ok

21 files changed, 3272 insertions, 0 deletions

diff --git a/node_modules/mongoose/support/expresso/.gitmodules b/node_modules/mongoose/support/expresso/.gitmodules
new file mode 100644
index 0000000..191ddeb
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "deps/jscoverage"]
+	path = deps/jscoverage
+	url = git://github.com/visionmedia/node-jscoverage.git
diff --git a/node_modules/mongoose/support/expresso/.npmignore b/node_modules/mongoose/support/expresso/.npmignore
new file mode 100644
index 0000000..432563f
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/.npmignore
@@ -0,0 +1,3 @@
+.DS_Store
+lib-cov
+*.seed
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/History.md b/node_modules/mongoose/support/expresso/History.md
new file mode 100644
index 0000000..cb16fa9
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/History.md
@@ -0,0 +1,128 @@
+
+0.7.2 / 2010-12-29 
+==================
+
+  * Fixed problem with `listen()` sometimes firing on the same tick [guillermo]
+
+0.7.1 / 2010-12-28 
+==================
+
+  * Fixed `assert.request()` client logic into an issue() function, fired upon the `listen()` callback if the server doesn't have an assigned fd. [guillermo]
+  * Removed `--watch`
+
+0.7.0 / 2010-11-19 
+==================
+
+  * Removed `assert` from test function signature
+    Just use `require('assert')` :) this will make integration
+    with libraries like [should](http://github.com/visionmedia/should) cleaner.
+
+0.6.4 / 2010-11-02 
+==================
+
+  * Added regexp support to `assert.response()` headers
+  * Removed `waitForExit` code, causing issues
+
+0.6.3 / 2010-11-02 
+==================
+
+  * Added `assert.response()` body RegExp support
+  * Fixed issue with _--serial_ not executing files sequentially. Closes #42
+  * Fixed hang when modules use `setInterval` - monitor running tests & force the process to quit after all have completed + timeout [Steve Mason]
+
+0.6.2 / 2010-09-17 
+==================
+
+  * Added _node-jsocoverage_ to package.json (aka will respect npm's binroot)
+  * Added _-t, --timeout_ MS option, defaulting to 2000 ms
+  * Added _-s, --serial_
+  * __PREFIX__ clobberable
+  * Fixed `assert.response()` for latest node
+  * Fixed cov reporting from exploding on empty files
+
+0.6.2 / 2010-08-03
+==================
+
+  * Added `assert.type()`
+  * Renamed `assert.isNotUndefined()` to `assert.isDefined()`
+  * Fixed `assert.includes()` param ordering
+
+0.6.0 / 2010-07-31
+==================
+
+  * Added _docs/api.html_
+  * Added -w, --watch
+  * Added `Array` support to `assert.includes()`
+  * Added; outputting exceptions immediately. Closes #19
+  * Fixed `assert.includes()` param ordering
+  * Fixed `assert.length()` param ordering
+  * Fixed jscoverage links
+
+0.5.0 / 2010-07-16
+==================
+
+  * Added support for async exports
+  * Added timeout support to `assert.response()`. Closes #3
+  * Added 4th arg callback support to `assert.response()`
+  * Added `assert.length()`
+  * Added `assert.match()`
+  * Added `assert.isUndefined()`
+  * Added `assert.isNull()`
+  * Added `assert.includes()`
+  * Added growlnotify support via -g, --growl
+  * Added -o, --only TESTS. Ex: --only "test foo()" --only "test foo(), test bar()"
+  * Removed profanity
+
+0.4.0 / 2010-07-09
+==================
+
+  * Added reporting source coverage (respects --boring for color haters)
+  * Added callback to assert.response(). Closes #12
+  * Fixed; putting exceptions to stderr. Closes #13
+
+0.3.1 / 2010-06-28
+==================
+
+  * Faster assert.response()
+
+0.3.0 / 2010-06-28
+==================
+
+  * Added -p, --port NUM flags
+  * Added assert.response(). Closes #11
+
+0.2.1 / 2010-06-25
+==================
+
+  * Fixed issue with reporting object assertions
+
+0.2.0 / 2010-06-21
+==================
+
+  * Added `make uninstall`
+  * Added better readdir() failure message
+  * Fixed `make install` for kiwi
+
+0.1.0 / 2010-06-15
+==================
+
+  * Added better usage docs via --help
+  * Added better conditional color support
+  * Added pre exit assertion support
+
+0.0.3 / 2010-06-02
+==================
+
+  * Added more room for filenames in test coverage
+  * Added boring output support via --boring (suppress colored output)
+  * Fixed async failure exit status
+
+0.0.2 / 2010-05-30
+==================
+
+  * Fixed exit status for CI support
+
+0.0.1 / 2010-05-30
+==================
+
+  * Initial release
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/Makefile b/node_modules/mongoose/support/expresso/Makefile
new file mode 100644
index 0000000..8acfe56
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/Makefile
@@ -0,0 +1,53 @@
+
+PREFIX ?= /usr/local
+BIN = bin/expresso
+JSCOV = deps/jscoverage/node-jscoverage
+DOCS = docs/index.md
+HTMLDOCS = $(DOCS:.md=.html)
+
+test: $(BIN)
+	@./$(BIN) -I lib --growl $(TEST_FLAGS) test/*.test.js
+
+test-cov:
+	@./$(BIN) -I lib --cov $(TEST_FLAGS) test/*.test.js
+
+test-serial:
+	@./$(BIN) --serial -I lib $(TEST_FLAGS) test/serial/*.test.js
+
+install: install-jscov install-expresso
+
+uninstall:
+	rm -f $(PREFIX)/bin/expresso
+	rm -f $(PREFIX)/bin/node-jscoverage
+
+install-jscov: $(JSCOV)
+	install $(JSCOV) $(PREFIX)/bin
+
+install-expresso:
+	install $(BIN) $(PREFIX)/bin
+
+$(JSCOV):
+	cd deps/jscoverage && ./configure && make && mv jscoverage node-jscoverage
+
+clean:
+	@cd deps/jscoverage && git clean -fd
+
+docs: docs/api.html $(HTMLDOCS)
+
+%.html: %.md
+	@echo "... $< > $@"
+	@ronn -5 --pipe --fragment $< \
+		| cat docs/layout/head.html - docs/layout/foot.html \
+		> $@
+
+docs/api.html: bin/expresso
+	dox \
+		--title "Expresso" \
+		--ribbon "http://github.com/visionmedia/expresso" \
+		--desc "Insanely fast TDD framework for [node](http://nodejs.org) featuring code coverage reporting." \
+		$< > $@
+
+docclean:
+	rm -f docs/*.html
+
+.PHONY: test test-cov install uninstall install-expresso install-jscov clean docs docclean
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/Readme.md b/node_modules/mongoose/support/expresso/Readme.md
new file mode 100644
index 0000000..05c972e
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/Readme.md
@@ -0,0 +1,61 @@
+
+# Expresso
+
+  TDD framework for [nodejs](http://nodejs.org).
+  
+## Features
+
+  - light-weight
+  - intuitive async support
+  - intuitive test runner executable
+  - test coverage support and reporting
+  - uses the _assert_ module
+  - `assert.eql()` alias of `assert.deepEqual()`
+  - `assert.response()` http response utility
+  - `assert.includes()`
+  - `assert.type()`
+  - `assert.isNull()`
+  - `assert.isUndefined()`
+  - `assert.isNotNull()`
+  - `assert.isDefined()`
+  - `assert.match()`
+  - `assert.length()`
+
+## Installation
+
+To install both expresso _and_ node-jscoverage run:
+
+    $ make install
+
+To install expresso alone (no build required) run:
+
+    $ make install-expresso
+
+Install via npm:
+
+	$ npm install expresso
+
+## License 
+
+(The MIT License)
+
+Copyright (c) 2010 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/mongoose/support/expresso/bin/expresso b/node_modules/mongoose/support/expresso/bin/expresso
new file mode 100755
index 0000000..fd98fff
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/bin/expresso
@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+
+/*
+ * Expresso
+ * Copyright(c) TJ Holowaychuk <tj@vision-media.ca>
+ * (MIT Licensed)
+ */
+ 
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert'),
+    childProcess = require('child_process'),
+    http = require('http'),
+    path = require('path'),
+    sys = require('sys'),
+    cwd = process.cwd(),
+    fs = require('fs'),
+    defer;
+
+/**
+ * Expresso version.
+ */
+
+var version = '0.7.2';
+
+/**
+ * Failure count.
+ */
+
+var failures = 0;
+
+
+/**
+ * Number of tests executed.
+ */
+
+var testcount = 0;
+
+/**
+ * Whitelist of tests to run.
+ */
+ 
+var only = [];
+
+/**
+ * Boring output.
+ */
+ 
+var boring = false;
+
+/**
+ * Growl notifications.
+ */
+
+var growl = false;
+
+/**
+ * Server port.
+ */
+
+var port = 5555;
+
+/**
+ * Execute serially.
+ */
+
+var serial = false;
+
+/**
+ * Default timeout.
+ */
+
+var timeout = 2000;
+
+/**
+ * Quiet output.
+ */
+
+var quiet = false;
+
+/**
+ * Usage documentation.
+ */
+
+var usage = ''
+    + '[bold]{Usage}: expresso [options] <file ...>'
+    + '\n'
+    + '\n[bold]{Options}:'
+    + '\n  -g, --growl          Enable growl notifications'
+    + '\n  -c, --coverage       Generate and report test coverage'
+    + '\n  -q, --quiet          Suppress coverage report if 100%'
+    + '\n  -t, --timeout MS     Timeout in milliseconds, defaults to 2000'
+    + '\n  -r, --require PATH   Require the given module path'
+    + '\n  -o, --only TESTS     Execute only the comma sperated TESTS (can be set several times)'
+    + '\n  -I, --include PATH   Unshift the given path to require.paths'
+    + '\n  -p, --port NUM       Port number for test servers, starts at 5555'
+    + '\n  -s, --serial         Execute tests serially'
+    + '\n  -b, --boring         Suppress ansi-escape colors'
+    + '\n  -v, --version        Output version number'
+    + '\n  -h, --help           Display help information'
+    + '\n';
+
+// Parse arguments
+
+var files = [],
+    args = process.argv.slice(2);
+
+while (args.length) {
+    var arg = args.shift();
+    switch (arg) {
+        case '-h':
+        case '--help':
+            print(usage + '\n');
+            process.exit(1);
+            break;
+        case '-v':
+        case '--version':
+            sys.puts(version);
+            process.exit(1);
+            break;
+        case '-i':
+        case '-I':
+        case '--include':
+            if (arg = args.shift()) {
+                require.paths.unshift(arg);
+            } else {
+                throw new Error('--include requires a path');
+            }
+            break;
+        case '-o':
+        case '--only':
+            if (arg = args.shift()) {
+                only = only.concat(arg.split(/ *, */));
+            } else {
+                throw new Error('--only requires comma-separated test names');
+            }
+            break;
+        case '-p':
+        case '--port':
+            if (arg = args.shift()) {
+                port = parseInt(arg, 10);
+            } else {
+                throw new Error('--port requires a number');
+            }
+            break;
+        case '-r':
+        case '--require':
+            if (arg = args.shift()) {
+                require(arg);
+            } else {
+                throw new Error('--require requires a path');
+            }
+            break;
+        case '-t':
+        case '--timeout':
+          if (arg = args.shift()) {
+            timeout = parseInt(arg, 10);
+          } else {
+            throw new Error('--timeout requires an argument');
+          }
+          break;
+        case '-c':
+        case '--cov':
+        case '--coverage':
+            defer = true;
+            childProcess.exec('rm -fr lib-cov && node-jscoverage lib lib-cov', function(err){
+                if (err) throw err;
+                require.paths.unshift('lib-cov');
+                run(files);
+            })
+            break;
+        case '-q':
+        case '--quiet':
+            quiet = true;
+            break;
+        case '-b':
+        case '--boring':
+        	boring = true;
+        	break;
+        case '-g':
+        case '--growl':
+            growl = true;
+            break;
+        case '-s':
+        case '--serial':
+            serial = true;
+            break;
+        default:
+            if (/\.js$/.test(arg)) {
+                files.push(arg);
+            }
+            break;
+    }
+}
+
+/**
+ * Colorized sys.error().
+ *
+ * @param {String} str
+ */
+
+function print(str){
+    sys.error(colorize(str));
+}
+
+/**
+ * Colorize the given string using ansi-escape sequences.
+ * Disabled when --boring is set.
+ *
+ * @param {String} str
+ * @return {String}
+ */
+
+function colorize(str){
+    var colors = { bold: 1, red: 31, green: 32, yellow: 33 };
+    return str.replace(/\[(\w+)\]\{([^]*?)\}/g, function(_, color, str){
+        return boring
+            ? str
+            : '\x1B[' + colors[color] + 'm' + str + '\x1B[0m';
+    });
+}
+
+// Alias deepEqual as eql for complex equality
+
+assert.eql = assert.deepEqual;
+
+/**
+ * Assert that `val` is null.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ */
+
+assert.isNull = function(val, msg) {
+    assert.strictEqual(null, val, msg);
+};
+
+/**
+ * Assert that `val` is not null.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ */
+
+assert.isNotNull = function(val, msg) {
+    assert.notStrictEqual(null, val, msg);
+};
+
+/**
+ * Assert that `val` is undefined.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ */
+
+assert.isUndefined = function(val, msg) {
+    assert.strictEqual(undefined, val, msg);
+};
+
+/**
+ * Assert that `val` is not undefined.
+ *
+ * @param {Mixed} val
+ * @param {String} msg
+ */
+
+assert.isDefined = function(val, msg) {
+    assert.notStrictEqual(undefined, val, msg);
+};
+
+/**
+ * Assert that `obj` is `type`.
+ *
+ * @param {Mixed} obj
+ * @param {String} type
+ * @api public
+ */
+
+assert.type = function(obj, type, msg){
+    var real = typeof obj;
+    msg = msg || 'typeof ' + sys.inspect(obj) + ' is ' + real + ', expected ' + type;
+    assert.ok(type === real, msg);
+};
+
+/**
+ * Assert that `str` matches `regexp`.
+ *
+ * @param {String} str
+ * @param {RegExp} regexp
+ * @param {String} msg
+ */
+
+assert.match = function(str, regexp, msg) {
+    msg = msg || sys.inspect(str) + ' does not match ' + sys.inspect(regexp);
+    assert.ok(regexp.test(str), msg);
+};
+
+/**
+ * Assert that `val` is within `obj`.
+ *
+ * Examples:
+ *
+ *    assert.includes('foobar', 'bar');
+ *    assert.includes(['foo', 'bar'], 'foo');
+ *
+ * @param {String|Array} obj
+ * @param {Mixed} val
+ * @param {String} msg
+ */
+
+assert.includes = function(obj, val, msg) {
+    msg = msg || sys.inspect(obj) + ' does not include ' + sys.inspect(val);
+    assert.ok(obj.indexOf(val) >= 0, msg);
+};
+
+/**
+ * Assert length of `val` is `n`.
+ *
+ * @param {Mixed} val
+ * @param {Number} n
+ * @param {String} msg
+ */
+
+assert.length = function(val, n, msg) {
+    msg = msg || sys.inspect(val) + ' has length of ' + val.length + ', expected ' + n;
+    assert.equal(n, val.length, msg);
+};
+
+/**
+ * Assert response from `server` with
+ * the given `req` object and `res` assertions object.
+ *
+ * @param {Server} server
+ * @param {Object} req
+ * @param {Object|Function} res
+ * @param {String} msg
+ */
+
+assert.response = function(server, req, res, msg){
+    // Check that the server is ready or defer
+    if (!server.fd) {
+        if (!('__deferred' in server)) {
+            server.__deferred = [];
+        }
+        server.__deferred.push(arguments);
+        if (!server.__started) {
+            server.listen(server.__port = port++, '127.0.0.1', function(){
+                if (server.__deferred) {
+                    process.nextTick(function(){
+                        server.__deferred.forEach(function(args){
+                          assert.response.apply(assert, args);
+                        });
+                    });
+                }
+            });
+            server.__started = true;
+        }
+        return;
+    }
+
+    // Callback as third or fourth arg
+    var callback = typeof res === 'function'
+        ? res
+        : typeof msg === 'function'
+            ? msg
+            : function(){};
+
+    // Default messate to test title
+    if (typeof msg === 'function') msg = null;
+    msg = msg || assert.testTitle;
+    msg += '. ';
+
+    // Pending responses
+    server.__pending = server.__pending || 0;
+    server.__pending++;
+
+    // Create client
+    if (!server.fd) {
+        server.listen(server.__port = port++, '127.0.0.1', issue);
+    } else {
+        issue();
+    }
+
+    function issue(){
+        if (!server.client)
+            server.client = http.createClient(server.__port);
+
+        // Issue request
+        var timer,
+            client = server.client,
+            method = req.method || 'GET',
+            status = res.status || res.statusCode,
+            data = req.data || req.body,
+            requestTimeout = req.timeout || 0;
+
+        var request = client.request(method, req.url, req.headers);
+
+        // Timeout
+        if (requestTimeout) {
+            timer = setTimeout(function(){
+                --server.__pending || server.close();
+                delete req.timeout;
+                assert.fail(msg + 'Request timed out after ' + requestTimeout + 'ms.');
+            }, requestTimeout);
+        }
+
+        if (data) request.write(data);
+        request.addListener('response', function(response){
+            response.body = '';
+            response.setEncoding('utf8');
+            response.addListener('data', function(chunk){ response.body += chunk; });
+            response.addListener('end', function(){
+                --server.__pending || server.close();
+                if (timer) clearTimeout(timer);
+
+                // Assert response body
+                if (res.body !== undefined) {
+                    var eql = res.body instanceof RegExp
+                      ? res.body.test(response.body)
+                      : res.body === response.body;
+                    assert.ok(
+                        eql,
+                        msg + 'Invalid response body.\n'
+                            + '    Expected: ' + sys.inspect(res.body) + '\n'
+                            + '    Got: ' + sys.inspect(response.body)
+                    );
+                }
+
+                // Assert response status
+                if (typeof status === 'number') {
+                    assert.equal(
+                        response.statusCode,
+                        status,
+                        msg + colorize('Invalid response status code.\n'
+                            + '    Expected: [green]{' + status + '}\n'
+                            + '    Got: [red]{' + response.statusCode + '}')
+                    );
+                }
+
+                // Assert response headers
+                if (res.headers) {
+                    var keys = Object.keys(res.headers);
+                    for (var i = 0, len = keys.length; i < len; ++i) {
+                        var name = keys[i],
+                            actual = response.headers[name.toLowerCase()],
+                            expected = res.headers[name],
+                            eql = expected instanceof RegExp
+                              ? expected.test(actual)
+                              : expected == actual;
+                        assert.ok(
+                            eql,
+                            msg + colorize('Invalid response header [bold]{' + name + '}.\n'
+                                + '    Expected: [green]{' + expected + '}\n'
+                                + '    Got: [red]{' + actual + '}')
+                        );
+                    }
+                }
+
+                // Callback
+                callback(response);
+            });
+        });
+        request.end();
+      }
+};
+
+/**
+ * Pad the given string to the maximum width provided.
+ *
+ * @param  {String} str
+ * @param  {Number} width
+ * @return {String}
+ */
+
+function lpad(str, width) {
+    str = String(str);
+    var n = width - str.length;
+    if (n < 1) return str;
+    while (n--) str = ' ' + str;
+    return str;
+}
+
+/**
+ * Pad the given string to the maximum width provided.
+ *
+ * @param  {String} str
+ * @param  {Number} width
+ * @return {String}
+ */
+
+function rpad(str, width) {
+    str = String(str);
+    var n = width - str.length;
+    if (n < 1) return str;
+    while (n--) str = str + ' ';
+    return str;
+}
+
+/**
+ * Report test coverage.
+ *
+ * @param  {Object} cov
+ */
+
+function reportCoverage(cov) {
+    // Stats
+    print('\n   [bold]{Test Coverage}\n');
+    var sep = '   +------------------------------------------+----------+------+------+--------+',
+        lastSep = '                                              +----------+------+------+--------+';
+    sys.puts(sep);
+    sys.puts('   | filename                                 | coverage | LOC  | SLOC | missed |');
+    sys.puts(sep);
+    for (var name in cov) {
+        var file = cov[name];
+        if (Array.isArray(file)) {
+            sys.print('   | ' + rpad(name, 40));
+            sys.print(' | ' + lpad(file.coverage.toFixed(2), 8));
+            sys.print(' | ' + lpad(file.LOC, 4));
+            sys.print(' | ' + lpad(file.SLOC, 4));
+            sys.print(' | ' + lpad(file.totalMisses, 6));
+            sys.print(' |\n');
+        }
+    }
+    sys.puts(sep);
+    sys.print('     ' + rpad('', 40));
+    sys.print(' | ' + lpad(cov.coverage.toFixed(2), 8));
+    sys.print(' | ' + lpad(cov.LOC, 4));
+    sys.print(' | ' + lpad(cov.SLOC, 4));
+    sys.print(' | ' + lpad(cov.totalMisses, 6));
+    sys.print(' |\n');
+    sys.puts(lastSep);
+    // Source
+    for (var name in cov) {
+        if (name.match(/\.js$/)) {
+            var file = cov[name];
+            if ((file.coverage < 100) || !quiet) {
+               print('\n   [bold]{' + name + '}:'); 
+               print(file.source);
+               sys.print('\n');
+            }
+        }
+    }
+}
+
+/**
+ * Populate code coverage data.
+ *
+ * @param  {Object} cov
+ */
+
+function populateCoverage(cov) {
+    cov.LOC = 
+    cov.SLOC =
+    cov.totalFiles =
+    cov.totalHits =
+    cov.totalMisses = 
+    cov.coverage = 0;
+    for (var name in cov) {
+        var file = cov[name];
+        if (Array.isArray(file)) {
+            // Stats
+            ++cov.totalFiles;
+            cov.totalHits += file.totalHits = coverage(file, true);
+            cov.totalMisses += file.totalMisses = coverage(file, false);
+            file.totalLines = file.totalHits + file.totalMisses;
+            cov.SLOC += file.SLOC = file.totalLines;
+            if (!file.source) file.source = [];
+            cov.LOC += file.LOC = file.source.length;
+            file.coverage = (file.totalHits / file.totalLines) * 100;
+            // Source
+            var width = file.source.length.toString().length;
+            file.source = file.source.map(function(line, i){
+                ++i;
+                var hits = file[i] === 0 ? 0 : (file[i] || ' ');
+                if (!boring) {
+                    if (hits === 0) {
+                        hits = '\x1b[31m' + hits + '\x1b[0m';
+                        line = '\x1b[41m' + line + '\x1b[0m';
+                    } else {
+                        hits = '\x1b[32m' + hits + '\x1b[0m';
+                    }
+                }
+                return '\n     ' + lpad(i, width) + ' | ' + hits + ' | ' + line;
+            }).join('');
+        }
+    }
+    cov.coverage = (cov.totalHits / cov.SLOC) * 100;
+}
+
+/**
+ * Total coverage for the given file data.
+ *
+ * @param  {Array} data
+ * @return {Type}
+ */
+
+function coverage(data, val) {
+    var n = 0;
+    for (var i = 0, len = data.length; i < len; ++i) {
+        if (data[i] !== undefined && data[i] == val) ++n;
+    }
+    return n;  
+}
+
+/**
+ * Test if all files have 100% coverage
+ *
+ * @param  {Object} cov
+ * @return {Boolean}
+ */
+
+function hasFullCoverage(cov) {
+  for (var name in cov) {
+    var file = cov[name];
+    if (file instanceof Array) {
+      if (file.coverage !== 100) {
+	      return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Run the given test `files`, or try _test/*_.
+ *
+ * @param  {Array} files
+ */
+
+function run(files) {
+    cursor(false);
+    if (!files.length) {
+        try {
+            files = fs.readdirSync('test').map(function(file){
+                return 'test/' + file;
+            });
+        } catch (err) {
+            print('\n  failed to load tests in [bold]{./test}\n');
+            ++failures;
+            process.exit(1);
+        }
+    }
+    runFiles(files);
+}
+
+/**
+ * Show the cursor when `show` is true, otherwise hide it.
+ *
+ * @param {Boolean} show
+ */
+
+function cursor(show) {
+    if (show) {
+        sys.print('\x1b[?25h');
+    } else {
+        sys.print('\x1b[?25l');
+    }
+}
+
+/**
+ * Run the given test `files`.
+ *
+ * @param {Array} files
+ */
+
+function runFiles(files) {
+    if (serial) {
+        (function next(){
+            if (files.length) {
+                runFile(files.shift(), next);
+            }
+        })();
+    } else {
+      files.forEach(runFile);
+    }
+}
+
+/**
+ * Run tests for the given `file`, callback `fn()` when finished.
+ *
+ * @param {String} file
+ * @param {Function} fn
+ */
+
+function runFile(file, fn) {
+    if (file.match(/\.js$/)) {
+        var title = path.basename(file),
+            file = path.join(cwd, file),
+            mod = require(file.replace(/\.js$/, ''));
+        (function check(){
+           var len = Object.keys(mod).length;
+           if (len) {
+               runSuite(title, mod, fn);
+           } else {
+               setTimeout(check, 20);
+           }
+        })();
+    }
+}
+
+/**
+ * Report `err` for the given `test` and `suite`.
+ *
+ * @param {String} suite
+ * @param {String} test
+ * @param {Error} err
+ */
+
+function error(suite, test, err) {
+    ++failures;
+    var name = err.name,
+        stack = err.stack.replace(err.name, ''),
+        label = test === 'uncaught'
+            ? test
+            : suite + ' ' + test;
+    print('\n   [bold]{' + label + '}: [red]{' + name + '}' + stack + '\n');
+}
+
+/**
+ * Run the given tests, callback `fn()` when finished.
+ *
+ * @param  {String} title
+ * @param  {Object} tests
+ * @param  {Function} fn
+ */
+
+var dots = 0;
+function runSuite(title, tests, fn) {
+    // Keys
+    var keys = only.length
+        ? only.slice(0)
+        : Object.keys(tests);
+
+    // Setup
+    var setup = tests.setup || function(fn){ fn(); };
+
+    // Iterate tests
+    (function next(){
+        if (keys.length) {
+            var key,
+                test = tests[key = keys.shift()];
+            // Non-tests
+            if (key === 'setup') return next();
+
+            // Run test
+            if (test) {
+                try {
+                    ++testcount;
+                    assert.testTitle = key;
+                    if (serial) {
+                        sys.print('.');
+                        if (++dots % 25 === 0) sys.print('\n');
+                        setup(function(){
+                            if (test.length < 1) {
+                                test();
+                                next();
+                            } else {
+                                var id = setTimeout(function(){
+                                    throw new Error("'" + key + "' timed out");
+                                }, timeout);
+                                test(function(){
+                                    clearTimeout(id);
+                                    next();
+                                });
+                            } 
+                        });
+                    } else {
+                        test(function(fn){
+                            addBeforeExit(function(){
+                                try {
+                                    fn();
+                                } catch (err) {
+                                    error(title, key, err);
+                                }
+                            });
+                        });
+                    }
+                } catch (err) {
+                    error(title, key, err);
+                }
+            }
+            if (!serial) next();
+        } else if (serial) {
+          fn();
+        }
+    })();
+}
+
+/**
+ * Adds before exit handlers with only one event handler
+ *
+ * @param {Function} callback
+ * @api private
+ */
+
+var beforeExitHandlers = [];
+
+function addBeforeExit (fn) {
+  if (!beforeExitHandlers.length)
+      process.on('beforeExit', function () {
+          for (var i = 0, l = beforeExitHandlers.length; i < l; i++)
+              beforeExitHandlers[i]();
+      });
+  beforeExitHandlers.push(fn);
+};
+
+/**
+ * Report exceptions.
+ */
+
+function report() {
+    cursor(true);
+    process.emit('beforeExit');
+    if (failures) {
+        print('\n   [bold]{Failures}: [red]{' + failures + '}\n\n');
+        notify('Failures: ' + failures);
+    } else {
+        if (serial) print('');
+        print('\n   [green]{100%} ' + testcount + ' tests\n');
+        notify('100% ok');
+    }
+    if (typeof _$jscoverage === 'object') {
+        populateCoverage(_$jscoverage);
+        if (!hasFullCoverage(_$jscoverage) || !quiet) {
+            reportCoverage(_$jscoverage);
+        }
+    }
+}
+
+/**
+ * Growl notify the given `msg`.
+ *
+ * @param {String} msg
+ */
+
+function notify(msg) {
+    if (growl) {
+        childProcess.exec('growlnotify -name Expresso -m "' + msg + '"');
+    }
+}
+
+// Report uncaught exceptions
+
+process.addListener('uncaughtException', function(err){
+    error('uncaught', 'uncaught', err);
+});
+
+// Show cursor
+
+['INT', 'TERM', 'QUIT'].forEach(function(sig){
+    process.addListener('SIG' + sig, function(){
+        cursor(true);
+        process.exit(1);
+    });
+});
+
+// Report test coverage when available
+// and emit "beforeExit" event to perform
+// final assertions
+
+var orig = process.emit;
+process.emit = function(event){
+    if (event === 'exit') {
+        report();
+        process.reallyExit(failures);
+    }
+    orig.apply(this, arguments);
+};
+
+// Run test files
+
+if (!defer) run(files);
diff --git a/node_modules/mongoose/support/expresso/docs/api.html b/node_modules/mongoose/support/expresso/docs/api.html
new file mode 100644
index 0000000..7b8fb2b
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/docs/api.html
@@ -0,0 +1,1080 @@
+<a href="http://github.com/visionmedia/expresso"><img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png"></a><html>
+	<head>
+		<title>Expresso</title>
+		<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
+		<style>body {
+    margin: 0;
+    padding: 0;
+    font: 14px/1.5 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
+    color: #252519;
+}
+a {
+    color: #252519;
+}
+a:hover {
+    text-decoration: underline;
+    color: #19469D;
+}
+p {
+    margin: 12px 0;
+}
+h1, h2, h3 {
+    margin: 0;
+    padding: 0;
+}
+table#source {
+    width: 100%;
+    border-collapse: collapse;
+}
+table#source td:first-child {
+    padding: 30px 40px 30px 40px;
+    vertical-align: top;
+}
+table#source td:first-child,
+table#source td:first-child pre {
+    width: 450px;
+}
+table#source td:last-child {
+    padding: 30px 0 30px 40px;
+    border-left: 1px solid #E5E5EE;
+    background: #F5F5FF;
+}
+table#source tr {
+    border-bottom: 1px solid #E5E5EE;
+}
+table#source tr.filename {
+    padding-top: 40px;
+    border-top: 1px solid #E5E5EE;
+}
+table#source tr.filename td:first-child {
+    text-transform: capitalize;
+}
+table#source tr.filename td:last-child {
+    font-size: 12px;
+}
+table#source tr.filename h2 {
+    margin: 0;
+    padding: 0;
+    cursor: pointer;
+}
+table#source tr.code h1,
+table#source tr.code h2,
+table#source tr.code h3 {
+    margin-top: 30px;
+    font-family: "Lucida Grande", "Helvetica Nueue", Arial, sans-serif;
+    font-size: 18px;
+}
+table#source tr.code h2 {
+    font-size: 16px;
+}
+table#source tr.code h3 {
+    font-size: 14px;
+}
+table#source tr.code ul {
+    margin: 15px 0 15px 35px;
+    padding: 0;
+}
+table#source tr.code ul li {
+    margin: 0;
+    padding: 1px 0;
+}
+table#source tr.code ul li p {
+    margin: 0;
+    padding: 0;
+}
+table#source tr.code td:first-child pre {
+    padding: 20px;
+}
+#ribbon {
+    position: fixed;
+    top: 0;
+    right: 0;
+}
+code .string { color: #219161; }
+code .regexp { color: #219161; }
+code .keyword { color: #954121; }
+code .number { color: #19469D; }
+code .comment { color: #bbb; }
+code .this { color: #19469D; }</style>
+		<script>
+			$(function(){
+				$('tr.code').hide();
+				$('tr.filename').toggle(function(){
+					$(this).nextUntil('.filename').fadeIn();
+				}, function(){
+					$(this).nextUntil('.filename').fadeOut();
+				});
+			});
+		</script>
+	</head>
+	<body>
+<table id="source"><tbody><tr><td><h1>Expresso</h1><p>Insanely fast TDD framework for <a href="http://nodejs.org">node</a> featuring code coverage reporting.</p></td><td></td></tr><tr class="filename"><td><h2 id="bin/expresso"><a href="#">expresso</a></h2></td><td>bin/expresso</td></tr><tr class="code">
+<td class="docs">
+<h1>!/usr/bin/env node</h1>
+</td>
+<td class="code">
+<pre><code>
+ * <span class="class">Expresso</span>
+ * <span class="class">Copyright</span>(<span class="variable">c</span>) <span class="class">TJ</span> <span class="class">Holowaychuk</span> &<span class="variable">lt</span>;<span class="variable">tj</span>@<span class="variable">vision</span>-<span class="variable">media</span>.<span class="variable">ca</span>&<span class="variable">gt</span>;
+ * (<span class="class">MIT</span> <span class="class">Licensed</span>)
+ </code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Module dependencies.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">assert</span> = <span class="variable">require</span>(<span class="string">'assert'</span>),
+    <span class="variable">childProcess</span> = <span class="variable">require</span>(<span class="string">'child_process'</span>),
+    <span class="variable">http</span> = <span class="variable">require</span>(<span class="string">'http'</span>),
+    <span class="variable">path</span> = <span class="variable">require</span>(<span class="string">'path'</span>),
+    <span class="variable">sys</span> = <span class="variable">require</span>(<span class="string">'sys'</span>),
+    <span class="variable">cwd</span> = <span class="variable">process</span>.<span class="variable">cwd</span>(),
+    <span class="variable">fs</span> = <span class="variable">require</span>(<span class="string">'fs'</span>),
+    <span class="variable">defer</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Expresso version.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">version</span> = <span class="string">'0.6.4'</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Failure count.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">failures</span> = <span class="number integer">0</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Number of tests executed.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">testcount</span> = <span class="number integer">0</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Whitelist of tests to run.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">only</span> = [];</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Boring output.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">boring</span> = <span class="variable">false</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Growl notifications.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">growl</span> = <span class="variable">false</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Server port.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">port</span> = <span class="number integer">5555</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Watch mode.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">watch</span> = <span class="variable">false</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Execute serially.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">serial</span> = <span class="variable">false</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Default timeout.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">timeout</span> = <span class="number integer">2000</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Usage documentation.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">usage</span> = <span class="string">''</span>
+    + <span class="string">'[bold]{Usage}: expresso [options] &lt;file ...&gt;'</span>
+    + <span class="string">'\n'</span>
+    + <span class="string">'\n[bold]{Options}:'</span>
+    + <span class="string">'\n  -w, --watch          Watch for modifications and re-execute tests'</span>
+    + <span class="string">'\n  -g, --growl          Enable growl notifications'</span>
+    + <span class="string">'\n  -c, --coverage       Generate and report test coverage'</span>
+    + <span class="string">'\n  -t, --timeout MS     Timeout in milliseconds, defaults to 2000'</span>
+    + <span class="string">'\n  -r, --require PATH   Require the given module path'</span>
+    + <span class="string">'\n  -o, --only TESTS     Execute only the comma sperated TESTS (can be set several times)'</span>
+    + <span class="string">'\n  -I, --include PATH   Unshift the given path to require.paths'</span>
+    + <span class="string">'\n  -p, --port NUM       Port number for test servers, starts at 5555'</span>
+    + <span class="string">'\n  -s, --serial         Execute tests serially'</span>
+    + <span class="string">'\n  -b, --boring         Suppress ansi-escape colors'</span>
+    + <span class="string">'\n  -v, --version        Output version number'</span>
+    + <span class="string">'\n  -h, --help           Display help information'</span>
+    + <span class="string">'\n'</span>;
+
+<span class="comment">// Parse arguments</span>
+
+<span class="keyword">var</span> <span class="variable">files</span> = [],
+    <span class="variable">args</span> = <span class="variable">process</span>.<span class="variable">argv</span>.<span class="variable">slice</span>(<span class="number integer">2</span>);
+
+<span class="keyword">while</span> (<span class="variable">args</span>.<span class="variable">length</span>) {
+    <span class="keyword">var</span> <span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>();
+    <span class="keyword">switch</span> (<span class="variable">arg</span>) {
+        <span class="keyword">case</span> <span class="string">'-h'</span>:
+        <span class="keyword">case</span> <span class="string">'--help'</span>:
+            <span class="variable">print</span>(<span class="variable">usage</span> + <span class="string">'\n'</span>);
+            <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-v'</span>:
+        <span class="keyword">case</span> <span class="string">'--version'</span>:
+            <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">version</span>);
+            <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-i'</span>:
+        <span class="keyword">case</span> <span class="string">'-I'</span>:
+        <span class="keyword">case</span> <span class="string">'--include'</span>:
+            <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
+                <span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="variable">arg</span>);
+            } <span class="keyword">else</span> {
+                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--include requires a path'</span>);
+            }
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-o'</span>:
+        <span class="keyword">case</span> <span class="string">'--only'</span>:
+            <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
+                <span class="variable">only</span> = <span class="variable">only</span>.<span class="variable">concat</span>(<span class="variable">arg</span>.<span class="variable">split</span>(<span class="regexp">/ *, */</span>));
+            } <span class="keyword">else</span> {
+                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--only requires comma-separated test names'</span>);
+            }
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-p'</span>:
+        <span class="keyword">case</span> <span class="string">'--port'</span>:
+            <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
+                <span class="variable">port</span> = <span class="variable">parseInt</span>(<span class="variable">arg</span>, <span class="number integer">10</span>);
+            } <span class="keyword">else</span> {
+                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--port requires a number'</span>);
+            }
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-r'</span>:
+        <span class="keyword">case</span> <span class="string">'--require'</span>:
+            <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
+                <span class="variable">require</span>(<span class="variable">arg</span>);
+            } <span class="keyword">else</span> {
+                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--require requires a path'</span>);
+            }
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-t'</span>:
+        <span class="keyword">case</span> <span class="string">'--timeout'</span>:
+          <span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
+            <span class="variable">timeout</span> = <span class="variable">parseInt</span>(<span class="variable">arg</span>, <span class="number integer">10</span>);
+          } <span class="keyword">else</span> {
+            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--timeout requires an argument'</span>);
+          }
+          <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-c'</span>:
+        <span class="keyword">case</span> <span class="string">'--cov'</span>:
+        <span class="keyword">case</span> <span class="string">'--coverage'</span>:
+            <span class="variable">defer</span> = <span class="variable">true</span>;
+            <span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'rm -fr lib-cov &amp;&amp; node-jscoverage lib lib-cov'</span>, <span class="keyword">function</span>(<span class="variable">err</span>){
+                <span class="keyword">if</span> (<span class="variable">err</span>) <span class="keyword">throw</span> <span class="variable">err</span>;
+                <span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="string">'lib-cov'</span>);
+                <span class="variable">run</span>(<span class="variable">files</span>);
+            })
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-b'</span>:
+        <span class="keyword">case</span> <span class="string">'--boring'</span>:
+        	<span class="variable">boring</span> = <span class="variable">true</span>;
+        	<span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-w'</span>:
+        <span class="keyword">case</span> <span class="string">'--watch'</span>:
+            <span class="variable">watch</span> = <span class="variable">true</span>;
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-g'</span>:
+        <span class="keyword">case</span> <span class="string">'--growl'</span>:
+            <span class="variable">growl</span> = <span class="variable">true</span>;
+            <span class="keyword">break</span>;
+        <span class="keyword">case</span> <span class="string">'-s'</span>:
+        <span class="keyword">case</span> <span class="string">'--serial'</span>:
+            <span class="variable">serial</span> = <span class="variable">true</span>;
+            <span class="keyword">break</span>;
+        <span class="keyword">default</span>:
+            <span class="keyword">if</span> (<span class="regexp">/\.js$/</span>.<span class="variable">test</span>(<span class="variable">arg</span>)) {
+                <span class="variable">files</span>.<span class="variable">push</span>(<span class="variable">arg</span>);
+            }
+            <span class="keyword">break</span>;
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Colorized sys.error().</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  str</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">print</span>(<span class="variable">str</span>){
+    <span class="variable">sys</span>.<span class="variable">error</span>(<span class="variable">colorize</span>(<span class="variable">str</span>));
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Colorize the given string using ansi-escape sequences.
+Disabled when --boring is set.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">colorize</span>(<span class="variable">str</span>){
+    <span class="keyword">var</span> <span class="variable">colors</span> = { <span class="variable">bold</span>: <span class="number integer">1</span>, <span class="variable">red</span>: <span class="number integer">31</span>, <span class="variable">green</span>: <span class="number integer">32</span>, <span class="variable">yellow</span>: <span class="number integer">33</span> };
+    <span class="keyword">return</span> <span class="variable">str</span>.<span class="variable">replace</span>(<span class="regexp">/\[(\w+)\]\{([^]*?)\}/g</span>, <span class="keyword">function</span>(<span class="variable">_</span>, <span class="variable">color</span>, <span class="variable">str</span>){
+        <span class="keyword">return</span> <span class="variable">boring</span>
+            ? <span class="variable">str</span>
+            : <span class="string">'\x1B['</span> + <span class="variable">colors</span>[<span class="variable">color</span>] + <span class="string">'m'</span> + <span class="variable">str</span> + <span class="string">'\x1B[0m'</span>;
+    });
+}
+
+<span class="comment">// Alias deepEqual as eql for complex equality</span>
+
+<span class="variable">assert</span>.<span class="variable">eql</span> = <span class="variable">assert</span>.<span class="variable">deepEqual</span>;</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>val</code> is null.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">isNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
+    <span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>val</code> is not null.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">isNotNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
+    <span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>val</code> is undefined.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">isUndefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
+    <span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>val</code> is not undefined.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">isDefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
+    <span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>obj</code> is <code>type</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  obj</p></li><li><p><strong>param</strong>: <em>String</em>  type</p></li><li><p><strong>api</strong>: <em>public</em></p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">type</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">type</span>, <span class="variable">msg</span>){
+    <span class="keyword">var</span> <span class="variable">real</span> = <span class="keyword">typeof</span> <span class="variable">obj</span>;
+    <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="string">'typeof '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' is '</span> + <span class="variable">real</span> + <span class="string">', expected '</span> + <span class="variable">type</span>;
+    <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">type</span> === <span class="variable">real</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>str</code> matches <code>regexp</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>RegExp</em>  regexp</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">match</span> = <span class="keyword">function</span>(<span class="variable">str</span>, <span class="variable">regexp</span>, <span class="variable">msg</span>) {
+    <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">str</span>) + <span class="string">' does not match '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">regexp</span>);
+    <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">regexp</span>.<span class="variable">test</span>(<span class="variable">str</span>), <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert that <code>val</code> is within <code>obj</code>.</p>
+
+<h2>Examples</h2>
+
+<p>   assert.includes('foobar', 'bar');
+   assert.includes(['foo', 'bar'], 'foo');</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String | Array</em>  obj</p></li><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">includes</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">val</span>, <span class="variable">msg</span>) {
+    <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' does not include '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>);
+    <span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">obj</span>.<span class="variable">indexOf</span>(<span class="variable">val</span>) &<span class="variable">gt</span>;= <span class="number integer">0</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert length of <code>val</code> is <code>n</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Mixed</em>  val</p></li><li><p><strong>param</strong>: <em>Number</em>  n</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">length</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">n</span>, <span class="variable">msg</span>) {
+    <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>) + <span class="string">' has length of '</span> + <span class="variable">val</span>.<span class="variable">length</span> + <span class="string">', expected '</span> + <span class="variable">n</span>;
+    <span class="variable">assert</span>.<span class="variable">equal</span>(<span class="variable">n</span>, <span class="variable">val</span>.<span class="variable">length</span>, <span class="variable">msg</span>);
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Assert response from <code>server</code> with
+the given <code>req</code> object and <code>res</code> assertions object.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Server</em>  server</p></li><li><p><strong>param</strong>: <em>Object</em>  req</p></li><li><p><strong>param</strong>: <em>Object | Function</em>  res</p></li><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="variable">assert</span>.<span class="variable">response</span> = <span class="keyword">function</span>(<span class="variable">server</span>, <span class="variable">req</span>, <span class="variable">res</span>, <span class="variable">msg</span>){
+    <span class="comment">// Callback as third or fourth arg</span>
+    <span class="keyword">var</span> <span class="variable">callback</span> = <span class="keyword">typeof</span> <span class="variable">res</span> === <span class="string">'function'</span>
+        ? <span class="variable">res</span>
+        : <span class="keyword">typeof</span> <span class="variable">msg</span> === <span class="string">'function'</span>
+            ? <span class="variable">msg</span>
+            : <span class="keyword">function</span>(){};
+
+    <span class="comment">// Default messate to test title</span>
+    <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">msg</span> === <span class="string">'function'</span>) <span class="variable">msg</span> = <span class="keyword">null</span>;
+    <span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">assert</span>.<span class="variable">testTitle</span>;
+    <span class="variable">msg</span> += <span class="string">'. '</span>;
+
+    <span class="comment">// Pending responses</span>
+    <span class="variable">server</span>.<span class="variable">__pending</span> = <span class="variable">server</span>.<span class="variable">__pending</span> || <span class="number integer">0</span>;
+    <span class="variable">server</span>.<span class="variable">__pending</span>++;
+
+    <span class="comment">// Create client</span>
+    <span class="keyword">if</span> (!<span class="variable">server</span>.<span class="variable">fd</span>) {
+        <span class="variable">server</span>.<span class="variable">listen</span>(<span class="variable">server</span>.<span class="variable">__port</span> = <span class="variable">port</span>++, <span class="string">'127.0.0.1'</span>);
+        <span class="variable">server</span>.<span class="variable">client</span> = <span class="variable">http</span>.<span class="variable">createClient</span>(<span class="variable">server</span>.<span class="variable">__port</span>);
+    }
+
+    <span class="comment">// Issue request</span>
+    <span class="keyword">var</span> <span class="variable">timer</span>,
+        <span class="variable">client</span> = <span class="variable">server</span>.<span class="variable">client</span>,
+        <span class="variable">method</span> = <span class="variable">req</span>.<span class="variable">method</span> || <span class="string">'GET'</span>,
+        <span class="variable">status</span> = <span class="variable">res</span>.<span class="variable">status</span> || <span class="variable">res</span>.<span class="variable">statusCode</span>,
+        <span class="variable">data</span> = <span class="variable">req</span>.<span class="variable">data</span> || <span class="variable">req</span>.<span class="variable">body</span>,
+        <span class="variable">requestTimeout</span> = <span class="variable">req</span>.<span class="variable">timeout</span> || <span class="number integer">0</span>;
+
+    <span class="keyword">var</span> <span class="variable">request</span> = <span class="variable">client</span>.<span class="variable">request</span>(<span class="variable">method</span>, <span class="variable">req</span>.<span class="variable">url</span>, <span class="variable">req</span>.<span class="variable">headers</span>);
+
+    <span class="comment">// Timeout</span>
+    <span class="keyword">if</span> (<span class="variable">requestTimeout</span>) {
+        <span class="variable">timer</span> = <span class="variable">setTimeout</span>(<span class="keyword">function</span>(){
+            --<span class="variable">server</span>.<span class="variable">__pending</span> || <span class="variable">server</span>.<span class="variable">close</span>();
+            <span class="keyword">delete</span> <span class="variable">req</span>.<span class="variable">timeout</span>;
+            <span class="variable">assert</span>.<span class="variable">fail</span>(<span class="variable">msg</span> + <span class="string">'Request timed out after '</span> + <span class="variable">requestTimeout</span> + <span class="string">'ms.'</span>);
+        }, <span class="variable">requestTimeout</span>);
+    }
+
+    <span class="keyword">if</span> (<span class="variable">data</span>) <span class="variable">request</span>.<span class="variable">write</span>(<span class="variable">data</span>);
+    <span class="variable">request</span>.<span class="variable">addListener</span>(<span class="string">'response'</span>, <span class="keyword">function</span>(<span class="variable">response</span>){
+        <span class="variable">response</span>.<span class="variable">body</span> = <span class="string">''</span>;
+        <span class="variable">response</span>.<span class="variable">setEncoding</span>(<span class="string">'utf8'</span>);
+        <span class="variable">response</span>.<span class="variable">addListener</span>(<span class="string">'data'</span>, <span class="keyword">function</span>(<span class="variable">chunk</span>){ <span class="variable">response</span>.<span class="variable">body</span> += <span class="variable">chunk</span>; });
+        <span class="variable">response</span>.<span class="variable">addListener</span>(<span class="string">'end'</span>, <span class="keyword">function</span>(){
+            --<span class="variable">server</span>.<span class="variable">__pending</span> || <span class="variable">server</span>.<span class="variable">close</span>();
+            <span class="keyword">if</span> (<span class="variable">timer</span>) <span class="variable">clearTimeout</span>(<span class="variable">timer</span>);
+
+            <span class="comment">// Assert response body</span>
+            <span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">body</span> !== <span class="variable">undefined</span>) {
+                <span class="keyword">var</span> <span class="variable">eql</span> = <span class="variable">res</span>.<span class="variable">body</span> <span class="variable">instanceof</span> <span class="class">RegExp</span>
+                  ? <span class="variable">res</span>.<span class="variable">body</span>.<span class="variable">test</span>(<span class="variable">response</span>.<span class="variable">body</span>)
+                  : <span class="variable">res</span>.<span class="variable">body</span> === <span class="variable">response</span>.<span class="variable">body</span>;
+                <span class="variable">assert</span>.<span class="variable">ok</span>(
+                    <span class="variable">eql</span>,
+                    <span class="variable">msg</span> + <span class="string">'Invalid response body.\n'</span>
+                        + <span class="string">'    Expected: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">res</span>.<span class="variable">body</span>) + <span class="string">'\n'</span>
+                        + <span class="string">'    Got: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">response</span>.<span class="variable">body</span>)
+                );
+            }
+
+            <span class="comment">// Assert response status</span>
+            <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">status</span> === <span class="string">'number'</span>) {
+                <span class="variable">assert</span>.<span class="variable">equal</span>(
+                    <span class="variable">response</span>.<span class="variable">statusCode</span>,
+                    <span class="variable">status</span>,
+                    <span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response status code.\n'</span>
+                        + <span class="string">'    Expected: [green]{'</span> + <span class="variable">status</span> + <span class="string">'}\n'</span>
+                        + <span class="string">'    Got: [red]{'</span> + <span class="variable">response</span>.<span class="variable">statusCode</span> + <span class="string">'}'</span>)
+                );
+            }
+
+            <span class="comment">// Assert response headers</span>
+            <span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">headers</span>) {
+                <span class="keyword">var</span> <span class="variable">keys</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">res</span>.<span class="variable">headers</span>);
+                <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">keys</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
+                    <span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">keys</span>[<span class="variable">i</span>],
+                        <span class="variable">actual</span> = <span class="variable">response</span>.<span class="variable">headers</span>[<span class="variable">name</span>.<span class="variable">toLowerCase</span>()],
+                        <span class="variable">expected</span> = <span class="variable">res</span>.<span class="variable">headers</span>[<span class="variable">name</span>],
+                        <span class="variable">eql</span> = <span class="variable">expected</span> <span class="variable">instanceof</span> <span class="class">RegExp</span>
+                          ? <span class="variable">expected</span>.<span class="variable">test</span>(<span class="variable">actual</span>)
+                          : <span class="variable">expected</span> == <span class="variable">actual</span>;
+                    <span class="variable">assert</span>.<span class="variable">ok</span>(
+                        <span class="variable">eql</span>,
+                        <span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response header [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}.\n'</span>
+                            + <span class="string">'    Expected: [green]{'</span> + <span class="variable">expected</span> + <span class="string">'}\n'</span>
+                            + <span class="string">'    Got: [red]{'</span> + <span class="variable">actual</span> + <span class="string">'}'</span>)
+                    );
+                }
+            }
+
+            <span class="comment">// Callback</span>
+            <span class="variable">callback</span>(<span class="variable">response</span>);
+        });
+    });
+    <span class="variable">request</span>.<span class="variable">end</span>();
+};</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Pad the given string to the maximum width provided.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>Number</em>  width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">lpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
+    <span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
+    <span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
+    <span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
+    <span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="string">' '</span> + <span class="variable">str</span>;
+    <span class="keyword">return</span> <span class="variable">str</span>;
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Pad the given string to the maximum width provided.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  str</p></li><li><p><strong>param</strong>: <em>Number</em>  width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">rpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
+    <span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
+    <span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
+    <span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
+    <span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="variable">str</span> + <span class="string">' '</span>;
+    <span class="keyword">return</span> <span class="variable">str</span>;
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Report test coverage.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">reportCoverage</span>(<span class="variable">cov</span>) {
+    <span class="variable">populateCoverage</span>(<span class="variable">cov</span>);
+    <span class="comment">// Stats</span>
+    <span class="variable">print</span>(<span class="string">'\n   [bold]{Test Coverage}\n'</span>);
+    <span class="keyword">var</span> <span class="variable">sep</span> = <span class="string">'   +------------------------------------------+----------+------+------+--------+'</span>,
+        <span class="variable">lastSep</span> = <span class="string">'                                              +----------+------+------+--------+'</span>;
+    <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
+    <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="string">'   | filename                                 | coverage | LOC  | SLOC | missed |'</span>);
+    <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
+    <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
+        <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
+        <span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'   | '</span> + <span class="variable">rpad</span>(<span class="variable">name</span>, <span class="number integer">40</span>));
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
+        }
+    }
+    <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'     '</span> + <span class="variable">rpad</span>(<span class="string">''</span>, <span class="number integer">40</span>));
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
+    <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
+    <span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">lastSep</span>);
+    <span class="comment">// Source</span>
+    <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
+        <span class="keyword">if</span> (<span class="variable">name</span>.<span class="variable">match</span>(<span class="regexp">/\.js$/</span>)) {
+            <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
+            <span class="variable">print</span>(<span class="string">'\n   [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}:'</span>);
+            <span class="variable">print</span>(<span class="variable">file</span>.<span class="variable">source</span>);
+            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\n'</span>);
+        }
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Populate code coverage data.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Object</em>  cov</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">populateCoverage</span>(<span class="variable">cov</span>) {
+    <span class="variable">cov</span>.<span class="class">LOC</span> = 
+    <span class="variable">cov</span>.<span class="class">SLOC</span> =
+    <span class="variable">cov</span>.<span class="variable">totalFiles</span> =
+    <span class="variable">cov</span>.<span class="variable">totalHits</span> =
+    <span class="variable">cov</span>.<span class="variable">totalMisses</span> = 
+    <span class="variable">cov</span>.<span class="variable">coverage</span> = <span class="number integer">0</span>;
+    <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
+        <span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
+        <span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
+            <span class="comment">// Stats</span>
+            ++<span class="variable">cov</span>.<span class="variable">totalFiles</span>;
+            <span class="variable">cov</span>.<span class="variable">totalHits</span> += <span class="variable">file</span>.<span class="variable">totalHits</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">true</span>);
+            <span class="variable">cov</span>.<span class="variable">totalMisses</span> += <span class="variable">file</span>.<span class="variable">totalMisses</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">false</span>);
+            <span class="variable">file</span>.<span class="variable">totalLines</span> = <span class="variable">file</span>.<span class="variable">totalHits</span> + <span class="variable">file</span>.<span class="variable">totalMisses</span>;
+            <span class="variable">cov</span>.<span class="class">SLOC</span> += <span class="variable">file</span>.<span class="class">SLOC</span> = <span class="variable">file</span>.<span class="variable">totalLines</span>;
+            <span class="keyword">if</span> (!<span class="variable">file</span>.<span class="variable">source</span>) <span class="variable">file</span>.<span class="variable">source</span> = [];
+            <span class="variable">cov</span>.<span class="class">LOC</span> += <span class="variable">file</span>.<span class="class">LOC</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>;
+            <span class="variable">file</span>.<span class="variable">coverage</span> = (<span class="variable">file</span>.<span class="variable">totalHits</span> / <span class="variable">file</span>.<span class="variable">totalLines</span>) * <span class="number integer">100</span>;
+            <span class="comment">// Source</span>
+            <span class="keyword">var</span> <span class="variable">width</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>.<span class="variable">toString</span>().<span class="variable">length</span>;
+            <span class="variable">file</span>.<span class="variable">source</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">line</span>, <span class="variable">i</span>){
+                ++<span class="variable">i</span>;
+                <span class="keyword">var</span> <span class="variable">hits</span> = <span class="variable">file</span>[<span class="variable">i</span>] === <span class="number integer">0</span> ? <span class="number integer">0</span> : (<span class="variable">file</span>[<span class="variable">i</span>] || <span class="string">' '</span>);
+                <span class="keyword">if</span> (!<span class="variable">boring</span>) {
+                    <span class="keyword">if</span> (<span class="variable">hits</span> === <span class="number integer">0</span>) {
+                        <span class="variable">hits</span> = <span class="string">'\x1b[31m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
+                        <span class="variable">line</span> = <span class="string">'\x1b[41m'</span> + <span class="variable">line</span> + <span class="string">'\x1b[0m'</span>;
+                    } <span class="keyword">else</span> {
+                        <span class="variable">hits</span> = <span class="string">'\x1b[32m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
+                    }
+                }
+                <span class="keyword">return</span> <span class="string">'\n     '</span> + <span class="variable">lpad</span>(<span class="variable">i</span>, <span class="variable">width</span>) + <span class="string">' | '</span> + <span class="variable">hits</span> + <span class="string">' | '</span> + <span class="variable">line</span>;
+            }).<span class="variable">join</span>(<span class="string">''</span>);
+        }
+    }
+    <span class="variable">cov</span>.<span class="variable">coverage</span> = (<span class="variable">cov</span>.<span class="variable">totalHits</span> / <span class="variable">cov</span>.<span class="class">SLOC</span>) * <span class="number integer">100</span>;
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Total coverage for the given file data.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Array</em>  data</p></li><li><p><strong>return</strong>: <em>Type</em> </p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">coverage</span>(<span class="variable">data</span>, <span class="variable">val</span>) {
+    <span class="keyword">var</span> <span class="variable">n</span> = <span class="number integer">0</span>;
+    <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">data</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
+        <span class="keyword">if</span> (<span class="variable">data</span>[<span class="variable">i</span>] !== <span class="variable">undefined</span> &<span class="variable">amp</span>;&<span class="variable">amp</span>; <span class="variable">data</span>[<span class="variable">i</span>] == <span class="variable">val</span>) ++<span class="variable">n</span>;
+    }
+    <span class="keyword">return</span> <span class="variable">n</span>;  
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Run the given test <code>files</code>, or try <em>test/*</em>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Array</em>  files</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">run</span>(<span class="variable">files</span>) {
+    <span class="keyword">if</span> (!<span class="variable">files</span>.<span class="variable">length</span>) {
+        <span class="keyword">try</span> {
+            <span class="variable">files</span> = <span class="variable">fs</span>.<span class="variable">readdirSync</span>(<span class="string">'test'</span>).<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">file</span>){
+                <span class="keyword">return</span> <span class="string">'test/'</span> + <span class="variable">file</span>;
+            });
+        } <span class="keyword">catch</span> (<span class="variable">err</span>) {
+            <span class="variable">print</span>(<span class="string">'\n  failed to load tests in [bold]{./test}\n'</span>);
+            ++<span class="variable">failures</span>;
+            <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
+        }
+    }
+    <span class="keyword">if</span> (<span class="variable">watch</span>) <span class="variable">watchFiles</span>(<span class="variable">files</span>);
+    <span class="variable">runFiles</span>(<span class="variable">files</span>);
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Show the cursor when <code>show</code> is true, otherwise hide it.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Boolean</em>  show</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">cursor</span>(<span class="variable">show</span>) {
+    <span class="keyword">if</span> (<span class="variable">show</span>) {
+        <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25h'</span>);
+    } <span class="keyword">else</span> {
+        <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25l'</span>);
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Run the given test <code>files</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Array</em>  files</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">runFiles</span>(<span class="variable">files</span>) {
+    <span class="keyword">if</span> (<span class="variable">serial</span>) {
+        (<span class="keyword">function</span> <span class="variable">next</span>(){
+            <span class="keyword">if</span> (<span class="variable">files</span>.<span class="variable">length</span>) {
+                <span class="variable">runFile</span>(<span class="variable">files</span>.<span class="variable">shift</span>(), <span class="variable">next</span>);
+            }
+        })();
+    } <span class="keyword">else</span> {
+      <span class="variable">files</span>.<span class="variable">forEach</span>(<span class="variable">runFile</span>);
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Run tests for the given <code>file</code>, callback <code>fn()</code> when finished.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  file</p></li><li><p><strong>param</strong>: <em>Function</em>  fn</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">runFile</span>(<span class="variable">file</span>, <span class="variable">fn</span>) {
+    <span class="keyword">if</span> (<span class="variable">file</span>.<span class="variable">match</span>(<span class="regexp">/\.js$/</span>)) {
+        <span class="keyword">var</span> <span class="variable">title</span> = <span class="variable">path</span>.<span class="variable">basename</span>(<span class="variable">file</span>),
+            <span class="variable">file</span> = <span class="variable">path</span>.<span class="variable">join</span>(<span class="variable">cwd</span>, <span class="variable">file</span>),
+            <span class="variable">mod</span> = <span class="variable">require</span>(<span class="variable">file</span>.<span class="variable">replace</span>(<span class="regexp">/\.js$/</span>, <span class="string">''</span>));
+        (<span class="keyword">function</span> <span class="variable">check</span>(){
+           <span class="keyword">var</span> <span class="variable">len</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">mod</span>).<span class="variable">length</span>;
+           <span class="keyword">if</span> (<span class="variable">len</span>) {
+               <span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">mod</span>, <span class="variable">fn</span>);
+           } <span class="keyword">else</span> {
+               <span class="variable">setTimeout</span>(<span class="variable">check</span>, <span class="number integer">20</span>);
+           }
+        })();
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Clear the module cache for the given <code>file</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  file</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">clearCache</span>(<span class="variable">file</span>) {
+    <span class="keyword">var</span> <span class="variable">keys</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">module</span>.<span class="variable">moduleCache</span>);
+    <span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">keys</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
+        <span class="keyword">var</span> <span class="variable">key</span> = <span class="variable">keys</span>[<span class="variable">i</span>];
+        <span class="keyword">if</span> (<span class="variable">key</span>.<span class="variable">indexOf</span>(<span class="variable">file</span>) === <span class="variable">key</span>.<span class="variable">length</span> - <span class="variable">file</span>.<span class="variable">length</span>) {
+            <span class="keyword">delete</span> <span class="variable">module</span>.<span class="variable">moduleCache</span>[<span class="variable">key</span>];
+        }
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Watch the given <code>files</code> for changes.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>Array</em>  files</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">watchFiles</span>(<span class="variable">files</span>) {
+    <span class="keyword">var</span> <span class="variable">p</span> = <span class="number integer">0</span>,
+        <span class="variable">c</span> = [<span class="string">'▫   '</span>, <span class="string">'▫▫  '</span>, <span class="string">'▫▫▫ '</span>, <span class="string">' ▫▫▫'</span>,
+             <span class="string">'  ▫▫'</span>, <span class="string">'   ▫'</span>, <span class="string">'   ▫'</span>, <span class="string">'  ▫▫'</span>,
+             <span class="string">'▫▫▫ '</span>, <span class="string">'▫▫  '</span>, <span class="string">'▫   '</span>],
+        <span class="variable">l</span> = <span class="variable">c</span>.<span class="variable">length</span>;
+    <span class="variable">cursor</span>(<span class="variable">false</span>);
+    <span class="variable">setInterval</span>(<span class="keyword">function</span>(){
+        <span class="variable">sys</span>.<span class="variable">print</span>(<span class="variable">colorize</span>(<span class="string">'  [green]{'</span> + <span class="variable">c</span>[<span class="variable">p</span>++ % <span class="variable">l</span>] + <span class="string">'} watching\r'</span>));
+    }, <span class="number integer">100</span>);
+    <span class="variable">files</span>.<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">file</span>){
+        <span class="variable">fs</span>.<span class="variable">watchFile</span>(<span class="variable">file</span>, { <span class="variable">interval</span>: <span class="number integer">100</span> }, <span class="keyword">function</span>(<span class="variable">curr</span>, <span class="variable">prev</span>){
+            <span class="keyword">if</span> (<span class="variable">curr</span>.<span class="variable">mtime</span> &<span class="variable">gt</span>; <span class="variable">prev</span>.<span class="variable">mtime</span>) {
+                <span class="variable">print</span>(<span class="string">'  [yellow]{◦} '</span> + <span class="variable">file</span>);
+                <span class="variable">clearCache</span>(<span class="variable">file</span>);
+                <span class="variable">runFile</span>(<span class="variable">file</span>);
+            }
+        });
+    });
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Report <code>err</code> for the given <code>test</code> and <code>suite</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  suite</p></li><li><p><strong>param</strong>: <em>String</em>  test</p></li><li><p><strong>param</strong>: <em>Error</em>  err</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">error</span>(<span class="variable">suite</span>, <span class="variable">test</span>, <span class="variable">err</span>) {
+    ++<span class="variable">failures</span>;
+    <span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">err</span>.<span class="variable">name</span>,
+        <span class="variable">stack</span> = <span class="variable">err</span>.<span class="variable">stack</span>.<span class="variable">replace</span>(<span class="variable">err</span>.<span class="variable">name</span>, <span class="string">''</span>),
+        <span class="keyword">label</span> = <span class="variable">test</span> === <span class="string">'uncaught'</span>
+            ? <span class="variable">test</span>
+            : <span class="variable">suite</span> + <span class="string">' '</span> + <span class="variable">test</span>;
+    <span class="variable">print</span>(<span class="string">'\n   [bold]{'</span> + <span class="keyword">label</span> + <span class="string">'}: [red]{'</span> + <span class="variable">name</span> + <span class="string">'}'</span> + <span class="variable">stack</span> + <span class="string">'\n'</span>);
+    <span class="keyword">if</span> (<span class="variable">watch</span>) <span class="variable">notify</span>(<span class="keyword">label</span> + <span class="string">' failed'</span>);
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Run the given tests, callback <code>fn()</code> when finished.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  title</p></li><li><p><strong>param</strong>: <em>Object</em>  tests</p></li><li><p><strong>param</strong>: <em>Function</em>  fn</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">var</span> <span class="variable">dots</span> = <span class="number integer">0</span>;
+<span class="keyword">function</span> <span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">tests</span>, <span class="variable">fn</span>) {
+    <span class="comment">// Keys</span>
+    <span class="keyword">var</span> <span class="variable">keys</span> = <span class="variable">only</span>.<span class="variable">length</span>
+        ? <span class="variable">only</span>.<span class="variable">slice</span>(<span class="number integer">0</span>)
+        : <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">tests</span>);
+
+    <span class="comment">// Setup</span>
+    <span class="keyword">var</span> <span class="variable">setup</span> = <span class="variable">tests</span>.<span class="variable">setup</span> || <span class="keyword">function</span>(<span class="variable">fn</span>){ <span class="variable">fn</span>(); };
+
+    <span class="comment">// Iterate tests</span>
+    (<span class="keyword">function</span> <span class="variable">next</span>(){
+        <span class="keyword">if</span> (<span class="variable">keys</span>.<span class="variable">length</span>) {
+            <span class="keyword">var</span> <span class="variable">key</span>,
+                <span class="variable">test</span> = <span class="variable">tests</span>[<span class="variable">key</span> = <span class="variable">keys</span>.<span class="variable">shift</span>()];
+            <span class="comment">// Non-tests</span>
+            <span class="keyword">if</span> (<span class="variable">key</span> === <span class="string">'setup'</span>) <span class="keyword">return</span> <span class="variable">next</span>();
+
+            <span class="comment">// Run test</span>
+            <span class="keyword">if</span> (<span class="variable">test</span>) {
+                <span class="keyword">try</span> {
+                    ++<span class="variable">testcount</span>;
+                    <span class="variable">assert</span>.<span class="variable">testTitle</span> = <span class="variable">key</span>;
+                    <span class="keyword">if</span> (<span class="variable">serial</span>) {
+                        <span class="keyword">if</span> (!<span class="variable">watch</span>) {
+                            <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'.'</span>);
+                            <span class="keyword">if</span> (++<span class="variable">dots</span> % <span class="number integer">25</span> === <span class="number integer">0</span>) <span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\n'</span>);
+                        }
+                        <span class="variable">setup</span>(<span class="keyword">function</span>(){
+                            <span class="keyword">if</span> (<span class="variable">test</span>.<span class="variable">length</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) {
+                                <span class="variable">test</span>();
+                                <span class="variable">next</span>();
+                            } <span class="keyword">else</span> {
+                                <span class="keyword">var</span> <span class="variable">id</span> = <span class="variable">setTimeout</span>(<span class="keyword">function</span>(){
+                                    <span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(&<span class="variable">quot</span>;<span class="string">'&quot; + key + &quot;'</span> <span class="variable">timed</span> <span class="variable">out</span>&<span class="variable">quot</span>;);
+                                }, <span class="variable">timeout</span>);
+                                <span class="variable">test</span>(<span class="keyword">function</span>(){
+                                    <span class="variable">clearTimeout</span>(<span class="variable">id</span>);
+                                    <span class="variable">next</span>();
+                                });
+                            } 
+                        });
+                    } <span class="keyword">else</span> {
+                        <span class="variable">test</span>(<span class="keyword">function</span>(<span class="variable">fn</span>){
+                            <span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'beforeExit'</span>, <span class="keyword">function</span>(){
+                                <span class="keyword">try</span> {
+                                    <span class="variable">fn</span>();
+                                } <span class="keyword">catch</span> (<span class="variable">err</span>) {
+                                    <span class="variable">error</span>(<span class="variable">title</span>, <span class="variable">key</span>, <span class="variable">err</span>);
+                                }
+                            });
+                        });
+                    }
+                } <span class="keyword">catch</span> (<span class="variable">err</span>) {
+                    <span class="variable">error</span>(<span class="variable">title</span>, <span class="variable">key</span>, <span class="variable">err</span>);
+                }
+            }
+            <span class="keyword">if</span> (!<span class="variable">serial</span>) <span class="variable">next</span>();
+        } <span class="keyword">else</span> <span class="keyword">if</span> (<span class="variable">serial</span>) {
+          <span class="variable">fn</span>();
+        }
+    })();
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Report exceptions.
+ </p>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">report</span>() {
+    <span class="variable">process</span>.<span class="variable">emit</span>(<span class="string">'beforeExit'</span>);
+    <span class="keyword">if</span> (<span class="variable">failures</span>) {
+        <span class="variable">print</span>(<span class="string">'\n   [bold]{Failures}: [red]{'</span> + <span class="variable">failures</span> + <span class="string">'}\n\n'</span>);
+        <span class="variable">notify</span>(<span class="string">'Failures: '</span> + <span class="variable">failures</span>);
+    } <span class="keyword">else</span> {
+        <span class="keyword">if</span> (<span class="variable">serial</span>) <span class="variable">print</span>(<span class="string">''</span>);
+        <span class="variable">print</span>(<span class="string">'\n   [green]{100%} '</span> + <span class="variable">testcount</span> + <span class="string">' tests\n'</span>);
+        <span class="variable">notify</span>(<span class="string">'100% ok'</span>);
+    }
+    <span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">_</span>$<span class="variable">jscoverage</span> === <span class="string">'object'</span>) {
+        <span class="variable">reportCoverage</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>);
+    }
+}</code></pre>
+</td>
+</tr>
+<tr class="code">
+<td class="docs">
+<p>Growl notify the given <code>msg</code>.</p>
+
+<h2></h2>
+
+<ul><li><p><strong>param</strong>: <em>String</em>  msg</p></li></ul>
+</td>
+<td class="code">
+<pre><code><span class="keyword">function</span> <span class="variable">notify</span>(<span class="variable">msg</span>) {
+    <span class="keyword">if</span> (<span class="variable">growl</span>) {
+        <span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'growlnotify -name Expresso -m &quot;'</span> + <span class="variable">msg</span> + <span class="string">'&quot;'</span>);
+    }
+}
+
+<span class="comment">// Report uncaught exceptions</span>
+
+<span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'uncaughtException'</span>, <span class="keyword">function</span>(<span class="variable">err</span>){
+    <span class="variable">error</span>(<span class="string">'uncaught'</span>, <span class="string">'uncaught'</span>, <span class="variable">err</span>);
+});
+
+<span class="comment">// Show cursor</span>
+
+[<span class="string">'INT'</span>, <span class="string">'TERM'</span>, <span class="string">'QUIT'</span>].<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">sig</span>){
+    <span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'SIG'</span> + <span class="variable">sig</span>, <span class="keyword">function</span>(){
+        <span class="variable">cursor</span>(<span class="variable">true</span>);
+        <span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
+    });
+});
+
+<span class="comment">// Report test coverage when available</span>
+<span class="comment">// and emit &quot;beforeExit&quot; event to perform</span>
+<span class="comment">// final assertions</span>
+
+<span class="keyword">var</span> <span class="variable">orig</span> = <span class="variable">process</span>.<span class="variable">emit</span>;
+<span class="variable">process</span>.<span class="variable">emit</span> = <span class="keyword">function</span>(<span class="variable">event</span>){
+    <span class="keyword">if</span> (<span class="variable">event</span> === <span class="string">'exit'</span>) {
+        <span class="variable">report</span>();
+        <span class="variable">process</span>.<span class="variable">reallyExit</span>(<span class="variable">failures</span>);
+    }
+    <span class="variable">orig</span>.<span class="variable">apply</span>(<span class="this">this</span>, <span class="variable">arguments</span>);
+};
+
+<span class="comment">// Run test files</span>
+
+<span class="keyword">if</span> (!<span class="variable">defer</span>) <span class="variable">run</span>(<span class="variable">files</span>);
+</code></pre>
+</td>
+</tr>	</body>
+</html></tbody></table>
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/docs/index.html b/node_modules/mongoose/support/expresso/docs/index.html
new file mode 100644
index 0000000..064313f
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/docs/index.html
@@ -0,0 +1,377 @@
+<html>
+	<head>
+		<title>Expresso - TDD Framework For Node</title>
+		<style>
+			body {
+				font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
+				text-align: center;
+			}
+			#ribbon {
+				position: absolute;
+				top: 0;
+				right: 0;
+				z-index: 10;
+			}
+			#wrapper {
+			  margin: 0 auto;
+				padding: 50px 80px;
+				width: 700px;
+				text-align: left;
+			}
+			h1, h2, h3 {
+				margin: 25px 0 15px 0;
+			}
+			h1 {
+			  font-size: 35px;
+			}
+			pre {
+				margin: 0 5px;
+				padding: 15px;
+				border: 1px solid #eee;
+			}
+			a {
+			  color: #00aaff;
+			}
+		</style>
+	</head>
+	<body>
+		<a href="http://github.com/visionmedia/expresso">
+			<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
+		</a>
+		<div id="wrapper">
+			<h1>Expresso</h1>
+<div class='mp'>
+<h2 id="NAME">NAME</h2>
+<p class="man-name">
+  <code>index</code>
+</p>
+<p><a href="http://github.com/visionmedia/expresso">Expresso</a> is a JavaScript <a href="http://en.wikipedia.org/wiki/Test-driven_development">TDD</a> framework written for <a href="http://nodejs.org">nodejs</a>. Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.</p>
+
+<h2 id="Features">Features</h2>
+
+<ul>
+<li>light-weight</li>
+<li>intuitive async support</li>
+<li>intuitive test runner executable</li>
+<li>test coverage support and reporting via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a></li>
+<li>uses and extends the core <em>assert</em> module</li>
+<li><code>assert.eql()</code> alias of <code>assert.deepEqual()</code></li>
+<li><code>assert.response()</code> http response utility</li>
+<li><code>assert.includes()</code></li>
+<li><code>assert.isNull()</code></li>
+<li><code>assert.isUndefined()</code></li>
+<li><code>assert.isNotNull()</code></li>
+<li><code>assert.isDefined()</code></li>
+<li><code>assert.match()</code></li>
+<li><code>assert.length()</code></li>
+</ul>
+
+
+<h2 id="Installation">Installation</h2>
+
+<p>To install both expresso <em>and</em> node-jscoverage run
+the command below, which will first compile node-jscoverage:</p>
+
+<pre><code>$ make install
+</code></pre>
+
+<p>To install expresso alone without coverage reporting run:</p>
+
+<pre><code>$ make install-expresso
+</code></pre>
+
+<p>Install via npm:</p>
+
+<pre><code>$ npm install expresso
+</code></pre>
+
+<h2 id="Examples">Examples</h2>
+
+<p>To define tests we simply export several functions:</p>
+
+<pre><code>exports['test String#length'] = function(){
+    assert.equal(6, 'foobar'.length);
+};
+</code></pre>
+
+<p>Alternatively for large numbers of tests you may want to
+export your own object containing the tests, however this
+is essentially the as above:</p>
+
+<pre><code>module.exports = {
+    'test String#length': function(){
+        assert.equal(6, 'foobar'.length);
+    }
+};
+</code></pre>
+
+<p>If you prefer not to use quoted keys:</p>
+
+<pre><code>exports.testsStringLength = function(){
+    assert.equal(6, 'foobar'.length);
+};
+</code></pre>
+
+<p>The argument passed to each callback is <em>beforeExit</em>,
+which is typically used to assert that callbacks have been
+invoked.</p>
+
+<pre><code>exports.testAsync = function(beforeExit){
+    var n = 0;
+    setTimeout(function(){
+        ++n;
+        assert.ok(true);
+    }, 200);
+    setTimeout(function(){
+        ++n;
+        assert.ok(true);
+    }, 200);
+    beforeExit(function(){
+        assert.equal(2, n, 'Ensure both timeouts are called');
+    });
+};
+</code></pre>
+
+<h2 id="Assert-Utilities">Assert Utilities</h2>
+
+<h3 id="assert-isNull-val-msg-">assert.isNull(val[, msg])</h3>
+
+<p>Asserts that the given <em>val</em> is <em>null</em>.</p>
+
+<pre><code>assert.isNull(null);
+</code></pre>
+
+<h3 id="assert-isNotNull-val-msg-">assert.isNotNull(val[, msg])</h3>
+
+<p>Asserts that the given <em>val</em> is not <em>null</em>.</p>
+
+<pre><code>assert.isNotNull(undefined);
+assert.isNotNull(false);
+</code></pre>
+
+<h3 id="assert-isUndefined-val-msg-">assert.isUndefined(val[, msg])</h3>
+
+<p>Asserts that the given <em>val</em> is <em>undefined</em>.</p>
+
+<pre><code>assert.isUndefined(undefined);
+</code></pre>
+
+<h3 id="assert-isDefined-val-msg-">assert.isDefined(val[, msg])</h3>
+
+<p>Asserts that the given <em>val</em> is not <em>undefined</em>.</p>
+
+<pre><code>assert.isDefined(null);
+assert.isDefined(false);
+</code></pre>
+
+<h3 id="assert-match-str-regexp-msg-">assert.match(str, regexp[, msg])</h3>
+
+<p>Asserts that the given <em>str</em> matches <em>regexp</em>.</p>
+
+<pre><code>assert.match('foobar', /^foo(bar)?/);
+assert.match('foo', /^foo(bar)?/);
+</code></pre>
+
+<h3 id="assert-length-val-n-msg-">assert.length(val, n[, msg])</h3>
+
+<p>Assert that the given <em>val</em> has a length of <em>n</em>.</p>
+
+<pre><code>assert.length([1,2,3], 3);
+assert.length('foo', 3);
+</code></pre>
+
+<h3 id="assert-type-obj-type-msg-">assert.type(obj, type[, msg])</h3>
+
+<p>Assert that the given <em>obj</em> is typeof <em>type</em>.</p>
+
+<pre><code>assert.type(3, 'number');
+</code></pre>
+
+<h3 id="assert-eql-a-b-msg-">assert.eql(a, b[, msg])</h3>
+
+<p>Assert that object <em>b</em> is equal to object <em>a</em>. This is an
+alias for the core <em>assert.deepEqual()</em> method which does complex
+comparisons, opposed to <em>assert.equal()</em> which uses <em>==</em>.</p>
+
+<pre><code>assert.eql('foo', 'foo');
+assert.eql([1,2], [1,2]);
+assert.eql({ foo: 'bar' }, { foo: 'bar' });
+</code></pre>
+
+<h3 id="assert-includes-obj-val-msg-">assert.includes(obj, val[, msg])</h3>
+
+<p>Assert that <em>obj</em> is within <em>val</em>. This method supports <em>Array_s
+and </em>Strings_s.</p>
+
+<pre><code>assert.includes([1,2,3], 3);
+assert.includes('foobar', 'foo');
+assert.includes('foobar', 'bar');
+</code></pre>
+
+<h3 id="assert-response-server-req-res-fn-msg-fn-">assert.response(server, req, res|fn[, msg|fn])</h3>
+
+<p>Performs assertions on the given <em>server</em>, which should <em>not</em> call
+listen(), as this is handled internally by expresso and the server
+is killed after all responses have completed. This method works with
+any <em>http.Server</em> instance, so <em>Connect</em> and <em>Express</em> servers will work
+as well.</p>
+
+<p>The <em>req</em> object may contain:</p>
+
+<ul>
+<li><em>url</em> request url</li>
+<li><em>timeout</em> timeout in milliseconds</li>
+<li><em>method</em> HTTP method</li>
+<li><em>data</em> request body</li>
+<li><em>headers</em> headers object</li>
+</ul>
+
+
+<p>The <em>res</em> object may be a callback function which
+receives the response for assertions, or an object
+which is then used to perform several assertions
+on the response with the following properties:</p>
+
+<ul>
+<li><em>body</em> assert response body (regexp or string)</li>
+<li><em>status</em> assert response status code</li>
+<li><em>header</em> assert that all given headers match (unspecified are ignored, use a regexp or string)</li>
+</ul>
+
+
+<p>When providing <em>res</em> you may then also pass a callback function
+as the fourth argument for additional assertions.</p>
+
+<p>Below are some examples:</p>
+
+<pre><code>assert.response(server, {
+    url: '/', timeout: 500
+}, {
+    body: 'foobar'
+});
+
+assert.response(server, {
+    url: '/',
+    method: 'GET'
+},{
+    body: '{"name":"tj"}',
+    status: 200,
+    headers: {
+        'Content-Type': 'application/json; charset=utf8',
+        'X-Foo': 'bar'
+    }
+});
+
+assert.response(server, {
+    url: '/foo',
+    method: 'POST',
+    data: 'bar baz'
+},{
+    body: '/foo bar baz',
+    status: 200
+}, 'Test POST');
+
+assert.response(server, {
+    url: '/foo',
+    method: 'POST',
+    data: 'bar baz'
+},{
+    body: '/foo bar baz',
+    status: 200
+}, function(res){
+    // All done, do some more tests if needed
+});
+
+assert.response(server, {
+    url: '/'
+}, function(res){
+    assert.ok(res.body.indexOf('tj') &gt;= 0, 'Test assert.response() callback');
+});
+</code></pre>
+
+<h2 id="expresso-1-">expresso(1)</h2>
+
+<p>To run a single test suite (file) run:</p>
+
+<pre><code>$ expresso test/a.test.js
+</code></pre>
+
+<p>To run several suites we may simply append another:</p>
+
+<pre><code>$ expresso test/a.test.js test/b.test.js
+</code></pre>
+
+<p>We can also pass a whitelist of tests to run within all suites:</p>
+
+<pre><code>$ expresso --only "foo()" --only "bar()"
+</code></pre>
+
+<p>Or several with one call:</p>
+
+<pre><code>$ expresso --only "foo(), bar()"
+</code></pre>
+
+<p>Globbing is of course possible as well:</p>
+
+<pre><code>$ expresso test/*
+</code></pre>
+
+<p>When expresso is called without any files, <em>test/*</em> is the default,
+so the following is equivalent to the command above:</p>
+
+<pre><code>$ expresso
+</code></pre>
+
+<p>If you wish to unshift a path to <code>require.paths</code> before
+running tests, you may use the <code>-I</code> or <code>--include</code> flag.</p>
+
+<pre><code>$ expresso --include lib test/*
+</code></pre>
+
+<p>The previous example is typically what I would recommend, since expresso
+supports test coverage via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a> (bundled with expresso),
+so you will need to expose an instrumented version of you library.</p>
+
+<p>To instrument your library, simply run <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a>,
+passing the <em>src</em> and <em>dest</em> directories:</p>
+
+<pre><code>$ node-jscoverage lib lib-cov
+</code></pre>
+
+<p>Now we can run our tests again, using the <em>lib-cov</em> directory that has been
+instrumented with coverage statements:</p>
+
+<pre><code>$ expresso -I lib-cov test/*
+</code></pre>
+
+<p>The output will look similar to below, depending on your test coverage of course :)</p>
+
+<p><img src="http://dl.dropbox.com/u/6396913/cov.png" alt="node coverage" /></p>
+
+<p>To make this process easier expresso has the <em>-c</em> or <em>--cov</em> which essentially
+does the same as the two commands above. The following two commands will
+run the same tests, however one will auto-instrument, and unshift <em>lib-cov</em>,
+and the other will run tests normally:</p>
+
+<pre><code>$ expresso -I lib test/*
+$ expresso -I lib --cov test/*
+</code></pre>
+
+<p>Currently coverage is bound to the <em>lib</em> directory, however in the
+future <code>--cov</code> will most likely accept a path.</p>
+
+<h2 id="Async-Exports">Async Exports</h2>
+
+<p>Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the <em>exports.foo = function(){};</em> syntax is supported for this:</p>
+
+<pre><code>setTimeout(function(){
+    exports['test async exports'] = function(){
+        assert.ok('wahoo');
+    };
+}, 100);
+</code></pre>
+
+</div>
+		</div>
+	</body>
+</html>
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/docs/index.md b/node_modules/mongoose/support/expresso/docs/index.md
new file mode 100644
index 0000000..489f931
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/docs/index.md
@@ -0,0 +1,290 @@
+
+[Expresso](http://github.com/visionmedia/expresso) is a JavaScript [TDD](http://en.wikipedia.org/wiki/Test-driven_development) framework written for [nodejs](http://nodejs.org). Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.
+
+## Features
+
+  - light-weight
+  - intuitive async support
+  - intuitive test runner executable
+  - test coverage support and reporting via [node-jscoverage](http://github.com/visionmedia/node-jscoverage)
+  - uses and extends the core _assert_ module
+  - `assert.eql()` alias of `assert.deepEqual()`
+  - `assert.response()` http response utility
+  - `assert.includes()`
+  - `assert.isNull()`
+  - `assert.isUndefined()`
+  - `assert.isNotNull()`
+  - `assert.isDefined()`
+  - `assert.match()`
+  - `assert.length()`
+
+## Installation
+
+To install both expresso _and_ node-jscoverage run
+the command below, which will first compile node-jscoverage:
+
+    $ make install
+
+To install expresso alone without coverage reporting run:
+
+    $ make install-expresso
+
+Install via npm:
+
+	$ npm install expresso
+
+## Examples
+
+To define tests we simply export several functions:
+
+	exports['test String#length'] = function(){
+		assert.equal(6, 'foobar'.length);
+	};
+
+Alternatively for large numbers of tests you may want to
+export your own object containing the tests, however this
+is essentially the as above:
+
+    module.exports = {
+      	'test String#length': function(){
+        	assert.equal(6, 'foobar'.length);
+      	}
+    };
+
+If you prefer not to use quoted keys:
+
+	exports.testsStringLength = function(){
+		assert.equal(6, 'foobar'.length);
+	};
+
+The argument passed to each callback is _beforeExit_,
+which is typically used to assert that callbacks have been
+invoked.
+
+    exports.testAsync = function(beforeExit){
+		var n = 0;
+      	setTimeout(function(){
+        	++n;
+        	assert.ok(true);
+      	}, 200);
+      	setTimeout(function(){
+        	++n;
+        	assert.ok(true);
+      	}, 200);
+		beforeExit(function(){
+			assert.equal(2, n, 'Ensure both timeouts are called');
+		});
+    };
+
+## Assert Utilities
+
+### assert.isNull(val[, msg])
+
+Asserts that the given _val_ is _null_.
+
+    assert.isNull(null);
+
+### assert.isNotNull(val[, msg])
+
+Asserts that the given _val_ is not _null_.
+
+    assert.isNotNull(undefined);
+    assert.isNotNull(false);
+
+### assert.isUndefined(val[, msg])
+
+Asserts that the given _val_ is _undefined_.
+
+    assert.isUndefined(undefined);
+
+### assert.isDefined(val[, msg])
+
+Asserts that the given _val_ is not _undefined_.
+
+    assert.isDefined(null);
+    assert.isDefined(false);
+
+### assert.match(str, regexp[, msg])
+
+Asserts that the given _str_ matches _regexp_.
+
+    assert.match('foobar', /^foo(bar)?/);
+    assert.match('foo', /^foo(bar)?/);
+
+### assert.length(val, n[, msg])
+
+Assert that the given _val_ has a length of _n_.
+
+    assert.length([1,2,3], 3);
+    assert.length('foo', 3);
+
+### assert.type(obj, type[, msg])
+
+Assert that the given _obj_ is typeof _type_.
+
+    assert.type(3, 'number');
+
+### assert.eql(a, b[, msg])
+
+Assert that object _b_ is equal to object _a_. This is an
+alias for the core _assert.deepEqual()_ method which does complex
+comparisons, opposed to _assert.equal()_ which uses _==_.
+
+    assert.eql('foo', 'foo');
+    assert.eql([1,2], [1,2]);
+    assert.eql({ foo: 'bar' }, { foo: 'bar' });
+
+### assert.includes(obj, val[, msg])
+
+Assert that _obj_ is within _val_. This method supports _Array_s
+and _Strings_s.
+
+    assert.includes([1,2,3], 3);
+    assert.includes('foobar', 'foo');
+    assert.includes('foobar', 'bar');
+
+### assert.response(server, req, res|fn[, msg|fn])
+
+Performs assertions on the given _server_, which should _not_ call
+listen(), as this is handled internally by expresso and the server 
+is killed after all responses have completed. This method works with
+any _http.Server_ instance, so _Connect_ and _Express_ servers will work
+as well.
+
+The _req_ object may contain:
+
+  - _url_ request url
+  - _timeout_ timeout in milliseconds
+  - _method_ HTTP method
+  - _data_ request body
+  - _headers_ headers object
+
+The _res_ object may be a callback function which
+receives the response for assertions, or an object
+which is then used to perform several assertions
+on the response with the following properties:
+
+  - _body_ assert response body (regexp or string)
+  - _status_ assert response status code
+  - _header_ assert that all given headers match (unspecified are ignored, use a regexp or string)
+
+When providing _res_ you may then also pass a callback function
+as the fourth argument for additional assertions.
+
+Below are some examples:
+
+    assert.response(server, {
+	  	url: '/', timeout: 500
+    }, {
+		body: 'foobar'
+    });
+
+    assert.response(server, {
+        url: '/',
+        method: 'GET'
+    },{
+        body: '{"name":"tj"}',
+        status: 200,
+        headers: {
+            'Content-Type': 'application/json; charset=utf8',
+			'X-Foo': 'bar'
+        }
+    });
+    
+    assert.response(server, {
+        url: '/foo',
+        method: 'POST',
+        data: 'bar baz'
+    },{
+        body: '/foo bar baz',
+        status: 200
+    }, 'Test POST');
+
+    assert.response(server, {
+        url: '/foo',
+        method: 'POST',
+        data: 'bar baz'
+    },{
+        body: '/foo bar baz',
+        status: 200
+    }, function(res){
+		// All done, do some more tests if needed
+	});
+
+    assert.response(server, {
+        url: '/'
+    }, function(res){
+        assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
+    });
+
+
+## expresso(1)
+
+To run a single test suite (file) run:
+
+    $ expresso test/a.test.js
+
+To run several suites we may simply append another:
+
+    $ expresso test/a.test.js test/b.test.js
+
+We can also pass a whitelist of tests to run within all suites:
+
+    $ expresso --only "foo()" --only "bar()"
+
+Or several with one call:
+
+    $ expresso --only "foo(), bar()"
+
+Globbing is of course possible as well:
+
+    $ expresso test/*
+
+When expresso is called without any files, _test/*_ is the default,
+so the following is equivalent to the command above:
+
+    $ expresso
+
+If you wish to unshift a path to `require.paths` before
+running tests, you may use the `-I` or `--include` flag.
+
+    $ expresso --include lib test/*
+
+The previous example is typically what I would recommend, since expresso
+supports test coverage via [node-jscoverage](http://github.com/visionmedia/node-jscoverage) (bundled with expresso),
+so you will need to expose an instrumented version of you library.
+
+To instrument your library, simply run [node-jscoverage](http://github.com/visionmedia/node-jscoverage),
+passing the _src_ and _dest_ directories:
+
+    $ node-jscoverage lib lib-cov
+
+Now we can run our tests again, using the _lib-cov_ directory that has been
+instrumented with coverage statements:
+
+    $ expresso -I lib-cov test/*
+
+The output will look similar to below, depending on your test coverage of course :)
+
+![node coverage](http://dl.dropbox.com/u/6396913/cov.png)
+
+To make this process easier expresso has the _-c_ or _--cov_ which essentially
+does the same as the two commands above. The following two commands will
+run the same tests, however one will auto-instrument, and unshift _lib-cov_,
+and the other will run tests normally:
+
+    $ expresso -I lib test/*
+    $ expresso -I lib --cov test/*
+
+Currently coverage is bound to the _lib_ directory, however in the
+future `--cov` will most likely accept a path.
+
+## Async Exports
+
+Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the _exports.foo = function(){};_ syntax is supported for this:
+    
+	setTimeout(function(){
+	    exports['test async exports'] = function(){
+	        assert.ok('wahoo');
+	    };
+	}, 100);
diff --git a/node_modules/mongoose/support/expresso/docs/layout/foot.html b/node_modules/mongoose/support/expresso/docs/layout/foot.html
new file mode 100644
index 0000000..44d85e9
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/docs/layout/foot.html
@@ -0,0 +1,3 @@
+		</div>
+	</body>
+</html>
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/docs/layout/head.html b/node_modules/mongoose/support/expresso/docs/layout/head.html
new file mode 100644
index 0000000..567f62e
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/docs/layout/head.html
@@ -0,0 +1,42 @@
+<html>
+	<head>
+		<title>Expresso - TDD Framework For Node</title>
+		<style>
+			body {
+				font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
+				text-align: center;
+			}
+			#ribbon {
+				position: absolute;
+				top: 0;
+				right: 0;
+				z-index: 10;
+			}
+			#wrapper {
+			  margin: 0 auto;
+				padding: 50px 80px;
+				width: 700px;
+				text-align: left;
+			}
+			h1, h2, h3 {
+				margin: 25px 0 15px 0;
+			}
+			h1 {
+			  font-size: 35px;
+			}
+			pre {
+				margin: 0 5px;
+				padding: 15px;
+				border: 1px solid #eee;
+			}
+			a {
+			  color: #00aaff;
+			}
+		</style>
+	</head>
+	<body>
+		<a href="http://github.com/visionmedia/expresso">
+			<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
+		</a>
+		<div id="wrapper">
+			<h1>Expresso</h1>
diff --git a/node_modules/mongoose/support/expresso/lib/bar.js b/node_modules/mongoose/support/expresso/lib/bar.js
new file mode 100644
index 0000000..e15aad4
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/lib/bar.js
@@ -0,0 +1,4 @@
+
+exports.bar = function(msg){
+    return msg || 'bar';
+};
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/lib/foo.js b/node_modules/mongoose/support/expresso/lib/foo.js
new file mode 100644
index 0000000..15701a5
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/lib/foo.js
@@ -0,0 +1,16 @@
+
+exports.foo = function(msg){
+    if (msg) {
+        return msg;
+    } else {
+        return generateFoo();
+    }
+};
+
+function generateFoo() {
+    return 'foo';
+}
+
+function Foo(msg){
+    this.msg = msg || 'foo';
+}
diff --git a/node_modules/mongoose/support/expresso/package.json b/node_modules/mongoose/support/expresso/package.json
new file mode 100644
index 0000000..569a54b
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/package.json
@@ -0,0 +1,12 @@
+{ "name": "expresso",
+  "version": "0.7.2",
+  "description": "TDD framework, light-weight, fast, CI-friendly",
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "bin": { 
+    "expresso": "./bin/expresso",
+    "node-jscoverage": "./deps/jscoverage/node-jscoverage"
+  },
+  "scripts": {
+    "preinstall": "make deps/jscoverage/node-jscoverage"	
+  }
+}
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/assert.test.js b/node_modules/mongoose/support/expresso/test/assert.test.js
new file mode 100644
index 0000000..f822595
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/assert.test.js
@@ -0,0 +1,91 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert');
+
+module.exports = {
+    'assert.eql()': function(){
+        assert.equal(assert.deepEqual, assert.eql);
+    },
+    
+    'assert.type()': function(){
+        assert.type('foobar', 'string');
+        assert.type(2, 'number');
+        assert.throws(function(){
+            assert.type([1,2,3], 'string');
+        });
+    },
+    
+    'assert.includes()': function(){
+        assert.includes('some random string', 'dom');
+        assert.throws(function(){
+           assert.include('some random string', 'foobar');
+        });
+
+        assert.includes(['foo', 'bar'], 'bar');
+        assert.includes(['foo', 'bar'], 'foo');
+        assert.includes([1,2,3], 3);
+        assert.includes([1,2,3], 2);
+        assert.includes([1,2,3], 1);
+        assert.throws(function(){
+            assert.includes(['foo', 'bar'], 'baz');
+        });
+        
+        assert.throws(function(){
+            assert.includes({ wrong: 'type' }, 'foo');
+        });
+    },
+    
+    'assert.isNull()': function(){
+        assert.isNull(null);
+        assert.throws(function(){
+            assert.isNull(undefined);
+        });
+        assert.throws(function(){
+            assert.isNull(false);
+        });
+    },
+    
+    'assert.isUndefined()': function(){
+        assert.isUndefined(undefined);
+        assert.throws(function(){
+            assert.isUndefined(null);
+        });
+        assert.throws(function(){
+            assert.isUndefined(false);
+        });
+    },
+    
+    'assert.isNotNull()': function(){
+        assert.isNotNull(false);
+        assert.isNotNull(undefined);
+        assert.throws(function(){
+            assert.isNotNull(null);
+        });
+    },
+    
+    'assert.isDefined()': function(){
+        assert.isDefined(false);
+        assert.isDefined(null);
+        assert.throws(function(){
+            assert.isDefined(undefined);
+        });
+    },
+    
+    'assert.match()': function(){
+        assert.match('foobar', /foo(bar)?/);
+        assert.throws(function(){
+            assert.match('something', /rawr/);
+        });
+    },
+    
+    'assert.length()': function(){
+        assert.length('test', 4);
+        assert.length([1,2,3,4], 4);
+        assert.throws(function(){
+            assert.length([1,2,3], 4);
+        });
+    }
+};
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/async.test.js b/node_modules/mongoose/support/expresso/test/async.test.js
new file mode 100644
index 0000000..d1d2036
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/async.test.js
@@ -0,0 +1,12 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert');
+
+setTimeout(function(){
+    exports['test async exports'] = function(){
+        assert.ok('wahoo');
+    };
+}, 100);
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/bar.test.js b/node_modules/mongoose/support/expresso/test/bar.test.js
new file mode 100644
index 0000000..cfc2e11
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/bar.test.js
@@ -0,0 +1,13 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert')
+  , bar = require('bar');
+
+module.exports = {
+    'bar()': function(){
+        assert.equal('bar', bar.bar());
+    }
+};
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/foo.test.js b/node_modules/mongoose/support/expresso/test/foo.test.js
new file mode 100644
index 0000000..ee5cff3
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/foo.test.js
@@ -0,0 +1,14 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert')
+  , foo = require('foo');
+
+module.exports = {
+    'foo()': function(){
+        assert.equal('foo', foo.foo());
+        assert.equal('foo', foo.foo());
+    }
+};
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/http.test.js b/node_modules/mongoose/support/expresso/test/http.test.js
new file mode 100644
index 0000000..41648d2
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/http.test.js
@@ -0,0 +1,109 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert')
+  , http = require('http');
+
+var server = http.createServer(function(req, res){
+    if (req.method === 'GET') {
+        if (req.url === '/delay') {
+            setTimeout(function(){
+                res.writeHead(200, {});
+                res.end('delayed');
+            }, 200);
+        } else {
+            var body = JSON.stringify({ name: 'tj' });
+            res.writeHead(200, {
+                'Content-Type': 'application/json; charset=utf8',
+                'Content-Length': body.length
+            });
+            res.end(body);
+        }
+    } else {
+        var body = '';
+        req.setEncoding('utf8');
+        req.addListener('data', function(chunk){ body += chunk });
+        req.addListener('end', function(){
+            res.writeHead(200, {});
+            res.end(req.url + ' ' + body);
+        });
+    }
+});
+
+var delayedServer = http.createServer(function(req, res){
+  res.writeHead(200);
+  res.end('it worked');
+});
+
+var oldListen = delayedServer.listen;
+delayedServer.listen = function(){
+  var args = arguments;
+  setTimeout(function(){
+    oldListen.apply(delayedServer, args);
+  }, 100);
+};
+
+module.exports = {
+    'test assert.response()': function(beforeExit){
+        var called = 0;
+
+        assert.response(server, {
+            url: '/',
+            method: 'GET'
+        },{
+            body: '{"name":"tj"}',
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json; charset=utf8'
+            }
+        });
+
+        assert.response(server, {
+            url: '/foo',
+            method: 'POST',
+            data: 'bar baz'
+        },{
+            body: '/foo bar baz',
+            status: 200
+        }, function(res){
+            ++called;
+            assert.ok(res);
+        });
+
+        assert.response(server, {
+            url: '/foo'
+        }, function(res){
+            ++called;
+            assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
+        });
+
+        assert.response(server,
+            { url: '/delay', timeout: 300 },
+            { body: 'delayed' });
+
+        beforeExit(function(){
+            assert.equal(2, called);
+        });
+    },
+
+    'test assert.response() regexp': function(){
+      assert.response(server,
+        { url: '/foo', method: 'POST', data: 'foobar' },
+        { body: /^\/foo foo(bar)?/ });
+    },
+    
+    'test assert.response() regexp headers': function(){
+      assert.response(server,
+        { url: '/' },
+        { body: '{"name":"tj"}', headers: { 'Content-Type': /^application\/json/ } });
+    },
+
+    // [!] if this test doesn't pass, an uncaught ECONNREFUSED will display
+    'test assert.response() with deferred listen()': function(){
+      assert.response(delayedServer,
+        { url: '/' },
+        { body: 'it worked' });
+    }
+};
diff --git a/node_modules/mongoose/support/expresso/test/serial/async.test.js b/node_modules/mongoose/support/expresso/test/serial/async.test.js
new file mode 100644
index 0000000..c596d5c
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/serial/async.test.js
@@ -0,0 +1,39 @@
+
+var assert = require('assert')
+  , setup = 0
+  , order = [];
+
+module.exports = {
+    setup: function(done){
+        ++setup;
+        done();
+    },
+
+    a: function(done){
+        assert.equal(1, setup);
+        order.push('a');
+        setTimeout(function(){
+            done();
+        }, 500);
+    },
+    
+    b: function(done){
+        assert.equal(2, setup);
+        order.push('b');
+        setTimeout(function(){
+            done();
+        }, 200);
+    },
+    
+    c: function(done){
+        assert.equal(3, setup);
+        order.push('c');
+        setTimeout(function(){
+            done();
+        }, 1000);
+    },
+
+    d: function(){
+        assert.eql(order, ['a', 'b', 'c']);
+    }
+};
\ No newline at end of file
diff --git a/node_modules/mongoose/support/expresso/test/serial/http.test.js b/node_modules/mongoose/support/expresso/test/serial/http.test.js
new file mode 100644
index 0000000..7783eb5
--- /dev/null
+++ b/node_modules/mongoose/support/expresso/test/serial/http.test.js
@@ -0,0 +1,48 @@
+
+/**
+ * Module dependencies.
+ */
+
+var assert = require('assert')
+  , http = require('http');
+
+var server = http.createServer(function(req, res){
+    if (req.method === 'GET') {
+        if (req.url === '/delay') {
+            setTimeout(function(){
+                res.writeHead(200, {});
+                res.end('delayed');
+            }, 200);
+        } else {
+            var body = JSON.stringify({ name: 'tj' });
+            res.writeHead(200, {
+                'Content-Type': 'application/json; charset=utf8',
+                'Content-Length': body.length
+            });
+            res.end(body);
+        }
+    } else {
+        var body = '';
+        req.setEncoding('utf8');
+        req.addListener('data', function(chunk){ body += chunk });
+        req.addListener('end', function(){
+            res.writeHead(200, {});
+            res.end(req.url + ' ' + body);
+        });
+    }
+});
+
+module.exports = {
+    'test assert.response()': function(done){
+        assert.response(server, {
+            url: '/',
+            method: 'GET'
+        },{
+            body: '{"name":"tj"}',
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json; charset=utf8'
+            }
+        }, done);
+    }
+};
\ No newline at end of file