diff --git a/.gitignore b/.gitignore
index 546b834cb..4d1314326 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
-node_modules
-package.json
+/package.json
 npm-debug.log
 sinopia-*.tgz
 .DS_Store
@@ -8,3 +7,17 @@ sinopia-*.tgz
 bin/**
 !bin/sinopia
 test-storage*
+
+# ignoring everything except bundled deps
+/node_modules/*
+!/node_modules/mkdirp
+!/node_modules/unopinionate
+!/node_modules/onclick
+!/node_modules/onscroll
+!/node_modules/transition-complete
+!/node_modules/helpers.less
+!/node_modules/tar.gz
+!/node_modules/sinopia-htpasswd
+!/node_modules/crypt3
+!/node_modules/http-errors
+
diff --git a/node_modules/crypt3/.gitignore b/node_modules/crypt3/.gitignore
new file mode 100644
index 000000000..6203a47cc
--- /dev/null
+++ b/node_modules/crypt3/.gitignore
@@ -0,0 +1,16 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+pids
+logs
+results
+
+npm-debug.log
+node_modules
+build/
diff --git a/node_modules/crypt3/LICENSE b/node_modules/crypt3/LICENSE
new file mode 100644
index 000000000..953cdcb6f
--- /dev/null
+++ b/node_modules/crypt3/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Sendanor
+
+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/crypt3/README.md b/node_modules/crypt3/README.md
new file mode 100644
index 000000000..0a7812224
--- /dev/null
+++ b/node_modules/crypt3/README.md
@@ -0,0 +1,43 @@
+node-crypt3
+===========
+
+[crypt3link]: https://en.wikipedia.org/wiki/Crypt_(C) "crypt() in C"
+
+[crypt(3)][crypt3link] for Node.js
+
+Installation
+------------
+
+Install using `npm install crypt3` and use:
+
+```javascript
+var crypt = require('crypt3');
+```
+
+Example password check
+----------------------
+
+```javascript
+if( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/') !== '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/' ) {
+	console.error('Access denied!');
+	return;
+}
+```
+
+Example password encoding
+-------------------------
+
+Use `crypt(key[, salt])`:
+
+```javascript
+console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh') );                                   // Salt generated automatically using default SHA512
+console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('md5') ) );         // MD5 salt
+console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('blowfish') ) );    // Blowfish salt (only some Linux distros)
+console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha256') ) );      // SHA-256
+console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha512') ) );      // SHA-512
+```
+
+Create hashes
+-------------
+
+Use `crypt.createSalt([type=sha512])` where type is one of `md5`, `blowfish`, `sha256` or `sha512` (default). 
diff --git a/node_modules/crypt3/binding.gyp b/node_modules/crypt3/binding.gyp
new file mode 100644
index 000000000..7349d802e
--- /dev/null
+++ b/node_modules/crypt3/binding.gyp
@@ -0,0 +1,14 @@
+{
+  "targets": [
+    {
+      "target_name": "crypt3",
+      "sources": [ "crypt3.cc" ],
+      "include_dirs" : [ "<!(node -e \"require('nan')\")" ],
+      "conditions": [
+        ['OS!="mac"', {
+          'link_settings': { "libraries": [ "-lcrypt" ] }
+        }]
+      ]
+    }
+  ]
+}
diff --git a/node_modules/crypt3/crypt3.cc b/node_modules/crypt3/crypt3.cc
new file mode 100644
index 000000000..d960a7ca9
--- /dev/null
+++ b/node_modules/crypt3/crypt3.cc
@@ -0,0 +1,39 @@
+/* Node.js Crypt(3) implementation */
+
+#include <node.h>
+#include <v8.h>
+#include <errno.h>
+#include <unistd.h>		// for crypt if _XOPEN_SOURCE exists
+#include <nan.h>
+
+using namespace v8;
+
+NAN_METHOD(Method) {
+	NanScope();
+
+	if (args.Length() < 2) {
+		return NanThrowTypeError("Wrong number of arguments");
+	}
+
+	if (!args[0]->IsString() || !args[1]->IsString()) {
+		return NanThrowTypeError("Wrong arguments");
+	}
+
+	v8::String::Utf8Value key(args[0]->ToString());
+	v8::String::Utf8Value salt(args[1]->ToString());
+
+	char* res = crypt(*key, *salt);
+	if (res != NULL) {
+		NanReturnValue(NanNew<String>(res));
+	} else {
+		return NanThrowError(node::ErrnoException(errno, "crypt"));
+	}
+}
+
+void init(Handle<Object> exports) {
+	exports->Set(NanNew<String>("crypt"), NanNew<FunctionTemplate>(Method)->GetFunction());
+}
+
+NODE_MODULE(crypt3, init)
+
+/* EOF */
diff --git a/node_modules/crypt3/index.js b/node_modules/crypt3/index.js
new file mode 100644
index 000000000..441930b6f
--- /dev/null
+++ b/node_modules/crypt3/index.js
@@ -0,0 +1,33 @@
+/** Node.js Crypt(3) Library */
+
+var salters = {
+	'md5': function() { return '$1$'+require('crypto').randomBytes(10).toString('base64'); },
+	'blowfish': function() { return '$2a$'+require('crypto').randomBytes(10).toString('base64'); },
+	'sha256': function() { return '$5$'+require('crypto').randomBytes(10).toString('base64'); },
+	'sha512': function() { return '$6$'+require('crypto').randomBytes(10).toString('base64'); }
+};
+
+function createSalt(type) {
+	type = type || 'sha512';
+	if(!salters[type]) throw new TypeError('Unknown salt type at crypt3.createSalt: ' + type);
+	return salters[type]();
+};
+
+/** Crypt(3) password and data encryption.
+ * @param {string} key user's typed password
+ * @param {string} salt Optional salt, for example SHA-512 use "$6$salt$".
+ * @returns {string} A generated hash in format $id$salt$encrypted
+ * @see https://en.wikipedia.org/wiki/Crypt_(C)
+ */
+var crypt3 = module.exports = function(key, salt) {
+	salt = salt || createSalt();
+	return require('./build/Release/crypt3').crypt(key, salt);
+};
+
+/** Create salt 
+ * @param {string} type The type of salt: md5, blowfish (only some linux distros), sha256 or sha512. Default is sha512.
+ * @returns {string} Generated salt string
+ */
+crypt3.createSalt = createSalt;
+
+/* EOF */
diff --git a/node_modules/crypt3/package.json b/node_modules/crypt3/package.json
new file mode 100644
index 000000000..331d403c8
--- /dev/null
+++ b/node_modules/crypt3/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "crypt3",
+  "version": "0.1.5",
+  "description": "Node.js crypt(3) bindings",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/test.js",
+    "install": "node-gyp rebuild"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sendanor/node-crypt3.git"
+  },
+  "keywords": [
+    "crypt",
+    "password",
+    "md5",
+    "sha256",
+    "sha512",
+    "blowfish",
+    "hash"
+  ],
+  "dependencies": { "nan": "~1.3.0" },
+  "author": {
+    "name": "Jaakko-Heikki Heusala",
+    "email": "jheusala@iki.fi"
+  },
+  "license": "MIT",
+  "gypfile": true,
+  "readme": "node-crypt3\n===========\n\n[crypt3link]: https://en.wikipedia.org/wiki/Crypt_(C) \"crypt() in C\"\n\n[crypt(3)][crypt3link] for Node.js\n\nInstallation\n------------\n\nInstall using `npm install crypt3` and use:\n\n```javascript\nvar crypt = require('crypt3');\n```\n\nExample password check\n----------------------\n\n```javascript\nif( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/') !== '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/' ) {\n\tconsole.error('Access denied!');\n\treturn;\n}\n```\n\nExample password encoding\n-------------------------\n\nUse `crypt(key[, salt])`:\n\n```javascript\nconsole.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh') );                                   // Salt generated automatically using default SHA512\nconsole.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('md5') ) );         // MD5 salt\nconsole.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('blowfish') ) );    // Blowfish salt (only some Linux distros)\nconsole.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha256') ) );      // SHA-256\nconsole.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha512') ) );      // SHA-512\n```\n\nCreate hashes\n-------------\n\nUse `crypt.createSalt([type=sha512])` where type is one of `md5`, `blowfish`, `sha256` or `sha512` (default). \n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/sendanor/node-crypt3/issues"
+  },
+  "homepage": "https://github.com/sendanor/node-crypt3",
+  "_id": "crypt3@0.1.5",
+  "_shasum": "f21e9ba7a57736f47e0654ad27f8668966de02db",
+  "_resolved": "git://github.com/sendanor/node-crypt3.git#9b893c95ed956adc3da681b125c371112b1ad31d",
+  "_from": "crypt3@git://github.com/sendanor/node-crypt3.git"
+}
diff --git a/node_modules/crypt3/test/test.js b/node_modules/crypt3/test/test.js
new file mode 100644
index 000000000..e1720ac93
--- /dev/null
+++ b/node_modules/crypt3/test/test.js
@@ -0,0 +1,14 @@
+var assert = require('assert')
+var crypt3 = require('../')
+
+assert.throws(function() {
+	crypt3()
+}, /Wrong arguments/)
+
+assert.equal(crypt3('pass', 'salt'), 'sa5JEXtYx/rm6')
+assert.equal(crypt3('pass', 'sa5JEXtYx/rm6'), 'sa5JEXtYx/rm6')
+
+var hash = crypt3('password')
+assert.equal(crypt3('password', hash), hash)
+assert.notEqual(crypt3('bad-pass', hash), hash)
+
diff --git a/node_modules/helpers.less/.gitignore b/node_modules/helpers.less/.gitignore
new file mode 100755
index 000000000..69fd427f4
--- /dev/null
+++ b/node_modules/helpers.less/.gitignore
@@ -0,0 +1,43 @@
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Node Stuff #
+##############
+node_modules/
+
+
diff --git a/node_modules/helpers.less/Gruntfile.js b/node_modules/helpers.less/Gruntfile.js
new file mode 100644
index 000000000..09b972876
--- /dev/null
+++ b/node_modules/helpers.less/Gruntfile.js
@@ -0,0 +1,17 @@
+module.exports = function(grunt) {
+    grunt.initConfig({
+        pkg: grunt.file.readJSON('package.json'),
+        browserify: {
+            'dist/subview.js':      ['src/main.js'],
+            'examples/build.js':    ['examples/example.js']
+        },
+        watch: {
+            files: [ "src/*.js", "examples/example.js"],
+            tasks: [ 'browserify' ]
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-browserify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+};
+
diff --git a/node_modules/helpers.less/README.md b/node_modules/helpers.less/README.md
new file mode 100644
index 000000000..e5d9ce966
--- /dev/null
+++ b/node_modules/helpers.less/README.md
@@ -0,0 +1,11 @@
+To Build:
+
+```bash
+grunt browserify
+```
+
+To Develop:
+
+```bash
+grunt watch
+```
\ No newline at end of file
diff --git a/node_modules/helpers.less/helpers.less b/node_modules/helpers.less/helpers.less
new file mode 100644
index 000000000..426f87988
--- /dev/null
+++ b/node_modules/helpers.less/helpers.less
@@ -0,0 +1,123 @@
+.backface-visibility(@style) {
+    -webkit-backface-visibility:    @style;
+    -moz-backface-visibility:       @style;
+    -ms-backface-visibility:        @style;
+    -o-backface-visibility:         @style;
+    backface-visibility:            @style;
+}
+
+.perspective(@style) {
+    -webkit-perspective:    @style;
+    -moz-perspective:       @style;
+    -ms-perspective:        @style;
+    -o-perspective:         @style;
+    perspective:            @style;
+}
+
+.border-radius(@radius) {
+    -webkit-border-radius:  @radius;
+    -moz-border-radius:     @radius;
+    border-radius:          @radius;
+}
+
+.border-radius-topleft(@radius) {
+    -moz-border-radius-topleft:     @radius;
+    border-top-left-radius:         @radius;
+}
+
+.border-radius-topright(@radius) {
+    -moz-border-radius-topright:    @radius;
+    border-top-right-radius:        @radius;
+}
+
+.border-radius-bottomleft(@radius) {
+    -moz-border-radius-bottomleft:  @radius;
+    border-bottom-left-radius:      @radius;
+}
+
+.border-radius-bottomright(@radius) {
+    -moz-border-radius-bottomright: @radius;
+    border-bottom-right-radius:     @radius;
+}
+
+.no-select() {
+    -moz-user-select:       none;
+    -ms-user-select:        none;
+    -khtml-user-select:     none;
+    -webkit-user-select:    none;
+    -o-user-select:         none;
+    user-select:            none;
+}
+
+.do-select() {
+    -moz-user-select:       text;
+    -ms-user-select:        text;
+    -khtml-user-select:     text;
+    -webkit-user-select:    text;
+    -o-user-select:         text;
+    user-select:            text;
+}
+
+.border-box() {
+    -moz-box-sizing:    border-box;
+    -webkit-box-sizing: border-box;
+    box-sizing:         border-box;
+}
+
+.box-shadow(@value1, @value2:X, ...) {
+    @value: ~`"@{arguments}".replace(/[\[\]]|\,\sX/g, '')`;
+    -moz-box-shadow:    @value;
+    -webkit-box-shadow: @value;
+    box-shadow:         @value;
+}
+
+.transition(@value1, @value2:X, ...) {
+    @value: ~`"@{arguments}".replace(/[\[\]]|\,\sX/g, '')`;
+
+    -webkit-transition: @value;
+    -moz-transition:    @value;
+    -ms-transition:     @value;
+    -o-transition:      @value;
+    transition:         @value;
+}
+
+.transformTransition(@value1, @value2:X, ...) {
+    @value: ~`"@{arguments}".replace(/[\[\]]|\,\sX/g, '')`;
+
+    -webkit-transition: -webkit-transform   @value;
+    -moz-transition:    -moz-transform      @value;
+    -ms-transition:     -ms-transform       @value;
+    -o-transition:      -o-transform        @value;
+    transition:         transform           @value;
+}
+
+.animation(@value1, @value2:X, ...) {
+    @value: ~`"@{arguments}".replace(/[\[\]]|\,\sX/g, '')`;
+
+    -webkit-animation:  @value;
+    -moz-animation:     @value;
+    -o-animation:       @value;
+    animation:          @value;
+}
+
+.transform(@value1, @value2:X, ...) {
+    @value: ~`"@{arguments}".replace(/[\[\]]|\,\sX/g, '')`;
+
+    -webkit-transform:  @value;
+    -moz-transform:     @value;
+    -o-transform:       @value;
+    -ms-transform:      @value;
+    transform:          @value;
+}
+
+.rotate(@deg) {
+    .transform(rotate(@deg));
+}
+
+.scale(@ratio) {
+    .transform(scale(@ratio, @ratio));
+}
+
+.translate(@x, @y) {
+    .transform(translate(@x, @y));
+}
diff --git a/node_modules/helpers.less/package.json b/node_modules/helpers.less/package.json
new file mode 100644
index 000000000..98287d079
--- /dev/null
+++ b/node_modules/helpers.less/package.json
@@ -0,0 +1,27 @@
+{
+    "name":         "helpers.less",
+    "description":  "A set of very convenient less helpers.",
+    "version":      "0.1.0",
+    "author":       {
+        "name": "Brian Peacock"
+    },
+    "main":         "helpers.less",
+    "repository":   {
+        "type": "git",
+        "url":  "https://github.com/bpeacock/helpers.less"
+    },
+    "dependencies": {},
+    "devDependencies": {},
+    "license": "MIT",
+    "keywords": [],
+    "readme": "To Build:\n\n```bash\ngrunt browserify\n```\n\nTo Develop:\n\n```bash\ngrunt watch\n```",
+    "readmeFilename": "README.md",
+    "bugs": {
+        "url": "https://github.com/bpeacock/helpers.less/issues"
+    },
+    "homepage": "https://github.com/bpeacock/helpers.less",
+    "_id": "helpers.less@0.1.0",
+    "_shasum": "d77d92fb3f710e0807f00bd2de920a9e4374799a",
+    "_resolved": "git://github.com/bpeacock/helpers.less.git#4184c4abac632b4b14129ec9ef6e1173370adc22",
+    "_from": "helpers.less@git://github.com/bpeacock/helpers.less.git"
+}
diff --git a/node_modules/http-errors/LICENSE b/node_modules/http-errors/LICENSE
new file mode 100644
index 000000000..a7ae8ee9b
--- /dev/null
+++ b/node_modules/http-errors/LICENSE
@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Jonathan Ong me@jongleberry.com
+
+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/http-errors/README.md b/node_modules/http-errors/README.md
new file mode 100644
index 000000000..1702b10e4
--- /dev/null
+++ b/node_modules/http-errors/README.md
@@ -0,0 +1,63 @@
+
+# http-errors
+
+[![NPM version][npm-image]][npm-url]
+[![Build status][travis-image]][travis-url]
+[![Test coverage][coveralls-image]][coveralls-url]
+[![Dependency Status][david-image]][david-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+Create HTTP errors for Express, Koa, Connect, etc. with ease.
+
+## Example
+
+```js
+var createError = require('http-errors');
+
+app.use(function (req, res, next) {
+  if (!req.user) return next(createError(401, 'Please login to view this page.'));
+  next();
+})
+```
+
+## API
+
+This is the current API, currently extracted from Koa and subject to change.
+
+### Error Properties
+
+- `message`
+- `status` and `statusCode` - the status code of the error, defaulting to `500`
+
+### createError([status], [message], [properties])
+
+```js
+var err = createError(404, 'This video does not exist!');
+```
+
+- `status: 500` - the status code as a number
+- `message` - the message of the error, defaulting to node's text for that status code.
+- `properties` - custom properties to attach to the object
+
+### new createError\[code || name\](\[msg]\))
+
+```js
+var err = new createError.NotFound();
+```
+
+- `code` - the status code as a number
+- `name` - the name of the error as a "bumpy case", i.e. `NotFound` or `InternalServerError`.
+
+[npm-image]: https://img.shields.io/npm/v/http-errors.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/http-errors
+[travis-image]: https://img.shields.io/travis/jshttp/http-errors.svg?style=flat-square
+[travis-url]: https://travis-ci.org/jshttp/http-errors
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/http-errors.svg?style=flat-square
+[coveralls-url]: https://coveralls.io/r/jshttp/http-errors?branch=master
+[david-image]: http://img.shields.io/david/jshttp/http-errors.svg?style=flat-square
+[david-url]: https://david-dm.org/jshttp/http-errors
+[license-image]: http://img.shields.io/npm/l/http-errors.svg?style=flat-square
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/http-errors.svg?style=flat-square
+[downloads-url]: https://npmjs.org/package/http-errors
diff --git a/node_modules/http-errors/index.js b/node_modules/http-errors/index.js
new file mode 100644
index 000000000..5f03585ed
--- /dev/null
+++ b/node_modules/http-errors/index.js
@@ -0,0 +1,75 @@
+
+var statuses = require('statuses');
+var inherits = require('util').inherits;
+
+exports = module.exports = function () {
+  // so much arity going on ~_~
+  var err;
+  var msg;
+  var status = 500;
+  var props = {};
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    if (arg instanceof Error) {
+      err = arg;
+      status = err.status || err.statusCode || status;
+      continue;
+    }
+    switch (typeof arg) {
+      case 'string':
+        msg = arg;
+        break;
+      case 'number':
+        status = arg;
+        break;
+      case 'object':
+        props = arg;
+        break;
+    }
+  }
+
+  if (typeof status !== 'number' || !statuses[status]) status = 500;
+  err = err || new Error(msg || statuses[status]);
+  err = err || new Error(msg || statuses[status]);
+  err.expose = status < 500;
+  for (var key in props) err[key] = props[key];
+  err.status = err.statusCode = status;
+  return err;
+};
+
+// create generic error objects
+var codes = statuses.codes.filter(function (num) {
+  return num >= 400;
+});
+
+codes.forEach(function (code) {
+  if (code >= 500) {
+    var ServerError = function ServerError(msg) {
+      var self = new Error(msg != null ? msg : statuses[code])
+      Error.captureStackTrace(self, arguments.callee)
+      self.__proto__ = ServerError.prototype
+      return self
+    }
+    inherits(ServerError, Error);
+    ServerError.prototype.status =
+    ServerError.prototype.statusCode = code;
+    ServerError.prototype.expose = false;
+    exports[code] =
+    exports[statuses[code].replace(/\s+/g, '')] = ServerError;
+    return;
+  }
+
+  var ClientError = function ClientError(msg) {
+    var self = new Error(msg != null ? msg : statuses[code])
+    Error.captureStackTrace(self, arguments.callee)
+    self.__proto__ = ClientError.prototype
+    return self
+  }
+  inherits(ClientError, Error);
+  ClientError.prototype.status =
+  ClientError.prototype.statusCode = code;
+  ClientError.prototype.expose = false;
+  exports[code] =
+  exports[statuses[code].replace(/\s+/g, '')] = ClientError;
+  return;
+});
diff --git a/node_modules/http-errors/node_modules/statuses/README.md b/node_modules/http-errors/node_modules/statuses/README.md
new file mode 100644
index 000000000..776db36db
--- /dev/null
+++ b/node_modules/http-errors/node_modules/statuses/README.md
@@ -0,0 +1,92 @@
+# Statuses
+
+[![NPM version][npm-image]][npm-url]
+[![Dependency Status][david-image]][david-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+HTTP status utility for node.
+
+## API
+
+```js
+var status = require('statuses');
+```
+
+### var code = status(Integer || String)
+
+If `Integer` or `String` is a valid HTTP code or status message, then the appropriate `code` will be returned. Otherwise, an error will be thrown.
+
+```js
+status(403) // => 403
+status('403') // => 403
+status('forbidden') // => 403
+status('Forbidden') // => 403
+status(306) // throws, as it's not supported by node.js
+```
+
+### status.codes
+
+Returns an array of all the status codes as `Integer`s.
+
+### var msg = status[code]
+
+Map of `code` to `status message`. `undefined` for invalid `code`s.
+
+```js
+status[404] // => 'Not Found'
+```
+
+### var code = status[msg]
+
+Map of `status message` to `code`. `msg` can either be title-cased or lower-cased. `undefined` for invalid `status message`s.
+
+```js
+status['not found'] // => 404
+status['Not Found'] // => 404
+```
+
+### status.redirect[code]
+
+Returns `true` if a status code is a valid redirect status.
+
+```js
+status.redirect[200] // => undefined
+status.redirect[301] // => true
+```
+
+### status.empty[code]
+
+Returns `true` if a status code expects an empty body.
+
+```js
+status.empty[200] // => undefined
+status.empty[204] // => true
+status.empty[304] // => true
+```
+
+### status.retry[code]
+
+Returns `true` if you should retry the rest.
+
+```js
+status.retry[501] // => undefined
+status.retry[503] // => true
+```
+
+[npm-image]: https://img.shields.io/npm/v/statuses.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/statuses
+[github-tag]: http://img.shields.io/github/tag/jshttp/statuses.svg?style=flat-square
+[github-url]: https://github.com/jshttp/statuses/tags
+[travis-image]: https://img.shields.io/travis/jshttp/statuses.svg?style=flat-square
+[travis-url]: https://travis-ci.org/jshttp/statuses
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/statuses.svg?style=flat-square
+[coveralls-url]: https://coveralls.io/r/jshttp/statuses?branch=master
+[david-image]: http://img.shields.io/david/jshttp/statuses.svg?style=flat-square
+[david-url]: https://david-dm.org/jshttp/statuses
+[license-image]: http://img.shields.io/npm/l/statuses.svg?style=flat-square
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/statuses.svg?style=flat-square
+[downloads-url]: https://npmjs.org/package/statuses
+[gittip-image]: https://img.shields.io/gittip/jonathanong.svg?style=flat-square
+[gittip-url]: https://www.gittip.com/jonathanong/
diff --git a/node_modules/http-errors/node_modules/statuses/index.js b/node_modules/http-errors/node_modules/statuses/index.js
new file mode 100644
index 000000000..41afc639a
--- /dev/null
+++ b/node_modules/http-errors/node_modules/statuses/index.js
@@ -0,0 +1,60 @@
+var http = require('http');
+var codes = http.STATUS_CODES;
+
+module.exports = status;
+
+// [Integer...]
+status.codes = Object.keys(codes).map(function (code) {
+  code = ~~code;
+  var msg = codes[code];
+  status[code] = msg;
+  status[msg] = status[msg.toLowerCase()] = code;
+  return code;
+});
+
+// status codes for redirects
+status.redirect = {
+  300: true,
+  301: true,
+  302: true,
+  303: true,
+  305: true,
+  307: true,
+  308: true,
+};
+
+// status codes for empty bodies
+status.empty = {
+  204: true,
+  205: true,
+  304: true,
+};
+
+// status codes for when you should retry the request
+status.retry = {
+  502: true,
+  503: true,
+  504: true,
+};
+
+function status(code) {
+  if (typeof code === 'number') {
+    if (!status[code]) throw new Error('invalid status code: ' + code);
+    return code;
+  }
+
+  if (typeof code !== 'string') {
+    throw new TypeError('code must be a number or string');
+  }
+
+  // '403'
+  var n = parseInt(code, 10)
+  if (!isNaN(n)) {
+    if (!status[n]) return new Error('invalid status code: ' + n);
+    return n;
+  }
+
+  n = status[code.toLowerCase()];
+  if (!n) throw new Error('invalid status message: "' + code + '"');
+  return n;
+}
diff --git a/node_modules/http-errors/node_modules/statuses/package.json b/node_modules/http-errors/node_modules/statuses/package.json
new file mode 100644
index 000000000..82c2903dc
--- /dev/null
+++ b/node_modules/http-errors/node_modules/statuses/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "statuses",
+  "description": "HTTP status utility",
+  "version": "1.0.4",
+  "author": {
+    "name": "Jonathan Ong",
+    "email": "me@jongleberry.com",
+    "url": "http://jongleberry.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jshttp/statuses"
+  },
+  "license": "MIT",
+  "keywords": [
+    "http",
+    "status",
+    "code"
+  ],
+  "files": [
+    "index.js"
+  ],
+  "readme": "# Statuses\n\n[![NPM version][npm-image]][npm-url]\n[![Dependency Status][david-image]][david-url]\n[![License][license-image]][license-url]\n[![Downloads][downloads-image]][downloads-url]\n\nHTTP status utility for node.\n\n## API\n\n```js\nvar status = require('statuses');\n```\n\n### var code = status(Integer || String)\n\nIf `Integer` or `String` is a valid HTTP code or status message, then the appropriate `code` will be returned. Otherwise, an error will be thrown.\n\n```js\nstatus(403) // => 403\nstatus('403') // => 403\nstatus('forbidden') // => 403\nstatus('Forbidden') // => 403\nstatus(306) // throws, as it's not supported by node.js\n```\n\n### status.codes\n\nReturns an array of all the status codes as `Integer`s.\n\n### var msg = status[code]\n\nMap of `code` to `status message`. `undefined` for invalid `code`s.\n\n```js\nstatus[404] // => 'Not Found'\n```\n\n### var code = status[msg]\n\nMap of `status message` to `code`. `msg` can either be title-cased or lower-cased. `undefined` for invalid `status message`s.\n\n```js\nstatus['not found'] // => 404\nstatus['Not Found'] // => 404\n```\n\n### status.redirect[code]\n\nReturns `true` if a status code is a valid redirect status.\n\n```js\nstatus.redirect[200] // => undefined\nstatus.redirect[301] // => true\n```\n\n### status.empty[code]\n\nReturns `true` if a status code expects an empty body.\n\n```js\nstatus.empty[200] // => undefined\nstatus.empty[204] // => true\nstatus.empty[304] // => true\n```\n\n### status.retry[code]\n\nReturns `true` if you should retry the rest.\n\n```js\nstatus.retry[501] // => undefined\nstatus.retry[503] // => true\n```\n\n[npm-image]: https://img.shields.io/npm/v/statuses.svg?style=flat-square\n[npm-url]: https://npmjs.org/package/statuses\n[github-tag]: http://img.shields.io/github/tag/jshttp/statuses.svg?style=flat-square\n[github-url]: https://github.com/jshttp/statuses/tags\n[travis-image]: https://img.shields.io/travis/jshttp/statuses.svg?style=flat-square\n[travis-url]: https://travis-ci.org/jshttp/statuses\n[coveralls-image]: https://img.shields.io/coveralls/jshttp/statuses.svg?style=flat-square\n[coveralls-url]: https://coveralls.io/r/jshttp/statuses?branch=master\n[david-image]: http://img.shields.io/david/jshttp/statuses.svg?style=flat-square\n[david-url]: https://david-dm.org/jshttp/statuses\n[license-image]: http://img.shields.io/npm/l/statuses.svg?style=flat-square\n[license-url]: LICENSE\n[downloads-image]: http://img.shields.io/npm/dm/statuses.svg?style=flat-square\n[downloads-url]: https://npmjs.org/package/statuses\n[gittip-image]: https://img.shields.io/gittip/jonathanong.svg?style=flat-square\n[gittip-url]: https://www.gittip.com/jonathanong/\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/jshttp/statuses/issues"
+  },
+  "homepage": "https://github.com/jshttp/statuses",
+  "_id": "statuses@1.0.4",
+  "_shasum": "a8b203f645cf475a66426f6be690205c85f3ebdd",
+  "_from": "statuses@~1.0.4",
+  "_resolved": "https://registry.npmjs.org/statuses/-/statuses-1.0.4.tgz"
+}
diff --git a/node_modules/http-errors/package.json b/node_modules/http-errors/package.json
new file mode 100644
index 000000000..5ce69f649
--- /dev/null
+++ b/node_modules/http-errors/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "http-errors",
+  "description": "Create HTTP error objects",
+  "version": "1.2.0",
+  "author": {
+    "name": "Jonathan Ong",
+    "email": "me@jongleberry.com",
+    "url": "http://jongleberry.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jshttp/http-errors"
+  },
+  "dependencies": {
+    "statuses": "~1.0.4"
+  },
+  "devDependencies": {
+    "istanbul": "0",
+    "mocha": "1"
+  },
+  "scripts": {
+    "test": "mocha --reporter spec --bail",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot",
+    "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter dot"
+  },
+  "keywords": [
+    "http",
+    "error"
+  ],
+  "files": [
+    "index.js",
+    "LICENSE"
+  ],
+  "readme": "\n# http-errors\n\n[![NPM version][npm-image]][npm-url]\n[![Build status][travis-image]][travis-url]\n[![Test coverage][coveralls-image]][coveralls-url]\n[![Dependency Status][david-image]][david-url]\n[![License][license-image]][license-url]\n[![Downloads][downloads-image]][downloads-url]\n\nCreate HTTP errors for Express, Koa, Connect, etc. with ease.\n\n## Example\n\n```js\nvar createError = require('http-errors');\n\napp.use(function (req, res, next) {\n  if (!req.user) return next(createError(401, 'Please login to view this page.'));\n  next();\n})\n```\n\n## API\n\nThis is the current API, currently extracted from Koa and subject to change.\n\n### Error Properties\n\n- `message`\n- `status` and `statusCode` - the status code of the error, defaulting to `500`\n\n### createError([status], [message], [properties])\n\n```js\nvar err = createError(404, 'This video does not exist!');\n```\n\n- `status: 500` - the status code as a number\n- `message` - the message of the error, defaulting to node's text for that status code.\n- `properties` - custom properties to attach to the object\n\n### new createError\\[code || name\\](\\[msg]\\))\n\n```js\nvar err = new createError.NotFound();\n```\n\n- `code` - the status code as a number\n- `name` - the name of the error as a \"bumpy case\", i.e. `NotFound` or `InternalServerError`.\n\n[npm-image]: https://img.shields.io/npm/v/http-errors.svg?style=flat-square\n[npm-url]: https://npmjs.org/package/http-errors\n[travis-image]: https://img.shields.io/travis/jshttp/http-errors.svg?style=flat-square\n[travis-url]: https://travis-ci.org/jshttp/http-errors\n[coveralls-image]: https://img.shields.io/coveralls/jshttp/http-errors.svg?style=flat-square\n[coveralls-url]: https://coveralls.io/r/jshttp/http-errors?branch=master\n[david-image]: http://img.shields.io/david/jshttp/http-errors.svg?style=flat-square\n[david-url]: https://david-dm.org/jshttp/http-errors\n[license-image]: http://img.shields.io/npm/l/http-errors.svg?style=flat-square\n[license-url]: LICENSE\n[downloads-image]: http://img.shields.io/npm/dm/http-errors.svg?style=flat-square\n[downloads-url]: https://npmjs.org/package/http-errors\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/jshttp/http-errors/issues"
+  },
+  "homepage": "https://github.com/jshttp/http-errors",
+  "_id": "http-errors@1.2.0",
+  "_shasum": "936739e42c3e9b778d84b30bce32802fd5eb9c75",
+  "_from": "http-errors@~1.2.0",
+  "_resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.2.0.tgz"
+}
diff --git a/node_modules/mkdirp/.npmignore b/node_modules/mkdirp/.npmignore
new file mode 100644
index 000000000..9303c347e
--- /dev/null
+++ b/node_modules/mkdirp/.npmignore
@@ -0,0 +1,2 @@
+node_modules/
+npm-debug.log
\ No newline at end of file
diff --git a/node_modules/mkdirp/.travis.yml b/node_modules/mkdirp/.travis.yml
new file mode 100644
index 000000000..c693a939d
--- /dev/null
+++ b/node_modules/mkdirp/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8
+  - "0.10"
diff --git a/node_modules/mkdirp/LICENSE b/node_modules/mkdirp/LICENSE
new file mode 100644
index 000000000..432d1aeb0
--- /dev/null
+++ b/node_modules/mkdirp/LICENSE
@@ -0,0 +1,21 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT/X11 license:
+
+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/mkdirp/bin/cmd.js b/node_modules/mkdirp/bin/cmd.js
new file mode 100755
index 000000000..d95de15ae
--- /dev/null
+++ b/node_modules/mkdirp/bin/cmd.js
@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+var mkdirp = require('../');
+var minimist = require('minimist');
+var fs = require('fs');
+
+var argv = minimist(process.argv.slice(2), {
+    alias: { m: 'mode', h: 'help' },
+    string: [ 'mode' ]
+});
+if (argv.help) {
+    fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout);
+    return;
+}
+
+var paths = argv._.slice();
+var mode = argv.mode ? parseInt(argv.mode, 8) : undefined;
+
+(function next () {
+    if (paths.length === 0) return;
+    var p = paths.shift();
+    
+    if (mode === undefined) mkdirp(p, cb)
+    else mkdirp(p, mode, cb)
+    
+    function cb (err) {
+        if (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        else next();
+    }
+})();
diff --git a/node_modules/mkdirp/bin/usage.txt b/node_modules/mkdirp/bin/usage.txt
new file mode 100644
index 000000000..f952aa2c7
--- /dev/null
+++ b/node_modules/mkdirp/bin/usage.txt
@@ -0,0 +1,12 @@
+usage: mkdirp [DIR1,DIR2..] {OPTIONS}
+
+  Create each supplied directory including any necessary parent directories that
+  don't yet exist.
+  
+  If the directory already exists, do nothing.
+
+OPTIONS are:
+
+  -m, --mode   If a directory needs to be created, set the mode as an octal
+               permission string.
+
diff --git a/node_modules/mkdirp/examples/pow.js b/node_modules/mkdirp/examples/pow.js
new file mode 100644
index 000000000..e6924212e
--- /dev/null
+++ b/node_modules/mkdirp/examples/pow.js
@@ -0,0 +1,6 @@
+var mkdirp = require('mkdirp');
+
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});
diff --git a/node_modules/mkdirp/index.js b/node_modules/mkdirp/index.js
new file mode 100644
index 000000000..a1742b206
--- /dev/null
+++ b/node_modules/mkdirp/index.js
@@ -0,0 +1,97 @@
+var path = require('path');
+var fs = require('fs');
+
+module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+
+function mkdirP (p, opts, f, made) {
+    if (typeof opts === 'function') {
+        f = opts;
+        opts = {};
+    }
+    else if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    
+    var mode = opts.mode;
+    var xfs = opts.fs || fs;
+    
+    if (mode === undefined) {
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+    
+    var cb = f || function () {};
+    p = path.resolve(p);
+    
+    xfs.mkdir(p, mode, function (er) {
+        if (!er) {
+            made = made || p;
+            return cb(null, made);
+        }
+        switch (er.code) {
+            case 'ENOENT':
+                mkdirP(path.dirname(p), opts, function (er, made) {
+                    if (er) cb(er, made);
+                    else mkdirP(p, opts, cb, made);
+                });
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                xfs.stat(p, function (er2, stat) {
+                    // if the stat fails, then that's super weird.
+                    // let the original error be the failure reason.
+                    if (er2 || !stat.isDirectory()) cb(er, made)
+                    else cb(null, made);
+                });
+                break;
+        }
+    });
+}
+
+mkdirP.sync = function sync (p, opts, made) {
+    if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    
+    var mode = opts.mode;
+    var xfs = opts.fs || fs;
+    
+    if (mode === undefined) {
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+
+    p = path.resolve(p);
+
+    try {
+        xfs.mkdirSync(p, mode);
+        made = made || p;
+    }
+    catch (err0) {
+        switch (err0.code) {
+            case 'ENOENT' :
+                made = sync(path.dirname(p), opts, made);
+                sync(p, opts, made);
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                var stat;
+                try {
+                    stat = xfs.statSync(p);
+                }
+                catch (err1) {
+                    throw err0;
+                }
+                if (!stat.isDirectory()) throw err0;
+                break;
+        }
+    }
+
+    return made;
+};
diff --git a/node_modules/mkdirp/node_modules/minimist/.travis.yml b/node_modules/mkdirp/node_modules/minimist/.travis.yml
new file mode 100644
index 000000000..cc4dba29d
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/.travis.yml
@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - "0.8"
+  - "0.10"
diff --git a/node_modules/mkdirp/node_modules/minimist/LICENSE b/node_modules/mkdirp/node_modules/minimist/LICENSE
new file mode 100644
index 000000000..ee27ba4b4
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/LICENSE
@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+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/mkdirp/node_modules/minimist/example/parse.js b/node_modules/mkdirp/node_modules/minimist/example/parse.js
new file mode 100644
index 000000000..abff3e8ee
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/example/parse.js
@@ -0,0 +1,2 @@
+var argv = require('../')(process.argv.slice(2));
+console.dir(argv);
diff --git a/node_modules/mkdirp/node_modules/minimist/index.js b/node_modules/mkdirp/node_modules/minimist/index.js
new file mode 100644
index 000000000..584f551a6
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/index.js
@@ -0,0 +1,187 @@
+module.exports = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {} };
+    
+    [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+        flags.bools[key] = true;
+    });
+    
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+    });
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+    
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function setArg (key, val) {
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+    
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            setArg(m[1], m[2]);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                setArg(key, next);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true');
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next)
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2));
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                    setArg(key, args[i+1]);
+                    i++;
+                }
+                else if (args[i+1] && /true|false/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true');
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true);
+                }
+            }
+        }
+        else {
+            argv._.push(
+                flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+            );
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    notFlags.forEach(function(key) {
+        argv._.push(key);
+    });
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function setKey (obj, keys, value) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        if (o[key] === undefined) o[key] = {};
+        o = o[key];
+    });
+    
+    var key = keys[keys.length - 1];
+    if (o[key] === undefined || typeof o[key] === 'boolean') {
+        o[key] = value;
+    }
+    else if (Array.isArray(o[key])) {
+        o[key].push(value);
+    }
+    else {
+        o[key] = [ o[key], value ];
+    }
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+function longest (xs) {
+    return Math.max.apply(null, xs.map(function (x) { return x.length }));
+}
diff --git a/node_modules/mkdirp/node_modules/minimist/package.json b/node_modules/mkdirp/node_modules/minimist/package.json
new file mode 100644
index 000000000..7c7220969
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/package.json
@@ -0,0 +1,49 @@
+{
+    "name": "minimist",
+    "version": "0.0.8",
+    "description": "parse argument options",
+    "main": "index.js",
+    "devDependencies": {
+        "tape": "~1.0.4",
+        "tap": "~0.4.0"
+    },
+    "scripts": {
+        "test": "tap test/*.js"
+    },
+    "testling" : {
+        "files" : "test/*.js",
+        "browsers" : [
+            "ie/6..latest",
+            "ff/5", "firefox/latest",
+            "chrome/10", "chrome/latest",
+            "safari/5.1", "safari/latest",
+            "opera/12"
+        ]
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/substack/minimist.git"
+    },
+    "homepage": "https://github.com/substack/minimist",
+    "keywords": [
+        "argv",
+        "getopt",
+        "parser",
+        "optimist"
+    ],
+    "author": {
+        "name": "James Halliday",
+        "email": "mail@substack.net",
+        "url": "http://substack.net"
+    },
+    "license": "MIT",
+    "readme": "# minimist\n\nparse argument options\n\nThis module is the guts of optimist's argument parser without all the\nfanciful decoration.\n\n[![browser support](https://ci.testling.com/substack/minimist.png)](http://ci.testling.com/substack/minimist)\n\n[![build status](https://secure.travis-ci.org/substack/minimist.png)](http://travis-ci.org/substack/minimist)\n\n# example\n\n``` js\nvar argv = require('minimist')(process.argv.slice(2));\nconsole.dir(argv);\n```\n\n```\n$ node example/parse.js -a beep -b boop\n{ _: [], a: 'beep', b: 'boop' }\n```\n\n```\n$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz\n{ _: [ 'foo', 'bar', 'baz' ],\n  x: 3,\n  y: 4,\n  n: 5,\n  a: true,\n  b: true,\n  c: true,\n  beep: 'boop' }\n```\n\n# methods\n\n``` js\nvar parseArgs = require('minimist')\n```\n\n## var argv = parseArgs(args, opts={})\n\nReturn an argument object `argv` populated with the array arguments from `args`.\n\n`argv._` contains all the arguments that didn't have an option associated with\nthem.\n\nNumeric-looking arguments will be returned as numbers unless `opts.string` or\n`opts.boolean` is set for that argument name.\n\nAny arguments after `'--'` will not be parsed and will end up in `argv._`.\n\noptions can be:\n\n* `opts.string` - a string or array of strings argument names to always treat as\nstrings\n* `opts.boolean` - a string or array of strings to always treat as booleans\n* `opts.alias` - an object mapping string names to strings or arrays of string\nargument names to use as aliases\n* `opts.default` - an object mapping string argument names to default values\n\n# install\n\nWith [npm](https://npmjs.org) do:\n\n```\nnpm install minimist\n```\n\n# license\n\nMIT\n",
+    "readmeFilename": "readme.markdown",
+    "bugs": {
+        "url": "https://github.com/substack/minimist/issues"
+    },
+    "_id": "minimist@0.0.8",
+    "_shasum": "857fcabfc3397d2625b8228262e86aa7a011b05d",
+    "_from": "minimist@0.0.8",
+    "_resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz"
+}
diff --git a/node_modules/mkdirp/node_modules/minimist/readme.markdown b/node_modules/mkdirp/node_modules/minimist/readme.markdown
new file mode 100644
index 000000000..c25635323
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/readme.markdown
@@ -0,0 +1,73 @@
+# minimist
+
+parse argument options
+
+This module is the guts of optimist's argument parser without all the
+fanciful decoration.
+
+[![browser support](https://ci.testling.com/substack/minimist.png)](http://ci.testling.com/substack/minimist)
+
+[![build status](https://secure.travis-ci.org/substack/minimist.png)](http://travis-ci.org/substack/minimist)
+
+# example
+
+``` js
+var argv = require('minimist')(process.argv.slice(2));
+console.dir(argv);
+```
+
+```
+$ node example/parse.js -a beep -b boop
+{ _: [], a: 'beep', b: 'boop' }
+```
+
+```
+$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
+{ _: [ 'foo', 'bar', 'baz' ],
+  x: 3,
+  y: 4,
+  n: 5,
+  a: true,
+  b: true,
+  c: true,
+  beep: 'boop' }
+```
+
+# methods
+
+``` js
+var parseArgs = require('minimist')
+```
+
+## var argv = parseArgs(args, opts={})
+
+Return an argument object `argv` populated with the array arguments from `args`.
+
+`argv._` contains all the arguments that didn't have an option associated with
+them.
+
+Numeric-looking arguments will be returned as numbers unless `opts.string` or
+`opts.boolean` is set for that argument name.
+
+Any arguments after `'--'` will not be parsed and will end up in `argv._`.
+
+options can be:
+
+* `opts.string` - a string or array of strings argument names to always treat as
+strings
+* `opts.boolean` - a string or array of strings to always treat as booleans
+* `opts.alias` - an object mapping string names to strings or arrays of string
+argument names to use as aliases
+* `opts.default` - an object mapping string argument names to default values
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install minimist
+```
+
+# license
+
+MIT
diff --git a/node_modules/mkdirp/node_modules/minimist/test/dash.js b/node_modules/mkdirp/node_modules/minimist/test/dash.js
new file mode 100644
index 000000000..8b034b99a
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/dash.js
@@ -0,0 +1,24 @@
+var parse = require('../');
+var test = require('tape');
+
+test('-', function (t) {
+    t.plan(5);
+    t.deepEqual(parse([ '-n', '-' ]), { n: '-', _: [] });
+    t.deepEqual(parse([ '-' ]), { _: [ '-' ] });
+    t.deepEqual(parse([ '-f-' ]), { f: '-', _: [] });
+    t.deepEqual(
+        parse([ '-b', '-' ], { boolean: 'b' }),
+        { b: true, _: [ '-' ] }
+    );
+    t.deepEqual(
+        parse([ '-s', '-' ], { string: 's' }),
+        { s: '-', _: [] }
+    );
+});
+
+test('-a -- b', function (t) {
+    t.plan(3);
+    t.deepEqual(parse([ '-a', '--', 'b' ]), { a: true, _: [ 'b' ] });
+    t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
+    t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/default_bool.js b/node_modules/mkdirp/node_modules/minimist/test/default_bool.js
new file mode 100644
index 000000000..f0041ee40
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/default_bool.js
@@ -0,0 +1,20 @@
+var test = require('tape');
+var parse = require('../');
+
+test('boolean default true', function (t) {
+    var argv = parse([], {
+        boolean: 'sometrue',
+        default: { sometrue: true }
+    });
+    t.equal(argv.sometrue, true);
+    t.end();
+});
+
+test('boolean default false', function (t) {
+    var argv = parse([], {
+        boolean: 'somefalse',
+        default: { somefalse: false }
+    });
+    t.equal(argv.somefalse, false);
+    t.end();
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/dotted.js b/node_modules/mkdirp/node_modules/minimist/test/dotted.js
new file mode 100644
index 000000000..ef0ae349b
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/dotted.js
@@ -0,0 +1,16 @@
+var parse = require('../');
+var test = require('tape');
+
+test('dotted alias', function (t) {
+    var argv = parse(['--a.b', '22'], {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}});
+    t.equal(argv.a.b, 22);
+    t.equal(argv.aa.bb, 22);
+    t.end();
+});
+
+test('dotted default', function (t) {
+    var argv = parse('', {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}});
+    t.equal(argv.a.b, 11);
+    t.equal(argv.aa.bb, 11);
+    t.end();
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/long.js b/node_modules/mkdirp/node_modules/minimist/test/long.js
new file mode 100644
index 000000000..5d3a1e09d
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/long.js
@@ -0,0 +1,31 @@
+var test = require('tape');
+var parse = require('../');
+
+test('long opts', function (t) {
+    t.deepEqual(
+        parse([ '--bool' ]),
+        { bool : true, _ : [] },
+        'long boolean'
+    );
+    t.deepEqual(
+        parse([ '--pow', 'xixxle' ]),
+        { pow : 'xixxle', _ : [] },
+        'long capture sp'
+    );
+    t.deepEqual(
+        parse([ '--pow=xixxle' ]),
+        { pow : 'xixxle', _ : [] },
+        'long capture eq'
+    );
+    t.deepEqual(
+        parse([ '--host', 'localhost', '--port', '555' ]),
+        { host : 'localhost', port : 555, _ : [] },
+        'long captures sp'
+    );
+    t.deepEqual(
+        parse([ '--host=localhost', '--port=555' ]),
+        { host : 'localhost', port : 555, _ : [] },
+        'long captures eq'
+    );
+    t.end();
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/parse.js b/node_modules/mkdirp/node_modules/minimist/test/parse.js
new file mode 100644
index 000000000..8a9064669
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/parse.js
@@ -0,0 +1,318 @@
+var parse = require('../');
+var test = require('tape');
+
+test('parse args', function (t) {
+    t.deepEqual(
+        parse([ '--no-moo' ]),
+        { moo : false, _ : [] },
+        'no'
+    );
+    t.deepEqual(
+        parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
+        { v : ['a','b','c'], _ : [] },
+        'multi'
+    );
+    t.end();
+});
+ 
+test('comprehensive', function (t) {
+    t.deepEqual(
+        parse([
+            '--name=meowmers', 'bare', '-cats', 'woo',
+            '-h', 'awesome', '--multi=quux',
+            '--key', 'value',
+            '-b', '--bool', '--no-meep', '--multi=baz',
+            '--', '--not-a-flag', 'eek'
+        ]),
+        {
+            c : true,
+            a : true,
+            t : true,
+            s : 'woo',
+            h : 'awesome',
+            b : true,
+            bool : true,
+            key : 'value',
+            multi : [ 'quux', 'baz' ],
+            meep : false,
+            name : 'meowmers',
+            _ : [ 'bare', '--not-a-flag', 'eek' ]
+        }
+    );
+    t.end();
+});
+
+test('nums', function (t) {
+    var argv = parse([
+        '-x', '1234',
+        '-y', '5.67',
+        '-z', '1e7',
+        '-w', '10f',
+        '--hex', '0xdeadbeef',
+        '789'
+    ]);
+    t.deepEqual(argv, {
+        x : 1234,
+        y : 5.67,
+        z : 1e7,
+        w : '10f',
+        hex : 0xdeadbeef,
+        _ : [ 789 ]
+    });
+    t.deepEqual(typeof argv.x, 'number');
+    t.deepEqual(typeof argv.y, 'number');
+    t.deepEqual(typeof argv.z, 'number');
+    t.deepEqual(typeof argv.w, 'string');
+    t.deepEqual(typeof argv.hex, 'number');
+    t.deepEqual(typeof argv._[0], 'number');
+    t.end();
+});
+
+test('flag boolean', function (t) {
+    var argv = parse([ '-t', 'moo' ], { boolean: 't' });
+    t.deepEqual(argv, { t : true, _ : [ 'moo' ] });
+    t.deepEqual(typeof argv.t, 'boolean');
+    t.end();
+});
+
+test('flag boolean value', function (t) {
+    var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], {
+        boolean: [ 't', 'verbose' ],
+        default: { verbose: true }
+    });
+    
+    t.deepEqual(argv, {
+        verbose: false,
+        t: true,
+        _: ['moo']
+    });
+    
+    t.deepEqual(typeof argv.verbose, 'boolean');
+    t.deepEqual(typeof argv.t, 'boolean');
+    t.end();
+});
+
+test('flag boolean default false', function (t) {
+    var argv = parse(['moo'], {
+        boolean: ['t', 'verbose'],
+        default: { verbose: false, t: false }
+    });
+    
+    t.deepEqual(argv, {
+        verbose: false,
+        t: false,
+        _: ['moo']
+    });
+    
+    t.deepEqual(typeof argv.verbose, 'boolean');
+    t.deepEqual(typeof argv.t, 'boolean');
+    t.end();
+
+});
+
+test('boolean groups', function (t) {
+    var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], {
+        boolean: ['x','y','z']
+    });
+    
+    t.deepEqual(argv, {
+        x : true,
+        y : false,
+        z : true,
+        _ : [ 'one', 'two', 'three' ]
+    });
+    
+    t.deepEqual(typeof argv.x, 'boolean');
+    t.deepEqual(typeof argv.y, 'boolean');
+    t.deepEqual(typeof argv.z, 'boolean');
+    t.end();
+});
+
+test('newlines in params' , function (t) {
+    var args = parse([ '-s', "X\nX" ])
+    t.deepEqual(args, { _ : [], s : "X\nX" });
+    
+    // reproduce in bash:
+    // VALUE="new
+    // line"
+    // node program.js --s="$VALUE"
+    args = parse([ "--s=X\nX" ])
+    t.deepEqual(args, { _ : [], s : "X\nX" });
+    t.end();
+});
+
+test('strings' , function (t) {
+    var s = parse([ '-s', '0001234' ], { string: 's' }).s;
+    t.equal(s, '0001234');
+    t.equal(typeof s, 'string');
+    
+    var x = parse([ '-x', '56' ], { string: 'x' }).x;
+    t.equal(x, '56');
+    t.equal(typeof x, 'string');
+    t.end();
+});
+
+test('stringArgs', function (t) {
+    var s = parse([ '  ', '  ' ], { string: '_' })._;
+    t.same(s.length, 2);
+    t.same(typeof s[0], 'string');
+    t.same(s[0], '  ');
+    t.same(typeof s[1], 'string');
+    t.same(s[1], '  ');
+    t.end();
+});
+
+test('empty strings', function(t) {
+    var s = parse([ '-s' ], { string: 's' }).s;
+    t.equal(s, '');
+    t.equal(typeof s, 'string');
+
+    var str = parse([ '--str' ], { string: 'str' }).str;
+    t.equal(str, '');
+    t.equal(typeof str, 'string');
+
+    var letters = parse([ '-art' ], {
+        string: [ 'a', 't' ]
+    });
+
+    t.equal(letters.a, '');
+    t.equal(letters.r, true);
+    t.equal(letters.t, '');
+
+    t.end();
+});
+
+
+test('slashBreak', function (t) {
+    t.same(
+        parse([ '-I/foo/bar/baz' ]),
+        { I : '/foo/bar/baz', _ : [] }
+    );
+    t.same(
+        parse([ '-xyz/foo/bar/baz' ]),
+        { x : true, y : true, z : '/foo/bar/baz', _ : [] }
+    );
+    t.end();
+});
+
+test('alias', function (t) {
+    var argv = parse([ '-f', '11', '--zoom', '55' ], {
+        alias: { z: 'zoom' }
+    });
+    t.equal(argv.zoom, 55);
+    t.equal(argv.z, argv.zoom);
+    t.equal(argv.f, 11);
+    t.end();
+});
+
+test('multiAlias', function (t) {
+    var argv = parse([ '-f', '11', '--zoom', '55' ], {
+        alias: { z: [ 'zm', 'zoom' ] }
+    });
+    t.equal(argv.zoom, 55);
+    t.equal(argv.z, argv.zoom);
+    t.equal(argv.z, argv.zm);
+    t.equal(argv.f, 11);
+    t.end();
+});
+
+test('nested dotted objects', function (t) {
+    var argv = parse([
+        '--foo.bar', '3', '--foo.baz', '4',
+        '--foo.quux.quibble', '5', '--foo.quux.o_O',
+        '--beep.boop'
+    ]);
+    
+    t.same(argv.foo, {
+        bar : 3,
+        baz : 4,
+        quux : {
+            quibble : 5,
+            o_O : true
+        }
+    });
+    t.same(argv.beep, { boop : true });
+    t.end();
+});
+
+test('boolean and alias with chainable api', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp',  'derp' ];
+    var opts = {
+        herp: { alias: 'h', boolean: true }
+    };
+    var aliasedArgv = parse(aliased, {
+        boolean: 'herp',
+        alias: { h: 'herp' }
+    });
+    var propertyArgv = parse(regular, {
+        boolean: 'herp',
+        alias: { h: 'herp' }
+    });
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ]
+    };
+    
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+test('boolean and alias with options hash', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp', 'derp' ];
+    var opts = {
+        alias: { 'h': 'herp' },
+        boolean: 'herp'
+    };
+    var aliasedArgv = parse(aliased, opts);
+    var propertyArgv = parse(regular, opts);
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ]
+    };
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected);
+    t.end();
+});
+
+test('boolean and alias using explicit true', function (t) {
+    var aliased = [ '-h', 'true' ];
+    var regular = [ '--herp',  'true' ];
+    var opts = {
+        alias: { h: 'herp' },
+        boolean: 'h'
+    };
+    var aliasedArgv = parse(aliased, opts);
+    var propertyArgv = parse(regular, opts);
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ ]
+    };
+
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+// regression, see https://github.com/substack/node-optimist/issues/71
+test('boolean and --x=true', function(t) {
+    var parsed = parse(['--boool', '--other=true'], {
+        boolean: 'boool'
+    });
+
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'true');
+
+    parsed = parse(['--boool', '--other=false'], {
+        boolean: 'boool'
+    });
+    
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'false');
+    t.end();
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/parse_modified.js b/node_modules/mkdirp/node_modules/minimist/test/parse_modified.js
new file mode 100644
index 000000000..21851b036
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/parse_modified.js
@@ -0,0 +1,9 @@
+var parse = require('../');
+var test = require('tape');
+
+test('parse with modifier functions' , function (t) {
+    t.plan(1);
+    
+    var argv = parse([ '-b', '123' ], { boolean: 'b' });
+    t.deepEqual(argv, { b: true, _: ['123'] });
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/short.js b/node_modules/mkdirp/node_modules/minimist/test/short.js
new file mode 100644
index 000000000..d513a1c25
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/short.js
@@ -0,0 +1,67 @@
+var parse = require('../');
+var test = require('tape');
+
+test('numeric short args', function (t) {
+    t.plan(2);
+    t.deepEqual(parse([ '-n123' ]), { n: 123, _: [] });
+    t.deepEqual(
+        parse([ '-123', '456' ]),
+        { 1: true, 2: true, 3: 456, _: [] }
+    );
+});
+
+test('short', function (t) {
+    t.deepEqual(
+        parse([ '-b' ]),
+        { b : true, _ : [] },
+        'short boolean'
+    );
+    t.deepEqual(
+        parse([ 'foo', 'bar', 'baz' ]),
+        { _ : [ 'foo', 'bar', 'baz' ] },
+        'bare'
+    );
+    t.deepEqual(
+        parse([ '-cats' ]),
+        { c : true, a : true, t : true, s : true, _ : [] },
+        'group'
+    );
+    t.deepEqual(
+        parse([ '-cats', 'meow' ]),
+        { c : true, a : true, t : true, s : 'meow', _ : [] },
+        'short group next'
+    );
+    t.deepEqual(
+        parse([ '-h', 'localhost' ]),
+        { h : 'localhost', _ : [] },
+        'short capture'
+    );
+    t.deepEqual(
+        parse([ '-h', 'localhost', '-p', '555' ]),
+        { h : 'localhost', p : 555, _ : [] },
+        'short captures'
+    );
+    t.end();
+});
+ 
+test('mixed short bool and capture', function (t) {
+    t.same(
+        parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
+        {
+            f : true, p : 555, h : 'localhost',
+            _ : [ 'script.js' ]
+        }
+    );
+    t.end();
+});
+ 
+test('short and long', function (t) {
+    t.deepEqual(
+        parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
+        {
+            f : true, p : 555, h : 'localhost',
+            _ : [ 'script.js' ]
+        }
+    );
+    t.end();
+});
diff --git a/node_modules/mkdirp/node_modules/minimist/test/whitespace.js b/node_modules/mkdirp/node_modules/minimist/test/whitespace.js
new file mode 100644
index 000000000..8a52a58ce
--- /dev/null
+++ b/node_modules/mkdirp/node_modules/minimist/test/whitespace.js
@@ -0,0 +1,8 @@
+var parse = require('../');
+var test = require('tape');
+
+test('whitespace should be whitespace' , function (t) {
+    t.plan(1);
+    var x = parse([ '-x', '\t' ]).x;
+    t.equal(x, '\t');
+});
diff --git a/node_modules/mkdirp/package.json b/node_modules/mkdirp/package.json
new file mode 100644
index 000000000..e3ddef10a
--- /dev/null
+++ b/node_modules/mkdirp/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "mkdirp",
+  "description": "Recursively mkdir, like `mkdir -p`",
+  "version": "0.5.0",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "main": "./index",
+  "keywords": [
+    "mkdir",
+    "directory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/substack/node-mkdirp.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "dependencies": {
+    "minimist": "0.0.8"
+  },
+  "devDependencies": {
+    "tap": "~0.4.0",
+    "mock-fs": "~2.2.0"
+  },
+  "bin": {
+    "mkdirp": "bin/cmd.js"
+  },
+  "license": "MIT",
+  "readme": "# mkdirp\n\nLike `mkdir -p`, but in node.js!\n\n[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp)\n\n# example\n\n## pow.js\n\n```js\nvar mkdirp = require('mkdirp');\n    \nmkdirp('/tmp/foo/bar/baz', function (err) {\n    if (err) console.error(err)\n    else console.log('pow!')\n});\n```\n\nOutput\n\n```\npow!\n```\n\nAnd now /tmp/foo/bar/baz exists, huzzah!\n\n# methods\n\n```js\nvar mkdirp = require('mkdirp');\n```\n\n## mkdirp(dir, opts, cb)\n\nCreate a new directory and any necessary subdirectories at `dir` with octal\npermission string `opts.mode`. If `opts` is a non-object, it will be treated as\nthe `opts.mode`.\n\nIf `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.\n\n`cb(err, made)` fires with the error or the first directory `made`\nthat had to be created, if any.\n\nYou can optionally pass in an alternate `fs` implementation by passing in\n`opts.fs`. Your implementation should have `opts.fs.mkdir(path, mode, cb)` and\n`opts.fs.stat(path, cb)`.\n\n## mkdirp.sync(dir, opts)\n\nSynchronously create a new directory and any necessary subdirectories at `dir`\nwith octal permission string `opts.mode`. If `opts` is a non-object, it will be\ntreated as the `opts.mode`.\n\nIf `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.\n\nReturns the first directory that had to be created, if any.\n\nYou can optionally pass in an alternate `fs` implementation by passing in\n`opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and\n`opts.fs.statSync(path)`.\n\n# usage\n\nThis package also ships with a `mkdirp` command.\n\n```\nusage: mkdirp [DIR1,DIR2..] {OPTIONS}\n\n  Create each supplied directory including any necessary parent directories that\n  don't yet exist.\n  \n  If the directory already exists, do nothing.\n\nOPTIONS are:\n\n  -m, --mode   If a directory needs to be created, set the mode as an octal\n               permission string.\n\n```\n\n# install\n\nWith [npm](http://npmjs.org) do:\n\n```\nnpm install mkdirp\n```\n\nto get the library, or\n\n```\nnpm install -g mkdirp\n```\n\nto get the command.\n\n# license\n\nMIT\n",
+  "readmeFilename": "readme.markdown",
+  "bugs": {
+    "url": "https://github.com/substack/node-mkdirp/issues"
+  },
+  "homepage": "https://github.com/substack/node-mkdirp",
+  "_id": "mkdirp@0.5.0",
+  "_shasum": "1d73076a6df986cd9344e15e71fcc05a4c9abf12",
+  "_from": "mkdirp@>=0.3.5 <1.0.0-0",
+  "_resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.0.tgz"
+}
diff --git a/node_modules/mkdirp/readme.markdown b/node_modules/mkdirp/readme.markdown
new file mode 100644
index 000000000..3cc131538
--- /dev/null
+++ b/node_modules/mkdirp/readme.markdown
@@ -0,0 +1,100 @@
+# mkdirp
+
+Like `mkdir -p`, but in node.js!
+
+[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp)
+
+# example
+
+## pow.js
+
+```js
+var mkdirp = require('mkdirp');
+    
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});
+```
+
+Output
+
+```
+pow!
+```
+
+And now /tmp/foo/bar/baz exists, huzzah!
+
+# methods
+
+```js
+var mkdirp = require('mkdirp');
+```
+
+## mkdirp(dir, opts, cb)
+
+Create a new directory and any necessary subdirectories at `dir` with octal
+permission string `opts.mode`. If `opts` is a non-object, it will be treated as
+the `opts.mode`.
+
+If `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+`cb(err, made)` fires with the error or the first directory `made`
+that had to be created, if any.
+
+You can optionally pass in an alternate `fs` implementation by passing in
+`opts.fs`. Your implementation should have `opts.fs.mkdir(path, mode, cb)` and
+`opts.fs.stat(path, cb)`.
+
+## mkdirp.sync(dir, opts)
+
+Synchronously create a new directory and any necessary subdirectories at `dir`
+with octal permission string `opts.mode`. If `opts` is a non-object, it will be
+treated as the `opts.mode`.
+
+If `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+Returns the first directory that had to be created, if any.
+
+You can optionally pass in an alternate `fs` implementation by passing in
+`opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and
+`opts.fs.statSync(path)`.
+
+# usage
+
+This package also ships with a `mkdirp` command.
+
+```
+usage: mkdirp [DIR1,DIR2..] {OPTIONS}
+
+  Create each supplied directory including any necessary parent directories that
+  don't yet exist.
+  
+  If the directory already exists, do nothing.
+
+OPTIONS are:
+
+  -m, --mode   If a directory needs to be created, set the mode as an octal
+               permission string.
+
+```
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install mkdirp
+```
+
+to get the library, or
+
+```
+npm install -g mkdirp
+```
+
+to get the command.
+
+# license
+
+MIT
diff --git a/node_modules/mkdirp/test/chmod.js b/node_modules/mkdirp/test/chmod.js
new file mode 100644
index 000000000..520dcb8e9
--- /dev/null
+++ b/node_modules/mkdirp/test/chmod.js
@@ -0,0 +1,38 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+test('chmod-pre', function (t) {
+    var mode = 0744
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.equal(stat && stat.mode & 0777, mode, 'should be 0744');
+            t.end();
+        });
+    });
+});
+
+test('chmod', function (t) {
+    var mode = 0755
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.end();
+        });
+    });
+});
diff --git a/node_modules/mkdirp/test/clobber.js b/node_modules/mkdirp/test/clobber.js
new file mode 100644
index 000000000..0eb709987
--- /dev/null
+++ b/node_modules/mkdirp/test/clobber.js
@@ -0,0 +1,37 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+// a file in the way
+var itw = ps.slice(0, 3).join('/');
+
+
+test('clobber-pre', function (t) {
+    console.error("about to write to "+itw)
+    fs.writeFileSync(itw, 'I AM IN THE WAY, THE TRUTH, AND THE LIGHT.');
+
+    fs.stat(itw, function (er, stat) {
+        t.ifError(er)
+        t.ok(stat && stat.isFile(), 'should be file')
+        t.end()
+    })
+})
+
+test('clobber', function (t) {
+    t.plan(2);
+    mkdirp(file, 0755, function (err) {
+        t.ok(err);
+        t.equal(err.code, 'ENOTDIR');
+        t.end();
+    });
+});
diff --git a/node_modules/mkdirp/test/mkdirp.js b/node_modules/mkdirp/test/mkdirp.js
new file mode 100644
index 000000000..3b624ddbe
--- /dev/null
+++ b/node_modules/mkdirp/test/mkdirp.js
@@ -0,0 +1,26 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('woo', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});
diff --git a/node_modules/mkdirp/test/opts_fs.js b/node_modules/mkdirp/test/opts_fs.js
new file mode 100644
index 000000000..f1fbeca14
--- /dev/null
+++ b/node_modules/mkdirp/test/opts_fs.js
@@ -0,0 +1,27 @@
+var mkdirp = require('../');
+var path = require('path');
+var test = require('tap').test;
+var mockfs = require('mock-fs');
+
+test('opts.fs', function (t) {
+    t.plan(5);
+    
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/beep/boop/' + [x,y,z].join('/');
+    var xfs = mockfs.fs();
+    
+    mkdirp(file, { fs: xfs, mode: 0755 }, function (err) {
+        t.ifError(err);
+        xfs.exists(file, function (ex) {
+            t.ok(ex, 'created file');
+            xfs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            });
+        });
+    });
+});
diff --git a/node_modules/mkdirp/test/opts_fs_sync.js b/node_modules/mkdirp/test/opts_fs_sync.js
new file mode 100644
index 000000000..224b50642
--- /dev/null
+++ b/node_modules/mkdirp/test/opts_fs_sync.js
@@ -0,0 +1,25 @@
+var mkdirp = require('../');
+var path = require('path');
+var test = require('tap').test;
+var mockfs = require('mock-fs');
+
+test('opts.fs sync', function (t) {
+    t.plan(4);
+    
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/beep/boop/' + [x,y,z].join('/');
+    var xfs = mockfs.fs();
+    
+    mkdirp.sync(file, { fs: xfs, mode: 0755 });
+    xfs.exists(file, function (ex) {
+        t.ok(ex, 'created file');
+        xfs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});
diff --git a/node_modules/mkdirp/test/perm.js b/node_modules/mkdirp/test/perm.js
new file mode 100644
index 000000000..2c9759052
--- /dev/null
+++ b/node_modules/mkdirp/test/perm.js
@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('async perm', function (t) {
+    t.plan(5);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16);
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});
+
+test('async root perm', function (t) {
+    mkdirp('/tmp', 0755, function (err) {
+        if (err) t.fail(err);
+        t.end();
+    });
+    t.end();
+});
diff --git a/node_modules/mkdirp/test/perm_sync.js b/node_modules/mkdirp/test/perm_sync.js
new file mode 100644
index 000000000..327e54b2e
--- /dev/null
+++ b/node_modules/mkdirp/test/perm_sync.js
@@ -0,0 +1,34 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('sync perm', function (t) {
+    t.plan(4);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16) + '.json';
+    
+    mkdirp.sync(file, 0755);
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});
+
+test('sync root perm', function (t) {
+    t.plan(3);
+    
+    var file = '/tmp';
+    mkdirp.sync(file, 0755);
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        })
+    });
+});
diff --git a/node_modules/mkdirp/test/race.js b/node_modules/mkdirp/test/race.js
new file mode 100644
index 000000000..7c295f410
--- /dev/null
+++ b/node_modules/mkdirp/test/race.js
@@ -0,0 +1,40 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('race', function (t) {
+    t.plan(6);
+    var ps = [ '', 'tmp' ];
+    
+    for (var i = 0; i < 25; i++) {
+        var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+        ps.push(dir);
+    }
+    var file = ps.join('/');
+    
+    var res = 2;
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    function mk (file, cb) {
+        mkdirp(file, 0755, function (err) {
+            t.ifError(err);
+            exists(file, function (ex) {
+                t.ok(ex, 'file created');
+                fs.stat(file, function (err, stat) {
+                    t.ifError(err);
+                    t.equal(stat.mode & 0777, 0755);
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    if (cb) cb();
+                });
+            })
+        });
+    }
+});
diff --git a/node_modules/mkdirp/test/rel.js b/node_modules/mkdirp/test/rel.js
new file mode 100644
index 000000000..d1f175c24
--- /dev/null
+++ b/node_modules/mkdirp/test/rel.js
@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('rel', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var cwd = process.cwd();
+    process.chdir('/tmp');
+    
+    var file = [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                process.chdir(cwd);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});
diff --git a/node_modules/mkdirp/test/return.js b/node_modules/mkdirp/test/return.js
new file mode 100644
index 000000000..bce68e561
--- /dev/null
+++ b/node_modules/mkdirp/test/return.js
@@ -0,0 +1,25 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    mkdirp(file, function (err, made) {
+        t.ifError(err);
+        t.equal(made, '/tmp/' + x);
+        mkdirp(file, function (err, made) {
+          t.ifError(err);
+          t.equal(made, null);
+        });
+    });
+});
diff --git a/node_modules/mkdirp/test/return_sync.js b/node_modules/mkdirp/test/return_sync.js
new file mode 100644
index 000000000..7c222d355
--- /dev/null
+++ b/node_modules/mkdirp/test/return_sync.js
@@ -0,0 +1,24 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    // Note that this will throw on failure, which will fail the test.
+    var made = mkdirp.sync(file);
+    t.equal(made, '/tmp/' + x);
+
+    // making the same file again should have no effect.
+    made = mkdirp.sync(file);
+    t.equal(made, null);
+});
diff --git a/node_modules/mkdirp/test/root.js b/node_modules/mkdirp/test/root.js
new file mode 100644
index 000000000..97ad7a2f3
--- /dev/null
+++ b/node_modules/mkdirp/test/root.js
@@ -0,0 +1,18 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('root', function (t) {
+    // '/' on unix, 'c:/' on windows.
+    var file = path.resolve('/');
+
+    mkdirp(file, 0755, function (err) {
+        if (err) throw err
+        fs.stat(file, function (er, stat) {
+            if (er) throw er
+            t.ok(stat.isDirectory(), 'target is a directory');
+            t.end();
+        })
+    });
+});
diff --git a/node_modules/mkdirp/test/sync.js b/node_modules/mkdirp/test/sync.js
new file mode 100644
index 000000000..88fa4324e
--- /dev/null
+++ b/node_modules/mkdirp/test/sync.js
@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('sync', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file, 0755);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});
diff --git a/node_modules/mkdirp/test/umask.js b/node_modules/mkdirp/test/umask.js
new file mode 100644
index 000000000..82c393a00
--- /dev/null
+++ b/node_modules/mkdirp/test/umask.js
@@ -0,0 +1,26 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('implicit mode from umask', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0777 & (~process.umask()));
+                t.ok(stat.isDirectory(), 'target not a directory');
+            });
+        })
+    });
+});
diff --git a/node_modules/mkdirp/test/umask_sync.js b/node_modules/mkdirp/test/umask_sync.js
new file mode 100644
index 000000000..e537fbe4b
--- /dev/null
+++ b/node_modules/mkdirp/test/umask_sync.js
@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('umask sync modes', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, (0777 & (~process.umask())));
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});
diff --git a/node_modules/onclick/.npmignore b/node_modules/onclick/.npmignore
new file mode 100755
index 000000000..69fd427f4
--- /dev/null
+++ b/node_modules/onclick/.npmignore
@@ -0,0 +1,43 @@
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Node Stuff #
+##############
+node_modules/
+
+
diff --git a/node_modules/onclick/.travis.yml b/node_modules/onclick/.travis.yml
new file mode 100644
index 000000000..eb8ff8b24
--- /dev/null
+++ b/node_modules/onclick/.travis.yml
@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.8"
+before_script: 
+  - npm install grunt-cli -g
diff --git a/node_modules/onclick/Gruntfile.js b/node_modules/onclick/Gruntfile.js
new file mode 100644
index 000000000..3388feba9
--- /dev/null
+++ b/node_modules/onclick/Gruntfile.js
@@ -0,0 +1,61 @@
+module.exports = function(grunt) {
+    grunt.initConfig({
+        pkg: grunt.file.readJSON('package.json'),
+        browserify: {
+            dist: {
+                files: {
+                    'dist/onClick.js':      ['src/onClick.js'],
+                    'examples/build.js':    ['examples/example.js']
+                },
+                options: {
+                    standalone: 'onClick'
+                }
+            },
+            test: {
+                files: {
+                    'test/build.js':        ['test/test.js']
+                }
+            }
+        },
+        uglify: {
+            dist: {
+                files: {
+                    'dist/onClick.min.js': ['dist/onClick.js']
+                },
+                options: {
+                    sourceMap: true
+                }
+            }
+        },
+        watch: {
+            files: [ "src/*.js", "examples/example.js", "test/test.js"],
+            tasks: [ 'browserify:dist' ]
+        },
+        qunit: {
+            files: ['test/index.html']
+        },
+        jshint: {
+            dist: {
+                src: ['src/**/*.js']
+            }
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-browserify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-contrib-qunit');
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+    grunt.loadNpmTasks('grunt-contrib-jshint');
+
+    grunt.registerTask('test', [
+        'browserify:test',
+        'qunit',
+        'jshint'
+    ]);
+
+    grunt.registerTask('build', [
+        'test',
+        'browserify:dist',
+        'uglify'
+    ]);
+};
diff --git a/node_modules/onclick/README.md b/node_modules/onclick/README.md
new file mode 100644
index 000000000..71bfb0af7
--- /dev/null
+++ b/node_modules/onclick/README.md
@@ -0,0 +1,47 @@
+onClick.js [![Build Status](https://travis-ci.org/bpeacock/onClick.png?branch=master)](https://travis-ci.org/bpeacock/onClick)
+===============
+
+A click controller for mouse & touch.
+
+- Prevents 300ms delay on touch
+- Touch interactions like scrolling work as expected
+- Handles devices that have both touch and mouse
+- Delegates events for efficiency
+
+Installation
+------------
+
+```bash
+npm install onclick
+```
+
+A jQuery-like selector library is required:
+- jQuery 1.4.3+
+- Zepto
+
+Usage
+-----
+
+```javascript
+onClick({
+    '#element': function(e) {
+        alert("I was clicked!");
+    }
+});
+
+onClick('.myclass', function() {
+
+});
+```
+
+Check out a live [example](http://htmlpreview.github.io/?https://github.com/bpeacock/onClick/blob/master/examples/index.html).
+
+Development
+-----------
+
+To Build:   `grunt build`
+
+To Develop: `grunt watch`
+
+To Test:    `npm test`
+ 
diff --git a/node_modules/onclick/dist/onClick.js b/node_modules/onclick/dist/onClick.js
new file mode 100644
index 000000000..f2fdb5c37
--- /dev/null
+++ b/node_modules/onclick/dist/onClick.js
@@ -0,0 +1,195 @@
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.onClick=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+(function (global){
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],2:[function(_dereq_,module,exports){
+var $ = _dereq_('unopinionate').selector;
+
+var $document   = $(document),
+    bindings    = {};
+
+var click = function(events) {
+    click.bind.apply(click, arguments);
+    return click;
+};
+
+/*** Configuration Options ***/
+click.distanceLimit = 10;
+click.timeLimit     = 140;
+
+/*** Useful Properties ***/
+click.isTouch = ('ontouchstart' in window) ||
+                window.DocumentTouch &&
+                document instanceof DocumentTouch;
+
+/*** Cached Functions ***/
+var onTouchstart = function(e) {
+    e.stopPropagation(); //Prevents multiple click events from happening
+
+    click._doAnywheres(e);
+
+    var $this       = $(this),
+        startTime   = new Date().getTime(),
+        startPos    = click._getPos(e);
+
+    $this.one('touchend', function(e) {
+        e.preventDefault(); //Prevents click event from firing
+        
+        var time        = new Date().getTime() - startTime,
+            endPos      = click._getPos(e),
+            distance    = Math.sqrt(
+                Math.pow(endPos.x - startPos.x, 2) +
+                Math.pow(endPos.y - startPos.y, 2)
+            );
+
+        if(time < click.timeLimit && distance < click.distanceLimit) {
+            //Find the correct callback
+            $.each(bindings, function(selector, callback) {
+                if($this.is(selector)) {
+                    callback.apply(e.target, [e]);
+                    return false;
+                }
+            });
+        }
+    });
+};
+
+/*** API ***/
+click.bind = function(events) {
+
+    //Argument Surgery
+    if(!$.isPlainObject(events)) {
+        newEvents = {};
+        newEvents[arguments[0]] = arguments[1];
+        events = newEvents;
+    }
+
+    $.each(events, function(selector, callback) {
+
+        /*** Register Binding ***/
+        if(typeof bindings[selector] != 'undefined') {
+            click.unbind(selector); //Ensure no duplicates
+        }
+        
+        bindings[selector] = callback;
+
+        /*** Touch Support ***/
+        if(click.isTouch) {
+            $document.delegate(selector, 'touchstart', onTouchstart);
+        }
+
+        /*** Mouse Support ***/
+        $document.delegate(selector, 'click', function(e) {
+            e.stopPropagation(); //Prevents multiple click events from happening
+            //click._doAnywheres(e); //Do anywheres first to be consistent with touch order
+            callback.apply(this, [e]);
+        });
+    });
+
+    return this;
+};
+
+click.unbind = function(selector) {
+    $document
+        .undelegate(selector, 'touchstart')
+        .undelegate(selector, 'click');
+
+    delete bindings[selector];
+
+    return this;
+};
+
+click.unbindAll = function() {
+    $.each(bindings, function(selector, callback) {
+        $document
+            .undelegate(selector, 'touchstart')
+            .undelegate(selector, 'click');
+    });
+    
+    bindings = {};
+
+    return this;
+};
+
+click.trigger = function(selector, e) {
+    e = e || $.Event('click');
+
+    if(typeof bindings[selector] != 'undefined') {
+        bindings[selector](e);
+    }
+    else {
+        console.error("No click events bound for selector '"+selector+"'.");
+    }
+
+    return this;
+};
+
+click.anywhere = function(callback) {
+    click._anywheres.push(callback);
+    return this;
+};
+
+/*** Internal (but useful) Methods ***/
+click._getPos = function(e) {
+    e = e.originalEvent;
+
+    if(e.pageX || e.pageY) {
+        return {
+            x: e.pageX,
+            y: e.pageY
+        };
+    }
+    else if(e.changedTouches) {
+        return {
+            x: e.changedTouches[0].clientX,
+            y: e.changedTouches[0].clientY
+        };
+    }
+    else {
+        return {
+            x: e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft,
+            y: e.clientY + document.body.scrollTop  + document.documentElement.scrollTop
+        };
+    }
+};
+
+click._anywheres = [];
+
+click._doAnywheres = function(e) {
+    var i = click._anywheres.length;
+    while(i--) {
+        click._anywheres[i](e);
+    }
+};
+
+$(document).bind('mousedown', click._doAnywheres);
+
+module.exports = click;
+
+
+},{"unopinionate":1}]},{},[2])
+(2)
+});
\ No newline at end of file
diff --git a/node_modules/onclick/dist/onClick.min.js b/node_modules/onclick/dist/onClick.min.js
new file mode 100644
index 000000000..a816aaeb7
--- /dev/null
+++ b/node_modules/onclick/dist/onClick.min.js
@@ -0,0 +1,2 @@
+!function(a){if("object"==typeof exports)module.exports=a();else if("function"==typeof define&&define.amd)define(a);else{var b;"undefined"!=typeof window?b=window:"undefined"!=typeof global?b=global:"undefined"!=typeof self&&(b=self),b.onClick=a()}}(function(){var a;return function b(a,c,d){function e(g,h){if(!c[g]){if(!a[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);throw new Error("Cannot find module '"+g+"'")}var j=c[g]={exports:{}};a[g][0].call(j.exports,function(b){var c=a[g][1][b];return e(c?c:b)},j,j.exports,b,a,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(b,c){(function(b){!function(b){var d={selector:b.jQuery||b.Zepto||b.ender||b.$,template:b.Handlebars||b.Mustache};"function"==typeof a&&a.amd?a([],function(){return d}):"undefined"!=typeof c.exports?c.exports=d:b.unopinionate=d}("undefined"!=typeof window?window:b)}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],2:[function(a,b){var c=a("unopinionate").selector,d=c(document),e={},f=function(a){return f.bind(a),f};f.distanceLimit=10,f.timeLimit=140,f.isTouch="ontouchstart"in window||window.DocumentTouch&&document instanceof DocumentTouch;var g=function(a){var b=c(this),d=(new Date).getTime(),g=f._getPos(a);b.one("touchend",function(a){a.preventDefault();var h=(new Date).getTime()-d,i=f._getPos(a),j=Math.sqrt(Math.pow(i.x-g.x,2)+Math.pow(i.y-g.y,2));h<f.timeLimit&&j<f.distanceLimit&&c.each(e,function(c,d){return b.is(c)?(d.apply(a.target,[a]),!1):void 0})})};f.bind=function(a){return c.isPlainObject(a)||(newEvents={},newEvents[arguments[0]]=arguments[1],a=newEvents),c.each(a,function(a,b){"undefined"!=typeof e[a]&&f.unbind(a),e[a]=b,f.isTouch&&d.delegate(a,"touchstart",g),d.delegate(a,"click",b)}),this},f.unbind=function(a){return d.undelegate(a,"touchstart").undelegate(a,"click"),delete e[a],this},f.unbindAll=function(){return c.each(e,function(a){d.undelegate(a,"touchstart").undelegate(a,"click")}),e={},this},f.trigger=function(a,b){return b=b||c.Event("click"),"undefined"!=typeof e[a]?e[a](b):console.error("No click events bound for selector '"+a+"'."),this},f._getPos=function(a){return a=a.originalEvent,a.pageX||a.pageY?{x:a.pageX,y:a.pageY}:a.changedTouches?{x:a.changedTouches[0].clientX,y:a.changedTouches[0].clientY}:{x:a.clientX+document.body.scrollLeft+document.documentElement.scrollLeft,y:a.clientY+document.body.scrollTop+document.documentElement.scrollTop}},b.exports=f},{unopinionate:1}]},{},[2])(2)});
+//# sourceMappingURL=onClick.min.map
\ No newline at end of file
diff --git a/node_modules/onclick/dist/onClick.min.map b/node_modules/onclick/dist/onClick.min.map
new file mode 100644
index 000000000..9eb622829
--- /dev/null
+++ b/node_modules/onclick/dist/onClick.min.map
@@ -0,0 +1 @@
+{"version":3,"file":"onClick.min.js","sources":["onClick.js"],"names":["e","exports","module","define","amd","f","window","global","self","onClick","t","n","r","s","o","u","a","require","i","Error","call","length",1,"_dereq_","root","unopinionate","selector","jQuery","Zepto","ender","$","template","Handlebars","Mustache","this",2,"$document","document","bindings","click","events","bind","distanceLimit","timeLimit","isTouch","DocumentTouch","onTouchstart","$this","startTime","Date","getTime","startPos","_getPos","one","preventDefault","time","endPos","distance","Math","sqrt","pow","x","y","each","callback","is","apply","target","isPlainObject","newEvents","arguments","unbind","delegate","undelegate","unbindAll","trigger","Event","console","error","originalEvent","pageX","pageY","changedTouches","clientX","clientY","body","scrollLeft","documentElement","scrollTop"],"mappings":"CAAC,SAASA,GAAG,GAAG,gBAAiBC,SAAQC,OAAOD,QAAQD,QAAS,IAAG,kBAAmBG,SAAQA,OAAOC,IAAID,OAAOH,OAAO,CAAC,GAAIK,EAAE,oBAAoBC,QAAOD,EAAEC,OAAO,mBAAoBC,QAAOF,EAAEE,OAAO,mBAAoBC,QAAOH,EAAEG,MAAMH,EAAEI,QAAQT,MAAM,WAAW,GAAIG,EAAsB,OAAO,SAAUH,GAAEU,EAAEC,EAAEC,GAAG,QAASC,GAAEC,EAAEC,GAAG,IAAIJ,EAAEG,GAAG,CAAC,IAAIJ,EAAEI,GAAG,CAAC,GAAIE,GAAkB,kBAATC,UAAqBA,OAAQ,KAAIF,GAAGC,EAAE,MAAOA,GAAEF,GAAE,EAAI,IAAGI,EAAE,MAAOA,GAAEJ,GAAE,EAAI,MAAM,IAAIK,OAAM,uBAAuBL,EAAE,KAAK,GAAIT,GAAEM,EAAEG,IAAIb,WAAYS,GAAEI,GAAG,GAAGM,KAAKf,EAAEJ,QAAQ,SAASD,GAAG,GAAIW,GAAED,EAAEI,GAAG,GAAGd,EAAG,OAAOa,GAAEF,EAAEA,EAAEX,IAAIK,EAAEA,EAAEJ,QAAQD,EAAEU,EAAEC,EAAEC,GAAG,MAAOD,GAAEG,GAAGb,QAAkD,IAAI,GAA1CiB,GAAkB,kBAATD,UAAqBA,QAAgBH,EAAE,EAAEA,EAAEF,EAAES,OAAOP,IAAID,EAAED,EAAEE,GAAI,OAAOD,KAAKS,GAAG,SAASC,EAAQrB,IACptB,SAAWK,IACX,SAAUiB,GACN,GAAIC,IACAC,SAAUF,EAAKG,QAAUH,EAAKI,OAASJ,EAAKK,OAASL,EAAKM,EAC1DC,SAAUP,EAAKQ,YAAcR,EAAKS,SAMjB,mBAAX9B,IAAyBA,EAAOC,IACtCD,KAAW,WACP,MAAOsB,KAImB,mBAAnBvB,GAAOD,QAClBC,EAAOD,QAAUwB,EAIjBD,EAAKC,aAAeA,GAER,mBAAVnB,QAAwBA,OAASC,KAExCa,KAAKc,KAAqB,mBAAT1B,MAAuBA,KAAyB,mBAAXF,QAAyBA,gBAC5E6B,GAAG,SAASZ,EAAQrB,GAC1B,GAAI4B,GAAIP,EAAQ,gBAAgBG,SAE5BU,EAAcN,EAAEO,UAChBC,KAEAC,EAAQ,SAASC,GAEjB,MADAD,GAAME,KAAKD,GACJD,EAIXA,GAAMG,cAAgB,GACtBH,EAAMI,UAAgB,IAGtBJ,EAAMK,QAAW,gBAAkBtC,SACnBA,OAAOuC,eACPR,mBAAoBQ,cAGpC,IAAIC,GAAe,SAAS9C,GACxB,GAAI+C,GAAcjB,EAAEI,MAChBc,GAAc,GAAIC,OAAOC,UACzBC,EAAcZ,EAAMa,QAAQpD,EAEhC+C,GAAMM,IAAI,WAAY,SAASrD,GAC3BA,EAAEsD,gBAEF,IAAIC,IAAc,GAAIN,OAAOC,UAAYF,EACrCQ,EAAcjB,EAAMa,QAAQpD,GAC5ByD,EAAcC,KAAKC,KACfD,KAAKE,IAAIJ,EAAOK,EAAIV,EAASU,EAAG,GAChCH,KAAKE,IAAIJ,EAAOM,EAAIX,EAASW,EAAG,GAGrCP,GAAOhB,EAAMI,WAAac,EAAWlB,EAAMG,eAE1CZ,EAAEiC,KAAKzB,EAAU,SAASZ,EAAUsC,GAChC,MAAGjB,GAAMkB,GAAGvC,IACRsC,EAASE,MAAMlE,EAAEmE,QAASnE,KACnB,GAFX,WAUhBuC,GAAME,KAAO,SAASD,GA2BlB,MAxBIV,GAAEsC,cAAc5B,KAChB6B,aACAA,UAAUC,UAAU,IAAMA,UAAU,GACpC9B,EAAS6B,WAGbvC,EAAEiC,KAAKvB,EAAQ,SAASd,EAAUsC,GAGE,mBAAtB1B,GAASZ,IACfa,EAAMgC,OAAO7C,GAGjBY,EAASZ,GAAYsC,EAGlBzB,EAAMK,SACLR,EAAUoC,SAAS9C,EAAU,aAAcoB,GAI/CV,EAAUoC,SAAS9C,EAAU,QAASsC,KAGnC9B,MAGXK,EAAMgC,OAAS,SAAS7C,GAOpB,MANAU,GACKqC,WAAW/C,EAAU,cACrB+C,WAAW/C,EAAU,eAEnBY,GAASZ,GAETQ,MAGXK,EAAMmC,UAAY,WASd,MARA5C,GAAEiC,KAAKzB,EAAU,SAASZ,GACtBU,EACKqC,WAAW/C,EAAU,cACrB+C,WAAW/C,EAAU,WAG9BY,KAEOJ,MAGXK,EAAMoC,QAAU,SAASjD,EAAU1B,GAU/B,MATAA,GAAIA,GAAK8B,EAAE8C,MAAM,SAEe,mBAAtBtC,GAASZ,GACfY,EAASZ,GAAU1B,GAGnB6E,QAAQC,MAAM,uCAAuCpD,EAAS,MAG3DQ,MAIXK,EAAMa,QAAU,SAASpD,GAGrB,MAFAA,GAAIA,EAAE+E,cAEH/E,EAAEgF,OAAShF,EAAEiF,OAERpB,EAAG7D,EAAEgF,MACLlB,EAAG9D,EAAEiF,OAGLjF,EAAEkF,gBAEFrB,EAAG7D,EAAEkF,eAAe,GAAGC,QACvBrB,EAAG9D,EAAEkF,eAAe,GAAGE,UAKvBvB,EAAG7D,EAAEmF,QAAU9C,SAASgD,KAAKC,WAAajD,SAASkD,gBAAgBD,WACnExB,EAAG9D,EAAEoF,QAAU/C,SAASgD,KAAKG,UAAanD,SAASkD,gBAAgBC,YAK/EtF,EAAOD,QAAUsC,IAGdd,aAAe,SAAS,IAC1B"}
\ No newline at end of file
diff --git a/node_modules/onclick/examples/build.js b/node_modules/onclick/examples/build.js
new file mode 100644
index 000000000..a3894bc8b
--- /dev/null
+++ b/node_modules/onclick/examples/build.js
@@ -0,0 +1,208 @@
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.onClick=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+var click = _dereq_("../src/onClick.js");
+
+click({
+    '#element': function(e) {
+        alert("You clicked!");
+    }
+});
+
+click('.elementSet', function(e) {
+    alert("You clicked the set");
+});
+
+},{"../src/onClick.js":3}],2:[function(_dereq_,module,exports){
+(function (global){
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],3:[function(_dereq_,module,exports){
+var $ = _dereq_('unopinionate').selector;
+
+var $document   = $(document),
+    bindings    = {};
+
+var click = function(events) {
+    click.bind.apply(click, arguments);
+    return click;
+};
+
+/*** Configuration Options ***/
+click.distanceLimit = 10;
+click.timeLimit     = 140;
+
+/*** Useful Properties ***/
+click.isTouch = ('ontouchstart' in window) ||
+                window.DocumentTouch &&
+                document instanceof DocumentTouch;
+
+/*** Cached Functions ***/
+var onTouchstart = function(e) {
+    e.stopPropagation(); //Prevents multiple click events from happening
+
+    click._doAnywheres(e);
+
+    var $this       = $(this),
+        startTime   = new Date().getTime(),
+        startPos    = click._getPos(e);
+
+    $this.one('touchend', function(e) {
+        e.preventDefault(); //Prevents click event from firing
+        
+        var time        = new Date().getTime() - startTime,
+            endPos      = click._getPos(e),
+            distance    = Math.sqrt(
+                Math.pow(endPos.x - startPos.x, 2) +
+                Math.pow(endPos.y - startPos.y, 2)
+            );
+
+        if(time < click.timeLimit && distance < click.distanceLimit) {
+            //Find the correct callback
+            $.each(bindings, function(selector, callback) {
+                if($this.is(selector)) {
+                    callback.apply(e.target, [e]);
+                    return false;
+                }
+            });
+        }
+    });
+};
+
+/*** API ***/
+click.bind = function(events) {
+
+    //Argument Surgery
+    if(!$.isPlainObject(events)) {
+        newEvents = {};
+        newEvents[arguments[0]] = arguments[1];
+        events = newEvents;
+    }
+
+    $.each(events, function(selector, callback) {
+
+        /*** Register Binding ***/
+        if(typeof bindings[selector] != 'undefined') {
+            click.unbind(selector); //Ensure no duplicates
+        }
+        
+        bindings[selector] = callback;
+
+        /*** Touch Support ***/
+        if(click.isTouch) {
+            $document.delegate(selector, 'touchstart', onTouchstart);
+        }
+
+        /*** Mouse Support ***/
+        $document.delegate(selector, 'click', function(e) {
+            e.stopPropagation(); //Prevents multiple click events from happening
+            //click._doAnywheres(e); //Do anywheres first to be consistent with touch order
+            callback.apply(this, [e]);
+        });
+    });
+
+    return this;
+};
+
+click.unbind = function(selector) {
+    $document
+        .undelegate(selector, 'touchstart')
+        .undelegate(selector, 'click');
+
+    delete bindings[selector];
+
+    return this;
+};
+
+click.unbindAll = function() {
+    $.each(bindings, function(selector, callback) {
+        $document
+            .undelegate(selector, 'touchstart')
+            .undelegate(selector, 'click');
+    });
+    
+    bindings = {};
+
+    return this;
+};
+
+click.trigger = function(selector, e) {
+    e = e || $.Event('click');
+
+    if(typeof bindings[selector] != 'undefined') {
+        bindings[selector](e);
+    }
+    else {
+        console.error("No click events bound for selector '"+selector+"'.");
+    }
+
+    return this;
+};
+
+click.anywhere = function(callback) {
+    click._anywheres.push(callback);
+    return this;
+};
+
+/*** Internal (but useful) Methods ***/
+click._getPos = function(e) {
+    e = e.originalEvent;
+
+    if(e.pageX || e.pageY) {
+        return {
+            x: e.pageX,
+            y: e.pageY
+        };
+    }
+    else if(e.changedTouches) {
+        return {
+            x: e.changedTouches[0].clientX,
+            y: e.changedTouches[0].clientY
+        };
+    }
+    else {
+        return {
+            x: e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft,
+            y: e.clientY + document.body.scrollTop  + document.documentElement.scrollTop
+        };
+    }
+};
+
+click._anywheres = [];
+
+click._doAnywheres = function(e) {
+    var i = click._anywheres.length;
+    while(i--) {
+        click._anywheres[i](e);
+    }
+};
+
+$(document).bind('mousedown', click._doAnywheres);
+
+module.exports = click;
+
+
+},{"unopinionate":2}]},{},[1])
+(1)
+});
\ No newline at end of file
diff --git a/node_modules/onclick/examples/example.css b/node_modules/onclick/examples/example.css
new file mode 100644
index 000000000..0167d7682
--- /dev/null
+++ b/node_modules/onclick/examples/example.css
@@ -0,0 +1,23 @@
+body {
+    font-family: Avenir, "Helvetica Neue", Helvetica, sans-serif;
+}
+
+#element {
+    background:     #0079E9;
+    width:          100px;
+    line-height:    40px;
+    color:          white;
+    text-align:     center;
+    border-radius:  3px;
+    cursor:         pointer;
+}
+
+.elementSet {
+    background: #EB6161;
+    width: 50px;
+    height: 25px;
+    display: inline-block;
+    margin: 5px 0;
+    border-radius: 3px;
+    cursor: pointer;
+}
\ No newline at end of file
diff --git a/node_modules/onclick/examples/example.js b/node_modules/onclick/examples/example.js
new file mode 100644
index 000000000..6dfebeb4e
--- /dev/null
+++ b/node_modules/onclick/examples/example.js
@@ -0,0 +1,11 @@
+var click = require("../src/onClick.js");
+
+click({
+    '#element': function(e) {
+        alert("You clicked!");
+    }
+});
+
+click('.elementSet', function(e) {
+    alert("You clicked the set");
+});
diff --git a/node_modules/onclick/examples/index.html b/node_modules/onclick/examples/index.html
new file mode 100644
index 000000000..6d5d6dbd0
--- /dev/null
+++ b/node_modules/onclick/examples/index.html
@@ -0,0 +1,27 @@
+<html>
+    <head>
+        <title>Click Example</title>
+
+        <!-- Prevent Mobile Zooming -->
+        <meta content='True' name='HandheldFriendly' />
+        <meta name="apple-mobile-web-app-capable" content="yes" />
+        <meta name="viewport" content="width=device-width, minimum-scale=1.0, maximum-scale=1.0, initial-scale=1.0, user-scalable=no">
+        
+        <!-- Prevent Tap Highlight on Windows 8 -->
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="msapplication-tap-highlight" content="no"/>
+
+        <link rel="stylesheet" type="text/css" href="example.css">
+    </head>
+
+    <body>
+        <div id='element'>Click Me</div>
+
+        <div class='elementSet'></div>
+        <div class='elementSet'></div>
+        <div class='elementSet'></div>
+
+        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+        <script id='main' src="build.js"></script>
+    </body>
+</html>
diff --git a/node_modules/onclick/package.json b/node_modules/onclick/package.json
new file mode 100644
index 000000000..b4325d41d
--- /dev/null
+++ b/node_modules/onclick/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "onclick",
+  "description": "A click controller for mouse & touch.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Brian Peacock"
+  },
+  "main": "src/onClick.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bpeacock/onClick"
+  },
+  "dependencies": {
+    "unopinionate": "0.0.x"
+  },
+  "devDependencies": {
+    "browserify": "3.24.x",
+    "grunt": "~0.4.2",
+    "grunt-contrib-watch": "0.5.x",
+    "grunt-browserify": "1.3.x",
+    "sinon": "~1.8.2",
+    "jQuery": "~1.7.4",
+    "grunt-contrib-qunit": "~0.4.0",
+    "qunitjs": "~1.14.0",
+    "grunt-contrib-uglify": "~0.3.2",
+    "grunt-contrib-jshint": "~0.8.0"
+  },
+  "scripts": {
+    "test": "grunt test"
+  },
+  "license": "MIT",
+  "keywords": [],
+  "readme": "onClick.js [![Build Status](https://travis-ci.org/bpeacock/onClick.png?branch=master)](https://travis-ci.org/bpeacock/onClick)\n===============\n\nA click controller for mouse & touch.\n\n- Prevents 300ms delay on touch\n- Touch interactions like scrolling work as expected\n- Handles devices that have both touch and mouse\n- Delegates events for efficiency\n\nInstallation\n------------\n\n```bash\nnpm install onclick\n```\n\nA jQuery-like selector library is required:\n- jQuery 1.4.3+\n- Zepto\n\nUsage\n-----\n\n```javascript\nonClick({\n    '#element': function(e) {\n        alert(\"I was clicked!\");\n    }\n});\n\nonClick('.myclass', function() {\n\n});\n```\n\nCheck out a live [example](http://htmlpreview.github.io/?https://github.com/bpeacock/onClick/blob/master/examples/index.html).\n\nDevelopment\n-----------\n\nTo Build:   `grunt build`\n\nTo Develop: `grunt watch`\n\nTo Test:    `npm test`\n \n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/bpeacock/onClick/issues"
+  },
+  "homepage": "https://github.com/bpeacock/onClick",
+  "_id": "onclick@0.1.0",
+  "_shasum": "00db9cf7be6a38ef1261550434e967329cfbe16c",
+  "_from": "onclick@>=0.1.0 <1.0.0-0",
+  "_resolved": "https://registry.npmjs.org/onclick/-/onclick-0.1.0.tgz"
+}
diff --git a/node_modules/onclick/src/onClick.js b/node_modules/onclick/src/onClick.js
new file mode 100644
index 000000000..f8259f760
--- /dev/null
+++ b/node_modules/onclick/src/onClick.js
@@ -0,0 +1,163 @@
+var $ = require('unopinionate').selector;
+
+var $document   = $(document),
+    bindings    = {};
+
+var click = function(events) {
+    click.bind.apply(click, arguments);
+    return click;
+};
+
+/*** Configuration Options ***/
+click.distanceLimit = 10;
+click.timeLimit     = 140;
+
+/*** Useful Properties ***/
+click.isTouch = ('ontouchstart' in window) ||
+                window.DocumentTouch &&
+                document instanceof DocumentTouch;
+
+/*** Cached Functions ***/
+var onTouchstart = function(e) {
+    e.stopPropagation(); //Prevents multiple click events from happening
+
+    click._doAnywheres(e);
+
+    var $this       = $(this),
+        startTime   = new Date().getTime(),
+        startPos    = click._getPos(e);
+
+    $this.one('touchend', function(e) {
+        e.preventDefault(); //Prevents click event from firing
+        
+        var time        = new Date().getTime() - startTime,
+            endPos      = click._getPos(e),
+            distance    = Math.sqrt(
+                Math.pow(endPos.x - startPos.x, 2) +
+                Math.pow(endPos.y - startPos.y, 2)
+            );
+
+        if(time < click.timeLimit && distance < click.distanceLimit) {
+            //Find the correct callback
+            $.each(bindings, function(selector, callback) {
+                if($this.is(selector)) {
+                    callback.apply(e.target, [e]);
+                    return false;
+                }
+            });
+        }
+    });
+};
+
+/*** API ***/
+click.bind = function(events) {
+
+    //Argument Surgery
+    if(!$.isPlainObject(events)) {
+        newEvents = {};
+        newEvents[arguments[0]] = arguments[1];
+        events = newEvents;
+    }
+
+    $.each(events, function(selector, callback) {
+
+        /*** Register Binding ***/
+        if(typeof bindings[selector] != 'undefined') {
+            click.unbind(selector); //Ensure no duplicates
+        }
+        
+        bindings[selector] = callback;
+
+        /*** Touch Support ***/
+        if(click.isTouch) {
+            $document.delegate(selector, 'touchstart', onTouchstart);
+        }
+
+        /*** Mouse Support ***/
+        $document.delegate(selector, 'click', function(e) {
+            e.stopPropagation(); //Prevents multiple click events from happening
+            //click._doAnywheres(e); //Do anywheres first to be consistent with touch order
+            callback.apply(this, [e]);
+        });
+    });
+
+    return this;
+};
+
+click.unbind = function(selector) {
+    $document
+        .undelegate(selector, 'touchstart')
+        .undelegate(selector, 'click');
+
+    delete bindings[selector];
+
+    return this;
+};
+
+click.unbindAll = function() {
+    $.each(bindings, function(selector, callback) {
+        $document
+            .undelegate(selector, 'touchstart')
+            .undelegate(selector, 'click');
+    });
+    
+    bindings = {};
+
+    return this;
+};
+
+click.trigger = function(selector, e) {
+    e = e || $.Event('click');
+
+    if(typeof bindings[selector] != 'undefined') {
+        bindings[selector](e);
+    }
+    else {
+        console.error("No click events bound for selector '"+selector+"'.");
+    }
+
+    return this;
+};
+
+click.anywhere = function(callback) {
+    click._anywheres.push(callback);
+    return this;
+};
+
+/*** Internal (but useful) Methods ***/
+click._getPos = function(e) {
+    e = e.originalEvent;
+
+    if(e.pageX || e.pageY) {
+        return {
+            x: e.pageX,
+            y: e.pageY
+        };
+    }
+    else if(e.changedTouches) {
+        return {
+            x: e.changedTouches[0].clientX,
+            y: e.changedTouches[0].clientY
+        };
+    }
+    else {
+        return {
+            x: e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft,
+            y: e.clientY + document.body.scrollTop  + document.documentElement.scrollTop
+        };
+    }
+};
+
+click._anywheres = [];
+
+click._doAnywheres = function(e) {
+    var i = click._anywheres.length;
+    while(i--) {
+        click._anywheres[i](e);
+    }
+};
+
+$(document).bind('mousedown', click._doAnywheres);
+
+module.exports = click;
+
diff --git a/node_modules/onclick/test/build.js b/node_modules/onclick/test/build.js
new file mode 100644
index 000000000..7e4542568
--- /dev/null
+++ b/node_modules/onclick/test/build.js
@@ -0,0 +1,4835 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+},{}],2:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+    var canSetImmediate = typeof window !== 'undefined'
+    && window.setImmediate;
+    var canPost = typeof window !== 'undefined'
+    && window.postMessage && window.addEventListener
+    ;
+
+    if (canSetImmediate) {
+        return function (f) { return window.setImmediate(f) };
+    }
+
+    if (canPost) {
+        var queue = [];
+        window.addEventListener('message', function (ev) {
+            var source = ev.source;
+            if ((source === window || source === null) && ev.data === 'process-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+
+        return function nextTick(fn) {
+            queue.push(fn);
+            window.postMessage('process-tick', '*');
+        };
+    }
+
+    return function nextTick(fn) {
+        setTimeout(fn, 0);
+    };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+
+},{}],3:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+},{}],4:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(global.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require("/Users/brianpeacock/apps/on3/onClick/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":3,"/Users/brianpeacock/apps/on3/onClick/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":2,"inherits":1}],5:[function(require,module,exports){
+/*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
+/*global module, require, __dirname, document*/
+/**
+ * Sinon core utilities. For internal use only.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+var sinon = (function (formatio) {
+    var div = typeof document != "undefined" && document.createElement("div");
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    function isDOMNode(obj) {
+        var success = false;
+
+        try {
+            obj.appendChild(div);
+            success = div.parentNode == obj;
+        } catch (e) {
+            return false;
+        } finally {
+            try {
+                obj.removeChild(div);
+            } catch (e) {
+                // Remove failed, not much we can do about that
+            }
+        }
+
+        return success;
+    }
+
+    function isElement(obj) {
+        return div && obj && obj.nodeType === 1 && isDOMNode(obj);
+    }
+
+    function isFunction(obj) {
+        return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+
+    function mirrorProperties(target, source) {
+        for (var prop in source) {
+            if (!hasOwn.call(target, prop)) {
+                target[prop] = source[prop];
+            }
+        }
+    }
+
+    function isRestorable (obj) {
+        return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
+    }
+
+    var sinon = {
+        wrapMethod: function wrapMethod(object, property, method) {
+            if (!object) {
+                throw new TypeError("Should wrap property of object");
+            }
+
+            if (typeof method != "function") {
+                throw new TypeError("Method wrapper should be function");
+            }
+
+            var wrappedMethod = object[property],
+                error;
+
+            if (!isFunction(wrappedMethod)) {
+                error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
+                                    property + " as function");
+            }
+
+            if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
+                error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
+            }
+
+            if (wrappedMethod.calledBefore) {
+                var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
+                error = new TypeError("Attempted to wrap " + property + " which is already " + verb);
+            }
+
+            if (error) {
+                if (wrappedMethod._stack) {
+                    error.stack += '\n--------------\n' + wrappedMethod._stack;
+                }
+                throw error;
+            }
+
+            // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem
+            // when using hasOwn.call on objects from other frames.
+            var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);
+            object[property] = method;
+            method.displayName = property;
+            // Set up a stack trace which can be used later to find what line of
+            // code the original method was created on.
+            method._stack = (new Error('Stack Trace for original')).stack;
+
+            method.restore = function () {
+                // For prototype properties try to reset by delete first.
+                // If this fails (ex: localStorage on mobile safari) then force a reset
+                // via direct assignment.
+                if (!owned) {
+                    delete object[property];
+                }
+                if (object[property] === method) {
+                    object[property] = wrappedMethod;
+                }
+            };
+
+            method.restore.sinon = true;
+            mirrorProperties(method, wrappedMethod);
+
+            return method;
+        },
+
+        extend: function extend(target) {
+            for (var i = 1, l = arguments.length; i < l; i += 1) {
+                for (var prop in arguments[i]) {
+                    if (arguments[i].hasOwnProperty(prop)) {
+                        target[prop] = arguments[i][prop];
+                    }
+
+                    // DONT ENUM bug, only care about toString
+                    if (arguments[i].hasOwnProperty("toString") &&
+                        arguments[i].toString != target.toString) {
+                        target.toString = arguments[i].toString;
+                    }
+                }
+            }
+
+            return target;
+        },
+
+        create: function create(proto) {
+            var F = function () {};
+            F.prototype = proto;
+            return new F();
+        },
+
+        deepEqual: function deepEqual(a, b) {
+            if (sinon.match && sinon.match.isMatcher(a)) {
+                return a.test(b);
+            }
+            if (typeof a != "object" || typeof b != "object") {
+                return a === b;
+            }
+
+            if (isElement(a) || isElement(b)) {
+                return a === b;
+            }
+
+            if (a === b) {
+                return true;
+            }
+
+            if ((a === null && b !== null) || (a !== null && b === null)) {
+                return false;
+            }
+
+            var aString = Object.prototype.toString.call(a);
+            if (aString != Object.prototype.toString.call(b)) {
+                return false;
+            }
+
+            if (aString == "[object Date]") {
+                return a.valueOf() === b.valueOf();
+            }
+
+            var prop, aLength = 0, bLength = 0;
+
+            if (aString == "[object Array]" && a.length !== b.length) {
+                return false;
+            }
+
+            for (prop in a) {
+                aLength += 1;
+
+                if (!deepEqual(a[prop], b[prop])) {
+                    return false;
+                }
+            }
+
+            for (prop in b) {
+                bLength += 1;
+            }
+
+            return aLength == bLength;
+        },
+
+        functionName: function functionName(func) {
+            var name = func.displayName || func.name;
+
+            // Use function decomposition as a last resort to get function
+            // name. Does not rely on function decomposition to work - if it
+            // doesn't debugging will be slightly less informative
+            // (i.e. toString will say 'spy' rather than 'myFunc').
+            if (!name) {
+                var matches = func.toString().match(/function ([^\s\(]+)/);
+                name = matches && matches[1];
+            }
+
+            return name;
+        },
+
+        functionToString: function toString() {
+            if (this.getCall && this.callCount) {
+                var thisValue, prop, i = this.callCount;
+
+                while (i--) {
+                    thisValue = this.getCall(i).thisValue;
+
+                    for (prop in thisValue) {
+                        if (thisValue[prop] === this) {
+                            return prop;
+                        }
+                    }
+                }
+            }
+
+            return this.displayName || "sinon fake";
+        },
+
+        getConfig: function (custom) {
+            var config = {};
+            custom = custom || {};
+            var defaults = sinon.defaultConfig;
+
+            for (var prop in defaults) {
+                if (defaults.hasOwnProperty(prop)) {
+                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
+                }
+            }
+
+            return config;
+        },
+
+        format: function (val) {
+            return "" + val;
+        },
+
+        defaultConfig: {
+            injectIntoThis: true,
+            injectInto: null,
+            properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+            useFakeTimers: true,
+            useFakeServer: true
+        },
+
+        timesInWords: function timesInWords(count) {
+            return count == 1 && "once" ||
+                count == 2 && "twice" ||
+                count == 3 && "thrice" ||
+                (count || 0) + " times";
+        },
+
+        calledInOrder: function (spies) {
+            for (var i = 1, l = spies.length; i < l; i++) {
+                if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
+                    return false;
+                }
+            }
+
+            return true;
+        },
+
+        orderByFirstCall: function (spies) {
+            return spies.sort(function (a, b) {
+                // uuid, won't ever be equal
+                var aCall = a.getCall(0);
+                var bCall = b.getCall(0);
+                var aId = aCall && aCall.callId || -1;
+                var bId = bCall && bCall.callId || -1;
+
+                return aId < bId ? -1 : 1;
+            });
+        },
+
+        log: function () {},
+
+        logError: function (label, err) {
+            var msg = label + " threw exception: ";
+            sinon.log(msg + "[" + err.name + "] " + err.message);
+            if (err.stack) { sinon.log(err.stack); }
+
+            setTimeout(function () {
+                err.message = msg + err.message;
+                throw err;
+            }, 0);
+        },
+
+        typeOf: function (value) {
+            if (value === null) {
+                return "null";
+            }
+            else if (value === undefined) {
+                return "undefined";
+            }
+            var string = Object.prototype.toString.call(value);
+            return string.substring(8, string.length - 1).toLowerCase();
+        },
+
+        createStubInstance: function (constructor) {
+            if (typeof constructor !== "function") {
+                throw new TypeError("The constructor should be a function.");
+            }
+            return sinon.stub(sinon.create(constructor.prototype));
+        },
+
+        restore: function (object) {
+            if (object !== null && typeof object === "object") {
+                for (var prop in object) {
+                    if (isRestorable(object[prop])) {
+                        object[prop].restore();
+                    }
+                }
+            }
+            else if (isRestorable(object)) {
+                object.restore();
+            }
+        }
+    };
+
+    var isNode = typeof module !== "undefined" && module.exports;
+    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd;
+
+    if (isAMD) {
+        define(function(){
+            return sinon;
+        });
+    } else if (isNode) {
+        try {
+            formatio = require("formatio");
+        } catch (e) {}
+        module.exports = sinon;
+        module.exports.spy = require("./sinon/spy");
+        module.exports.spyCall = require("./sinon/call");
+        module.exports.behavior = require("./sinon/behavior");
+        module.exports.stub = require("./sinon/stub");
+        module.exports.mock = require("./sinon/mock");
+        module.exports.collection = require("./sinon/collection");
+        module.exports.assert = require("./sinon/assert");
+        module.exports.sandbox = require("./sinon/sandbox");
+        module.exports.test = require("./sinon/test");
+        module.exports.testCase = require("./sinon/test_case");
+        module.exports.assert = require("./sinon/assert");
+        module.exports.match = require("./sinon/match");
+    }
+
+    if (formatio) {
+        var formatter = formatio.configure({ quoteStrings: false });
+        sinon.format = function () {
+            return formatter.ascii.apply(formatter, arguments);
+        };
+    } else if (isNode) {
+        try {
+            var util = require("util");
+            sinon.format = function (value) {
+                return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
+            };
+        } catch (e) {
+            /* Node, but no util module - would be very old, but better safe than
+             sorry */
+        }
+    }
+
+    return sinon;
+}(typeof formatio == "object" && formatio));
+
+},{"./sinon/assert":6,"./sinon/behavior":7,"./sinon/call":8,"./sinon/collection":9,"./sinon/match":10,"./sinon/mock":11,"./sinon/sandbox":12,"./sinon/spy":13,"./sinon/stub":14,"./sinon/test":15,"./sinon/test_case":16,"formatio":18,"util":4}],6:[function(require,module,exports){
+(function (global){
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Assertions matching the test spy retrieval interface.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon, global) {
+    var commonJSModule = typeof module !== "undefined" && module.exports;
+    var slice = Array.prototype.slice;
+    var assert;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function verifyIsStub() {
+        var method;
+
+        for (var i = 0, l = arguments.length; i < l; ++i) {
+            method = arguments[i];
+
+            if (!method) {
+                assert.fail("fake is not a spy");
+            }
+
+            if (typeof method != "function") {
+                assert.fail(method + " is not a function");
+            }
+
+            if (typeof method.getCall != "function") {
+                assert.fail(method + " is not stubbed");
+            }
+        }
+    }
+
+    function failAssertion(object, msg) {
+        object = object || global;
+        var failMethod = object.fail || assert.fail;
+        failMethod.call(object, msg);
+    }
+
+    function mirrorPropAsAssertion(name, method, message) {
+        if (arguments.length == 2) {
+            message = method;
+            method = name;
+        }
+
+        assert[name] = function (fake) {
+            verifyIsStub(fake);
+
+            var args = slice.call(arguments, 1);
+            var failed = false;
+
+            if (typeof method == "function") {
+                failed = !method(fake);
+            } else {
+                failed = typeof fake[method] == "function" ?
+                    !fake[method].apply(fake, args) : !fake[method];
+            }
+
+            if (failed) {
+                failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
+            } else {
+                assert.pass(name);
+            }
+        };
+    }
+
+    function exposedName(prefix, prop) {
+        return !prefix || /^fail/.test(prop) ? prop :
+            prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
+    }
+
+    assert = {
+        failException: "AssertError",
+
+        fail: function fail(message) {
+            var error = new Error(message);
+            error.name = this.failException || assert.failException;
+
+            throw error;
+        },
+
+        pass: function pass(assertion) {},
+
+        callOrder: function assertCallOrder() {
+            verifyIsStub.apply(null, arguments);
+            var expected = "", actual = "";
+
+            if (!sinon.calledInOrder(arguments)) {
+                try {
+                    expected = [].join.call(arguments, ", ");
+                    var calls = slice.call(arguments);
+                    var i = calls.length;
+                    while (i) {
+                        if (!calls[--i].called) {
+                            calls.splice(i, 1);
+                        }
+                    }
+                    actual = sinon.orderByFirstCall(calls).join(", ");
+                } catch (e) {
+                    // If this fails, we'll just fall back to the blank string
+                }
+
+                failAssertion(this, "expected " + expected + " to be " +
+                              "called in order but were called as " + actual);
+            } else {
+                assert.pass("callOrder");
+            }
+        },
+
+        callCount: function assertCallCount(method, count) {
+            verifyIsStub(method);
+
+            if (method.callCount != count) {
+                var msg = "expected %n to be called " + sinon.timesInWords(count) +
+                    " but was called %c%C";
+                failAssertion(this, method.printf(msg));
+            } else {
+                assert.pass("callCount");
+            }
+        },
+
+        expose: function expose(target, options) {
+            if (!target) {
+                throw new TypeError("target is null or undefined");
+            }
+
+            var o = options || {};
+            var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
+            var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
+
+            for (var method in this) {
+                if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
+                    target[exposedName(prefix, method)] = this[method];
+                }
+            }
+
+            return target;
+        }
+    };
+
+    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
+    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
+                          "expected %n to not have been called but was called %c%C");
+    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
+    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
+    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
+    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
+    mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
+    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
+    mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
+    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
+    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
+    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
+    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
+
+    if (commonJSModule) {
+        module.exports = assert;
+    } else {
+        sinon.assert = assert;
+    }
+}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../sinon":5}],7:[function(require,module,exports){
+(function (process){
+/**
+ * @depend ../sinon.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global module, require, sinon, process, setImmediate, setTimeout*/
+/**
+ * Stub behavior
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @author Tim Fischbach (mail@timfischbach.de)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    var slice = Array.prototype.slice;
+    var join = Array.prototype.join;
+    var proto;
+
+    var nextTick = (function () {
+        if (typeof process === "object" && typeof process.nextTick === "function") {
+            return process.nextTick;
+        } else if (typeof setImmediate === "function") {
+            return setImmediate;
+        } else {
+            return function (callback) {
+                setTimeout(callback, 0);
+            };
+        }
+    })();
+
+    function throwsException(error, message) {
+        if (typeof error == "string") {
+            this.exception = new Error(message || "");
+            this.exception.name = error;
+        } else if (!error) {
+            this.exception = new Error("Error");
+        } else {
+            this.exception = error;
+        }
+
+        return this;
+    }
+
+    function getCallback(behavior, args) {
+        var callArgAt = behavior.callArgAt;
+
+        if (callArgAt < 0) {
+            var callArgProp = behavior.callArgProp;
+
+            for (var i = 0, l = args.length; i < l; ++i) {
+                if (!callArgProp && typeof args[i] == "function") {
+                    return args[i];
+                }
+
+                if (callArgProp && args[i] &&
+                    typeof args[i][callArgProp] == "function") {
+                    return args[i][callArgProp];
+                }
+            }
+
+            return null;
+        }
+
+        return args[callArgAt];
+    }
+
+    function getCallbackError(behavior, func, args) {
+        if (behavior.callArgAt < 0) {
+            var msg;
+
+            if (behavior.callArgProp) {
+                msg = sinon.functionName(behavior.stub) +
+                    " expected to yield to '" + behavior.callArgProp +
+                    "', but no object with such a property was passed.";
+            } else {
+                msg = sinon.functionName(behavior.stub) +
+                    " expected to yield, but no callback was passed.";
+            }
+
+            if (args.length > 0) {
+                msg += " Received [" + join.call(args, ", ") + "]";
+            }
+
+            return msg;
+        }
+
+        return "argument at index " + behavior.callArgAt + " is not a function: " + func;
+    }
+
+    function callCallback(behavior, args) {
+        if (typeof behavior.callArgAt == "number") {
+            var func = getCallback(behavior, args);
+
+            if (typeof func != "function") {
+                throw new TypeError(getCallbackError(behavior, func, args));
+            }
+
+            if (behavior.callbackAsync) {
+                nextTick(function() {
+                    func.apply(behavior.callbackContext, behavior.callbackArguments);
+                });
+            } else {
+                func.apply(behavior.callbackContext, behavior.callbackArguments);
+            }
+        }
+    }
+
+    proto = {
+        create: function(stub) {
+            var behavior = sinon.extend({}, sinon.behavior);
+            delete behavior.create;
+            behavior.stub = stub;
+
+            return behavior;
+        },
+
+        isPresent: function() {
+            return (typeof this.callArgAt == 'number' ||
+                    this.exception ||
+                    typeof this.returnArgAt == 'number' ||
+                    this.returnThis ||
+                    this.returnValueDefined);
+        },
+
+        invoke: function(context, args) {
+            callCallback(this, args);
+
+            if (this.exception) {
+                throw this.exception;
+            } else if (typeof this.returnArgAt == 'number') {
+                return args[this.returnArgAt];
+            } else if (this.returnThis) {
+                return context;
+            }
+
+            return this.returnValue;
+        },
+
+        onCall: function(index) {
+            return this.stub.onCall(index);
+        },
+
+        onFirstCall: function() {
+            return this.stub.onFirstCall();
+        },
+
+        onSecondCall: function() {
+            return this.stub.onSecondCall();
+        },
+
+        onThirdCall: function() {
+            return this.stub.onThirdCall();
+        },
+
+        withArgs: function(/* arguments */) {
+            throw new Error('Defining a stub by invoking "stub.onCall(...).withArgs(...)" is not supported. ' +
+                            'Use "stub.withArgs(...).onCall(...)" to define sequential behavior for calls with certain arguments.');
+        },
+
+        callsArg: function callsArg(pos) {
+            if (typeof pos != "number") {
+                throw new TypeError("argument index is not number");
+            }
+
+            this.callArgAt = pos;
+            this.callbackArguments = [];
+            this.callbackContext = undefined;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        callsArgOn: function callsArgOn(pos, context) {
+            if (typeof pos != "number") {
+                throw new TypeError("argument index is not number");
+            }
+            if (typeof context != "object") {
+                throw new TypeError("argument context is not an object");
+            }
+
+            this.callArgAt = pos;
+            this.callbackArguments = [];
+            this.callbackContext = context;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        callsArgWith: function callsArgWith(pos) {
+            if (typeof pos != "number") {
+                throw new TypeError("argument index is not number");
+            }
+
+            this.callArgAt = pos;
+            this.callbackArguments = slice.call(arguments, 1);
+            this.callbackContext = undefined;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        callsArgOnWith: function callsArgWith(pos, context) {
+            if (typeof pos != "number") {
+                throw new TypeError("argument index is not number");
+            }
+            if (typeof context != "object") {
+                throw new TypeError("argument context is not an object");
+            }
+
+            this.callArgAt = pos;
+            this.callbackArguments = slice.call(arguments, 2);
+            this.callbackContext = context;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        yields: function () {
+            this.callArgAt = -1;
+            this.callbackArguments = slice.call(arguments, 0);
+            this.callbackContext = undefined;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        yieldsOn: function (context) {
+            if (typeof context != "object") {
+                throw new TypeError("argument context is not an object");
+            }
+
+            this.callArgAt = -1;
+            this.callbackArguments = slice.call(arguments, 1);
+            this.callbackContext = context;
+            this.callArgProp = undefined;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        yieldsTo: function (prop) {
+            this.callArgAt = -1;
+            this.callbackArguments = slice.call(arguments, 1);
+            this.callbackContext = undefined;
+            this.callArgProp = prop;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+        yieldsToOn: function (prop, context) {
+            if (typeof context != "object") {
+                throw new TypeError("argument context is not an object");
+            }
+
+            this.callArgAt = -1;
+            this.callbackArguments = slice.call(arguments, 2);
+            this.callbackContext = context;
+            this.callArgProp = prop;
+            this.callbackAsync = false;
+
+            return this;
+        },
+
+
+        "throws": throwsException,
+        throwsException: throwsException,
+
+        returns: function returns(value) {
+            this.returnValue = value;
+            this.returnValueDefined = true;
+
+            return this;
+        },
+
+        returnsArg: function returnsArg(pos) {
+            if (typeof pos != "number") {
+                throw new TypeError("argument index is not number");
+            }
+
+            this.returnArgAt = pos;
+
+            return this;
+        },
+
+        returnsThis: function returnsThis() {
+            this.returnThis = true;
+
+            return this;
+        }
+    };
+
+    // create asynchronous versions of callsArg* and yields* methods
+    for (var method in proto) {
+        // need to avoid creating anotherasync versions of the newly added async methods
+        if (proto.hasOwnProperty(method) &&
+            method.match(/^(callsArg|yields)/) &&
+            !method.match(/Async/)) {
+            proto[method + 'Async'] = (function (syncFnName) {
+                return function () {
+                    var result = this[syncFnName].apply(this, arguments);
+                    this.callbackAsync = true;
+                    return result;
+                };
+            })(method);
+        }
+    }
+
+    if (commonJSModule) {
+        module.exports = proto;
+    } else {
+        sinon.behavior = proto;
+    }
+}(typeof sinon == "object" && sinon || null));
+}).call(this,require("/Users/brianpeacock/apps/on3/onClick/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"../sinon":5,"/Users/brianpeacock/apps/on3/onClick/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":2}],8:[function(require,module,exports){
+/**
+  * @depend ../sinon.js
+  * @depend match.js
+  */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+  * Spy calls
+  *
+  * @author Christian Johansen (christian@cjohansen.no)
+  * @author Maximilian Antoni (mail@maxantoni.de)
+  * @license BSD
+  *
+  * Copyright (c) 2010-2013 Christian Johansen
+  * Copyright (c) 2013 Maximilian Antoni
+  */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function throwYieldError(proxy, text, args) {
+        var msg = sinon.functionName(proxy) + text;
+        if (args.length) {
+            msg += " Received [" + slice.call(args).join(", ") + "]";
+        }
+        throw new Error(msg);
+    }
+
+    var slice = Array.prototype.slice;
+
+    var callProto = {
+        calledOn: function calledOn(thisValue) {
+            if (sinon.match && sinon.match.isMatcher(thisValue)) {
+                return thisValue.test(this.thisValue);
+            }
+            return this.thisValue === thisValue;
+        },
+
+        calledWith: function calledWith() {
+            for (var i = 0, l = arguments.length; i < l; i += 1) {
+                if (!sinon.deepEqual(arguments[i], this.args[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        },
+
+        calledWithMatch: function calledWithMatch() {
+            for (var i = 0, l = arguments.length; i < l; i += 1) {
+                var actual = this.args[i];
+                var expectation = arguments[i];
+                if (!sinon.match || !sinon.match(expectation).test(actual)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+
+        calledWithExactly: function calledWithExactly() {
+            return arguments.length == this.args.length &&
+                this.calledWith.apply(this, arguments);
+        },
+
+        notCalledWith: function notCalledWith() {
+            return !this.calledWith.apply(this, arguments);
+        },
+
+        notCalledWithMatch: function notCalledWithMatch() {
+            return !this.calledWithMatch.apply(this, arguments);
+        },
+
+        returned: function returned(value) {
+            return sinon.deepEqual(value, this.returnValue);
+        },
+
+        threw: function threw(error) {
+            if (typeof error === "undefined" || !this.exception) {
+                return !!this.exception;
+            }
+
+            return this.exception === error || this.exception.name === error;
+        },
+
+        calledWithNew: function calledWithNew() {
+            return this.proxy.prototype && this.thisValue instanceof this.proxy;
+        },
+
+        calledBefore: function (other) {
+            return this.callId < other.callId;
+        },
+
+        calledAfter: function (other) {
+            return this.callId > other.callId;
+        },
+
+        callArg: function (pos) {
+            this.args[pos]();
+        },
+
+        callArgOn: function (pos, thisValue) {
+            this.args[pos].apply(thisValue);
+        },
+
+        callArgWith: function (pos) {
+            this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
+        },
+
+        callArgOnWith: function (pos, thisValue) {
+            var args = slice.call(arguments, 2);
+            this.args[pos].apply(thisValue, args);
+        },
+
+        "yield": function () {
+            this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
+        },
+
+        yieldOn: function (thisValue) {
+            var args = this.args;
+            for (var i = 0, l = args.length; i < l; ++i) {
+                if (typeof args[i] === "function") {
+                    args[i].apply(thisValue, slice.call(arguments, 1));
+                    return;
+                }
+            }
+            throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
+        },
+
+        yieldTo: function (prop) {
+            this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
+        },
+
+        yieldToOn: function (prop, thisValue) {
+            var args = this.args;
+            for (var i = 0, l = args.length; i < l; ++i) {
+                if (args[i] && typeof args[i][prop] === "function") {
+                    args[i][prop].apply(thisValue, slice.call(arguments, 2));
+                    return;
+                }
+            }
+            throwYieldError(this.proxy, " cannot yield to '" + prop +
+                "' since no callback was passed.", args);
+        },
+
+        toString: function () {
+            var callStr = this.proxy.toString() + "(";
+            var args = [];
+
+            for (var i = 0, l = this.args.length; i < l; ++i) {
+                args.push(sinon.format(this.args[i]));
+            }
+
+            callStr = callStr + args.join(", ") + ")";
+
+            if (typeof this.returnValue != "undefined") {
+                callStr += " => " + sinon.format(this.returnValue);
+            }
+
+            if (this.exception) {
+                callStr += " !" + this.exception.name;
+
+                if (this.exception.message) {
+                    callStr += "(" + this.exception.message + ")";
+                }
+            }
+
+            return callStr;
+        }
+    };
+
+    callProto.invokeCallback = callProto.yield;
+
+    function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
+        if (typeof id !== "number") {
+            throw new TypeError("Call id is not a number");
+        }
+        var proxyCall = sinon.create(callProto);
+        proxyCall.proxy = spy;
+        proxyCall.thisValue = thisValue;
+        proxyCall.args = args;
+        proxyCall.returnValue = returnValue;
+        proxyCall.exception = exception;
+        proxyCall.callId = id;
+
+        return proxyCall;
+    }
+    createSpyCall.toString = callProto.toString; // used by mocks
+
+    if (commonJSModule) {
+        module.exports = createSpyCall;
+    } else {
+        sinon.spyCall = createSpyCall;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+
+},{"../sinon":5}],9:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true*/
+/*global module, require, sinon*/
+/**
+ * Collections of stubs, spies and mocks.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+    var push = [].push;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function getFakes(fakeCollection) {
+        if (!fakeCollection.fakes) {
+            fakeCollection.fakes = [];
+        }
+
+        return fakeCollection.fakes;
+    }
+
+    function each(fakeCollection, method) {
+        var fakes = getFakes(fakeCollection);
+
+        for (var i = 0, l = fakes.length; i < l; i += 1) {
+            if (typeof fakes[i][method] == "function") {
+                fakes[i][method]();
+            }
+        }
+    }
+
+    function compact(fakeCollection) {
+        var fakes = getFakes(fakeCollection);
+        var i = 0;
+        while (i < fakes.length) {
+          fakes.splice(i, 1);
+        }
+    }
+
+    var collection = {
+        verify: function resolve() {
+            each(this, "verify");
+        },
+
+        restore: function restore() {
+            each(this, "restore");
+            compact(this);
+        },
+
+        verifyAndRestore: function verifyAndRestore() {
+            var exception;
+
+            try {
+                this.verify();
+            } catch (e) {
+                exception = e;
+            }
+
+            this.restore();
+
+            if (exception) {
+                throw exception;
+            }
+        },
+
+        add: function add(fake) {
+            push.call(getFakes(this), fake);
+            return fake;
+        },
+
+        spy: function spy() {
+            return this.add(sinon.spy.apply(sinon, arguments));
+        },
+
+        stub: function stub(object, property, value) {
+            if (property) {
+                var original = object[property];
+
+                if (typeof original != "function") {
+                    if (!hasOwnProperty.call(object, property)) {
+                        throw new TypeError("Cannot stub non-existent own property " + property);
+                    }
+
+                    object[property] = value;
+
+                    return this.add({
+                        restore: function () {
+                            object[property] = original;
+                        }
+                    });
+                }
+            }
+            if (!property && !!object && typeof object == "object") {
+                var stubbedObj = sinon.stub.apply(sinon, arguments);
+
+                for (var prop in stubbedObj) {
+                    if (typeof stubbedObj[prop] === "function") {
+                        this.add(stubbedObj[prop]);
+                    }
+                }
+
+                return stubbedObj;
+            }
+
+            return this.add(sinon.stub.apply(sinon, arguments));
+        },
+
+        mock: function mock() {
+            return this.add(sinon.mock.apply(sinon, arguments));
+        },
+
+        inject: function inject(obj) {
+            var col = this;
+
+            obj.spy = function () {
+                return col.spy.apply(col, arguments);
+            };
+
+            obj.stub = function () {
+                return col.stub.apply(col, arguments);
+            };
+
+            obj.mock = function () {
+                return col.mock.apply(col, arguments);
+            };
+
+            return obj;
+        }
+    };
+
+    if (commonJSModule) {
+        module.exports = collection;
+    } else {
+        sinon.collection = collection;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],10:[function(require,module,exports){
+/* @depend ../sinon.js */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Match functions
+ *
+ * @author Maximilian Antoni (mail@maxantoni.de)
+ * @license BSD
+ *
+ * Copyright (c) 2012 Maximilian Antoni
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function assertType(value, type, name) {
+        var actual = sinon.typeOf(value);
+        if (actual !== type) {
+            throw new TypeError("Expected type of " + name + " to be " +
+                type + ", but was " + actual);
+        }
+    }
+
+    var matcher = {
+        toString: function () {
+            return this.message;
+        }
+    };
+
+    function isMatcher(object) {
+        return matcher.isPrototypeOf(object);
+    }
+
+    function matchObject(expectation, actual) {
+        if (actual === null || actual === undefined) {
+            return false;
+        }
+        for (var key in expectation) {
+            if (expectation.hasOwnProperty(key)) {
+                var exp = expectation[key];
+                var act = actual[key];
+                if (match.isMatcher(exp)) {
+                    if (!exp.test(act)) {
+                        return false;
+                    }
+                } else if (sinon.typeOf(exp) === "object") {
+                    if (!matchObject(exp, act)) {
+                        return false;
+                    }
+                } else if (!sinon.deepEqual(exp, act)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    matcher.or = function (m2) {
+        if (!isMatcher(m2)) {
+            throw new TypeError("Matcher expected");
+        }
+        var m1 = this;
+        var or = sinon.create(matcher);
+        or.test = function (actual) {
+            return m1.test(actual) || m2.test(actual);
+        };
+        or.message = m1.message + ".or(" + m2.message + ")";
+        return or;
+    };
+
+    matcher.and = function (m2) {
+        if (!isMatcher(m2)) {
+            throw new TypeError("Matcher expected");
+        }
+        var m1 = this;
+        var and = sinon.create(matcher);
+        and.test = function (actual) {
+            return m1.test(actual) && m2.test(actual);
+        };
+        and.message = m1.message + ".and(" + m2.message + ")";
+        return and;
+    };
+
+    var match = function (expectation, message) {
+        var m = sinon.create(matcher);
+        var type = sinon.typeOf(expectation);
+        switch (type) {
+        case "object":
+            if (typeof expectation.test === "function") {
+                m.test = function (actual) {
+                    return expectation.test(actual) === true;
+                };
+                m.message = "match(" + sinon.functionName(expectation.test) + ")";
+                return m;
+            }
+            var str = [];
+            for (var key in expectation) {
+                if (expectation.hasOwnProperty(key)) {
+                    str.push(key + ": " + expectation[key]);
+                }
+            }
+            m.test = function (actual) {
+                return matchObject(expectation, actual);
+            };
+            m.message = "match(" + str.join(", ") + ")";
+            break;
+        case "number":
+            m.test = function (actual) {
+                return expectation == actual;
+            };
+            break;
+        case "string":
+            m.test = function (actual) {
+                if (typeof actual !== "string") {
+                    return false;
+                }
+                return actual.indexOf(expectation) !== -1;
+            };
+            m.message = "match(\"" + expectation + "\")";
+            break;
+        case "regexp":
+            m.test = function (actual) {
+                if (typeof actual !== "string") {
+                    return false;
+                }
+                return expectation.test(actual);
+            };
+            break;
+        case "function":
+            m.test = expectation;
+            if (message) {
+                m.message = message;
+            } else {
+                m.message = "match(" + sinon.functionName(expectation) + ")";
+            }
+            break;
+        default:
+            m.test = function (actual) {
+              return sinon.deepEqual(expectation, actual);
+            };
+        }
+        if (!m.message) {
+            m.message = "match(" + expectation + ")";
+        }
+        return m;
+    };
+
+    match.isMatcher = isMatcher;
+
+    match.any = match(function () {
+        return true;
+    }, "any");
+
+    match.defined = match(function (actual) {
+        return actual !== null && actual !== undefined;
+    }, "defined");
+
+    match.truthy = match(function (actual) {
+        return !!actual;
+    }, "truthy");
+
+    match.falsy = match(function (actual) {
+        return !actual;
+    }, "falsy");
+
+    match.same = function (expectation) {
+        return match(function (actual) {
+            return expectation === actual;
+        }, "same(" + expectation + ")");
+    };
+
+    match.typeOf = function (type) {
+        assertType(type, "string", "type");
+        return match(function (actual) {
+            return sinon.typeOf(actual) === type;
+        }, "typeOf(\"" + type + "\")");
+    };
+
+    match.instanceOf = function (type) {
+        assertType(type, "function", "type");
+        return match(function (actual) {
+            return actual instanceof type;
+        }, "instanceOf(" + sinon.functionName(type) + ")");
+    };
+
+    function createPropertyMatcher(propertyTest, messagePrefix) {
+        return function (property, value) {
+            assertType(property, "string", "property");
+            var onlyProperty = arguments.length === 1;
+            var message = messagePrefix + "(\"" + property + "\"";
+            if (!onlyProperty) {
+                message += ", " + value;
+            }
+            message += ")";
+            return match(function (actual) {
+                if (actual === undefined || actual === null ||
+                        !propertyTest(actual, property)) {
+                    return false;
+                }
+                return onlyProperty || sinon.deepEqual(value, actual[property]);
+            }, message);
+        };
+    }
+
+    match.has = createPropertyMatcher(function (actual, property) {
+        if (typeof actual === "object") {
+            return property in actual;
+        }
+        return actual[property] !== undefined;
+    }, "has");
+
+    match.hasOwn = createPropertyMatcher(function (actual, property) {
+        return actual.hasOwnProperty(property);
+    }, "hasOwn");
+
+    match.bool = match.typeOf("boolean");
+    match.number = match.typeOf("number");
+    match.string = match.typeOf("string");
+    match.object = match.typeOf("object");
+    match.func = match.typeOf("function");
+    match.array = match.typeOf("array");
+    match.regexp = match.typeOf("regexp");
+    match.date = match.typeOf("date");
+
+    if (commonJSModule) {
+        module.exports = match;
+    } else {
+        sinon.match = match;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],11:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false*/
+/*global module, require, sinon*/
+/**
+ * Mock functions.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+    var push = [].push;
+    var match;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    match = sinon.match;
+
+    if (!match && commonJSModule) {
+        match = require("./match");
+    }
+
+    function mock(object) {
+        if (!object) {
+            return sinon.expectation.create("Anonymous mock");
+        }
+
+        return mock.create(object);
+    }
+
+    sinon.mock = mock;
+
+    sinon.extend(mock, (function () {
+        function each(collection, callback) {
+            if (!collection) {
+                return;
+            }
+
+            for (var i = 0, l = collection.length; i < l; i += 1) {
+                callback(collection[i]);
+            }
+        }
+
+        return {
+            create: function create(object) {
+                if (!object) {
+                    throw new TypeError("object is null");
+                }
+
+                var mockObject = sinon.extend({}, mock);
+                mockObject.object = object;
+                delete mockObject.create;
+
+                return mockObject;
+            },
+
+            expects: function expects(method) {
+                if (!method) {
+                    throw new TypeError("method is falsy");
+                }
+
+                if (!this.expectations) {
+                    this.expectations = {};
+                    this.proxies = [];
+                }
+
+                if (!this.expectations[method]) {
+                    this.expectations[method] = [];
+                    var mockObject = this;
+
+                    sinon.wrapMethod(this.object, method, function () {
+                        return mockObject.invokeMethod(method, this, arguments);
+                    });
+
+                    push.call(this.proxies, method);
+                }
+
+                var expectation = sinon.expectation.create(method);
+                push.call(this.expectations[method], expectation);
+
+                return expectation;
+            },
+
+            restore: function restore() {
+                var object = this.object;
+
+                each(this.proxies, function (proxy) {
+                    if (typeof object[proxy].restore == "function") {
+                        object[proxy].restore();
+                    }
+                });
+            },
+
+            verify: function verify() {
+                var expectations = this.expectations || {};
+                var messages = [], met = [];
+
+                each(this.proxies, function (proxy) {
+                    each(expectations[proxy], function (expectation) {
+                        if (!expectation.met()) {
+                            push.call(messages, expectation.toString());
+                        } else {
+                            push.call(met, expectation.toString());
+                        }
+                    });
+                });
+
+                this.restore();
+
+                if (messages.length > 0) {
+                    sinon.expectation.fail(messages.concat(met).join("\n"));
+                } else {
+                    sinon.expectation.pass(messages.concat(met).join("\n"));
+                }
+
+                return true;
+            },
+
+            invokeMethod: function invokeMethod(method, thisValue, args) {
+                var expectations = this.expectations && this.expectations[method];
+                var length = expectations && expectations.length || 0, i;
+
+                for (i = 0; i < length; i += 1) {
+                    if (!expectations[i].met() &&
+                        expectations[i].allowsCall(thisValue, args)) {
+                        return expectations[i].apply(thisValue, args);
+                    }
+                }
+
+                var messages = [], available, exhausted = 0;
+
+                for (i = 0; i < length; i += 1) {
+                    if (expectations[i].allowsCall(thisValue, args)) {
+                        available = available || expectations[i];
+                    } else {
+                        exhausted += 1;
+                    }
+                    push.call(messages, "    " + expectations[i].toString());
+                }
+
+                if (exhausted === 0) {
+                    return available.apply(thisValue, args);
+                }
+
+                messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
+                    proxy: method,
+                    args: args
+                }));
+
+                sinon.expectation.fail(messages.join("\n"));
+            }
+        };
+    }()));
+
+    var times = sinon.timesInWords;
+
+    sinon.expectation = (function () {
+        var slice = Array.prototype.slice;
+        var _invoke = sinon.spy.invoke;
+
+        function callCountInWords(callCount) {
+            if (callCount == 0) {
+                return "never called";
+            } else {
+                return "called " + times(callCount);
+            }
+        }
+
+        function expectedCallCountInWords(expectation) {
+            var min = expectation.minCalls;
+            var max = expectation.maxCalls;
+
+            if (typeof min == "number" && typeof max == "number") {
+                var str = times(min);
+
+                if (min != max) {
+                    str = "at least " + str + " and at most " + times(max);
+                }
+
+                return str;
+            }
+
+            if (typeof min == "number") {
+                return "at least " + times(min);
+            }
+
+            return "at most " + times(max);
+        }
+
+        function receivedMinCalls(expectation) {
+            var hasMinLimit = typeof expectation.minCalls == "number";
+            return !hasMinLimit || expectation.callCount >= expectation.minCalls;
+        }
+
+        function receivedMaxCalls(expectation) {
+            if (typeof expectation.maxCalls != "number") {
+                return false;
+            }
+
+            return expectation.callCount == expectation.maxCalls;
+        }
+
+        function verifyMatcher(possibleMatcher, arg){
+            if (match && match.isMatcher(possibleMatcher)) {
+                return possibleMatcher.test(arg);
+            } else {
+                return true;
+            }
+        }
+
+        return {
+            minCalls: 1,
+            maxCalls: 1,
+
+            create: function create(methodName) {
+                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
+                delete expectation.create;
+                expectation.method = methodName;
+
+                return expectation;
+            },
+
+            invoke: function invoke(func, thisValue, args) {
+                this.verifyCallAllowed(thisValue, args);
+
+                return _invoke.apply(this, arguments);
+            },
+
+            atLeast: function atLeast(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.maxCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.minCalls = num;
+
+                return this;
+            },
+
+            atMost: function atMost(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.minCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.maxCalls = num;
+
+                return this;
+            },
+
+            never: function never() {
+                return this.exactly(0);
+            },
+
+            once: function once() {
+                return this.exactly(1);
+            },
+
+            twice: function twice() {
+                return this.exactly(2);
+            },
+
+            thrice: function thrice() {
+                return this.exactly(3);
+            },
+
+            exactly: function exactly(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not a number");
+                }
+
+                this.atLeast(num);
+                return this.atMost(num);
+            },
+
+            met: function met() {
+                return !this.failed && receivedMinCalls(this);
+            },
+
+            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
+                if (receivedMaxCalls(this)) {
+                    this.failed = true;
+                    sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
+                        this.expectedThis);
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return;
+                }
+
+                if (!args) {
+                    sinon.expectation.fail(this.method + " received no arguments, expected " +
+                        sinon.format(this.expectedArguments));
+                }
+
+                if (args.length < this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) +
+                        "), expected " + sinon.format(this.expectedArguments));
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) +
+                        "), expected " + sinon.format(this.expectedArguments));
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+
+                    if (!verifyMatcher(this.expectedArguments[i],args[i])) {
+                        sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
+                            ", didn't match " + this.expectedArguments.toString());
+                    }
+
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
+                            ", expected " + sinon.format(this.expectedArguments));
+                    }
+                }
+            },
+
+            allowsCall: function allowsCall(thisValue, args) {
+                if (this.met() && receivedMaxCalls(this)) {
+                    return false;
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    return false;
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return true;
+                }
+
+                args = args || [];
+
+                if (args.length < this.expectedArguments.length) {
+                    return false;
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    return false;
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+                    if (!verifyMatcher(this.expectedArguments[i],args[i])) {
+                        return false;
+                    }
+
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+
+            withArgs: function withArgs() {
+                this.expectedArguments = slice.call(arguments);
+                return this;
+            },
+
+            withExactArgs: function withExactArgs() {
+                this.withArgs.apply(this, arguments);
+                this.expectsExactArgCount = true;
+                return this;
+            },
+
+            on: function on(thisValue) {
+                this.expectedThis = thisValue;
+                return this;
+            },
+
+            toString: function () {
+                var args = (this.expectedArguments || []).slice();
+
+                if (!this.expectsExactArgCount) {
+                    push.call(args, "[...]");
+                }
+
+                var callStr = sinon.spyCall.toString.call({
+                    proxy: this.method || "anonymous mock expectation",
+                    args: args
+                });
+
+                var message = callStr.replace(", [...", "[, ...") + " " +
+                    expectedCallCountInWords(this);
+
+                if (this.met()) {
+                    return "Expectation met: " + message;
+                }
+
+                return "Expected " + message + " (" +
+                    callCountInWords(this.callCount) + ")";
+            },
+
+            verify: function verify() {
+                if (!this.met()) {
+                    sinon.expectation.fail(this.toString());
+                } else {
+                    sinon.expectation.pass(this.toString());
+                }
+
+                return true;
+            },
+
+            pass: function(message) {
+              sinon.assert.pass(message);
+            },
+            fail: function (message) {
+                var exception = new Error(message);
+                exception.name = "ExpectationError";
+
+                throw exception;
+            }
+        };
+    }());
+
+    if (commonJSModule) {
+        module.exports = mock;
+    } else {
+        sinon.mock = mock;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5,"./match":10}],12:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend collection.js
+ * @depend util/fake_timers.js
+ * @depend util/fake_server_with_clock.js
+ */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global require, module*/
+/**
+ * Manages fake collections as well as fake utilities such as Sinon's
+ * timers and fake XHR implementation in one convenient object.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+if (typeof module !== 'undefined' && module.exports) {
+    var sinon = require("../sinon");
+    sinon.extend(sinon, require("./util/fake_timers"));
+}
+
+(function () {
+    var push = [].push;
+
+    function exposeValue(sandbox, config, key, value) {
+        if (!value) {
+            return;
+        }
+
+        if (config.injectInto && !(key in config.injectInto) ) {
+            config.injectInto[key] = value;
+        } else {
+            push.call(sandbox.args, value);
+        }
+    }
+
+    function prepareSandboxFromConfig(config) {
+        var sandbox = sinon.create(sinon.sandbox);
+
+        if (config.useFakeServer) {
+            if (typeof config.useFakeServer == "object") {
+                sandbox.serverPrototype = config.useFakeServer;
+            }
+
+            sandbox.useFakeServer();
+        }
+
+        if (config.useFakeTimers) {
+            if (typeof config.useFakeTimers == "object") {
+                sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
+            } else {
+                sandbox.useFakeTimers();
+            }
+        }
+
+        return sandbox;
+    }
+
+    sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
+        useFakeTimers: function useFakeTimers() {
+            this.clock = sinon.useFakeTimers.apply(sinon, arguments);
+
+            return this.add(this.clock);
+        },
+
+        serverPrototype: sinon.fakeServer,
+
+        useFakeServer: function useFakeServer() {
+            var proto = this.serverPrototype || sinon.fakeServer;
+
+            if (!proto || !proto.create) {
+                return null;
+            }
+
+            this.server = proto.create();
+            return this.add(this.server);
+        },
+
+        inject: function (obj) {
+            sinon.collection.inject.call(this, obj);
+
+            if (this.clock) {
+                obj.clock = this.clock;
+            }
+
+            if (this.server) {
+                obj.server = this.server;
+                obj.requests = this.server.requests;
+            }
+
+            return obj;
+        },
+
+        create: function (config) {
+            if (!config) {
+                return sinon.create(sinon.sandbox);
+            }
+
+            var sandbox = prepareSandboxFromConfig(config);
+            sandbox.args = sandbox.args || [];
+            var prop, value, exposed = sandbox.inject({});
+
+            if (config.properties) {
+                for (var i = 0, l = config.properties.length; i < l; i++) {
+                    prop = config.properties[i];
+                    value = exposed[prop] || prop == "sandbox" && sandbox;
+                    exposeValue(sandbox, config, prop, value);
+                }
+            } else {
+                exposeValue(sandbox, config, "sandbox", value);
+            }
+
+            return sandbox;
+        }
+    });
+
+    sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = sinon.sandbox;
+    }
+}());
+
+},{"../sinon":5,"./util/fake_timers":17}],13:[function(require,module,exports){
+/**
+  * @depend ../sinon.js
+  * @depend call.js
+  */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+  * Spy functions
+  *
+  * @author Christian Johansen (christian@cjohansen.no)
+  * @license BSD
+  *
+  * Copyright (c) 2010-2013 Christian Johansen
+  */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+    var push = Array.prototype.push;
+    var slice = Array.prototype.slice;
+    var callId = 0;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function spy(object, property) {
+        if (!property && typeof object == "function") {
+            return spy.create(object);
+        }
+
+        if (!object && !property) {
+            return spy.create(function () { });
+        }
+
+        var method = object[property];
+        return sinon.wrapMethod(object, property, spy.create(method));
+    }
+
+    function matchingFake(fakes, args, strict) {
+        if (!fakes) {
+            return;
+        }
+
+        for (var i = 0, l = fakes.length; i < l; i++) {
+            if (fakes[i].matches(args, strict)) {
+                return fakes[i];
+            }
+        }
+    }
+
+    function incrementCallCount() {
+        this.called = true;
+        this.callCount += 1;
+        this.notCalled = false;
+        this.calledOnce = this.callCount == 1;
+        this.calledTwice = this.callCount == 2;
+        this.calledThrice = this.callCount == 3;
+    }
+
+    function createCallProperties() {
+        this.firstCall = this.getCall(0);
+        this.secondCall = this.getCall(1);
+        this.thirdCall = this.getCall(2);
+        this.lastCall = this.getCall(this.callCount - 1);
+    }
+
+    var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
+    function createProxy(func) {
+        // Retain the function length:
+        var p;
+        if (func.length) {
+            eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
+                ") { return p.invoke(func, this, slice.call(arguments)); });");
+        }
+        else {
+            p = function proxy() {
+                return p.invoke(func, this, slice.call(arguments));
+            };
+        }
+        return p;
+    }
+
+    var uuid = 0;
+
+    // Public API
+    var spyApi = {
+        reset: function () {
+            this.called = false;
+            this.notCalled = true;
+            this.calledOnce = false;
+            this.calledTwice = false;
+            this.calledThrice = false;
+            this.callCount = 0;
+            this.firstCall = null;
+            this.secondCall = null;
+            this.thirdCall = null;
+            this.lastCall = null;
+            this.args = [];
+            this.returnValues = [];
+            this.thisValues = [];
+            this.exceptions = [];
+            this.callIds = [];
+            if (this.fakes) {
+                for (var i = 0; i < this.fakes.length; i++) {
+                    this.fakes[i].reset();
+                }
+            }
+        },
+
+        create: function create(func) {
+            var name;
+
+            if (typeof func != "function") {
+                func = function () { };
+            } else {
+                name = sinon.functionName(func);
+            }
+
+            var proxy = createProxy(func);
+
+            sinon.extend(proxy, spy);
+            delete proxy.create;
+            sinon.extend(proxy, func);
+
+            proxy.reset();
+            proxy.prototype = func.prototype;
+            proxy.displayName = name || "spy";
+            proxy.toString = sinon.functionToString;
+            proxy._create = sinon.spy.create;
+            proxy.id = "spy#" + uuid++;
+
+            return proxy;
+        },
+
+        invoke: function invoke(func, thisValue, args) {
+            var matching = matchingFake(this.fakes, args);
+            var exception, returnValue;
+
+            incrementCallCount.call(this);
+            push.call(this.thisValues, thisValue);
+            push.call(this.args, args);
+            push.call(this.callIds, callId++);
+
+            try {
+                if (matching) {
+                    returnValue = matching.invoke(func, thisValue, args);
+                } else {
+                    returnValue = (this.func || func).apply(thisValue, args);
+                }
+
+                var thisCall = this.getCall(this.callCount - 1);
+                if (thisCall.calledWithNew() && typeof returnValue !== 'object') {
+                    returnValue = thisValue;
+                }
+            } catch (e) {
+                exception = e;
+            }
+
+            push.call(this.exceptions, exception);
+            push.call(this.returnValues, returnValue);
+
+            createCallProperties.call(this);
+
+            if (exception !== undefined) {
+                throw exception;
+            }
+
+            return returnValue;
+        },
+
+        getCall: function getCall(i) {
+            if (i < 0 || i >= this.callCount) {
+                return null;
+            }
+
+            return sinon.spyCall(this, this.thisValues[i], this.args[i],
+                                    this.returnValues[i], this.exceptions[i],
+                                    this.callIds[i]);
+        },
+
+        getCalls: function () {
+            var calls = [];
+            var i;
+
+            for (i = 0; i < this.callCount; i++) {
+                calls.push(this.getCall(i));
+            }
+
+            return calls;
+        },
+
+        calledBefore: function calledBefore(spyFn) {
+            if (!this.called) {
+                return false;
+            }
+
+            if (!spyFn.called) {
+                return true;
+            }
+
+            return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
+        },
+
+        calledAfter: function calledAfter(spyFn) {
+            if (!this.called || !spyFn.called) {
+                return false;
+            }
+
+            return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
+        },
+
+        withArgs: function () {
+            var args = slice.call(arguments);
+
+            if (this.fakes) {
+                var match = matchingFake(this.fakes, args, true);
+
+                if (match) {
+                    return match;
+                }
+            } else {
+                this.fakes = [];
+            }
+
+            var original = this;
+            var fake = this._create();
+            fake.matchingAguments = args;
+            fake.parent = this;
+            push.call(this.fakes, fake);
+
+            fake.withArgs = function () {
+                return original.withArgs.apply(original, arguments);
+            };
+
+            for (var i = 0; i < this.args.length; i++) {
+                if (fake.matches(this.args[i])) {
+                    incrementCallCount.call(fake);
+                    push.call(fake.thisValues, this.thisValues[i]);
+                    push.call(fake.args, this.args[i]);
+                    push.call(fake.returnValues, this.returnValues[i]);
+                    push.call(fake.exceptions, this.exceptions[i]);
+                    push.call(fake.callIds, this.callIds[i]);
+                }
+            }
+            createCallProperties.call(fake);
+
+            return fake;
+        },
+
+        matches: function (args, strict) {
+            var margs = this.matchingAguments;
+
+            if (margs.length <= args.length &&
+                sinon.deepEqual(margs, args.slice(0, margs.length))) {
+                return !strict || margs.length == args.length;
+            }
+        },
+
+        printf: function (format) {
+            var spy = this;
+            var args = slice.call(arguments, 1);
+            var formatter;
+
+            return (format || "").replace(/%(.)/g, function (match, specifyer) {
+                formatter = spyApi.formatters[specifyer];
+
+                if (typeof formatter == "function") {
+                    return formatter.call(null, spy, args);
+                } else if (!isNaN(parseInt(specifyer, 10))) {
+                    return sinon.format(args[specifyer - 1]);
+                }
+
+                return "%" + specifyer;
+            });
+        }
+    };
+
+    function delegateToCalls(method, matchAny, actual, notCalled) {
+        spyApi[method] = function () {
+            if (!this.called) {
+                if (notCalled) {
+                    return notCalled.apply(this, arguments);
+                }
+                return false;
+            }
+
+            var currentCall;
+            var matches = 0;
+
+            for (var i = 0, l = this.callCount; i < l; i += 1) {
+                currentCall = this.getCall(i);
+
+                if (currentCall[actual || method].apply(currentCall, arguments)) {
+                    matches += 1;
+
+                    if (matchAny) {
+                        return true;
+                    }
+                }
+            }
+
+            return matches === this.callCount;
+        };
+    }
+
+    delegateToCalls("calledOn", true);
+    delegateToCalls("alwaysCalledOn", false, "calledOn");
+    delegateToCalls("calledWith", true);
+    delegateToCalls("calledWithMatch", true);
+    delegateToCalls("alwaysCalledWith", false, "calledWith");
+    delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
+    delegateToCalls("calledWithExactly", true);
+    delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
+    delegateToCalls("neverCalledWith", false, "notCalledWith",
+        function () { return true; });
+    delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
+        function () { return true; });
+    delegateToCalls("threw", true);
+    delegateToCalls("alwaysThrew", false, "threw");
+    delegateToCalls("returned", true);
+    delegateToCalls("alwaysReturned", false, "returned");
+    delegateToCalls("calledWithNew", true);
+    delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
+    delegateToCalls("callArg", false, "callArgWith", function () {
+        throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+    });
+    spyApi.callArgWith = spyApi.callArg;
+    delegateToCalls("callArgOn", false, "callArgOnWith", function () {
+        throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+    });
+    spyApi.callArgOnWith = spyApi.callArgOn;
+    delegateToCalls("yield", false, "yield", function () {
+        throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+    });
+    // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
+    spyApi.invokeCallback = spyApi.yield;
+    delegateToCalls("yieldOn", false, "yieldOn", function () {
+        throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+    });
+    delegateToCalls("yieldTo", false, "yieldTo", function (property) {
+        throw new Error(this.toString() + " cannot yield to '" + property +
+            "' since it was not yet invoked.");
+    });
+    delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
+        throw new Error(this.toString() + " cannot yield to '" + property +
+            "' since it was not yet invoked.");
+    });
+
+    spyApi.formatters = {
+        "c": function (spy) {
+            return sinon.timesInWords(spy.callCount);
+        },
+
+        "n": function (spy) {
+            return spy.toString();
+        },
+
+        "C": function (spy) {
+            var calls = [];
+
+            for (var i = 0, l = spy.callCount; i < l; ++i) {
+                var stringifiedCall = "    " + spy.getCall(i).toString();
+                if (/\n/.test(calls[i - 1])) {
+                    stringifiedCall = "\n" + stringifiedCall;
+                }
+                push.call(calls, stringifiedCall);
+            }
+
+            return calls.length > 0 ? "\n" + calls.join("\n") : "";
+        },
+
+        "t": function (spy) {
+            var objects = [];
+
+            for (var i = 0, l = spy.callCount; i < l; ++i) {
+                push.call(objects, sinon.format(spy.thisValues[i]));
+            }
+
+            return objects.join(", ");
+        },
+
+        "*": function (spy, args) {
+            var formatted = [];
+
+            for (var i = 0, l = args.length; i < l; ++i) {
+                push.call(formatted, sinon.format(args[i]));
+            }
+
+            return formatted.join(", ");
+        }
+    };
+
+    sinon.extend(spy, spyApi);
+
+    spy.spyCall = sinon.spyCall;
+
+    if (commonJSModule) {
+        module.exports = spy;
+    } else {
+        sinon.spy = spy;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],14:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend spy.js
+ * @depend behavior.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global module, require, sinon*/
+/**
+ * Stub functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function stub(object, property, func) {
+        if (!!func && typeof func != "function") {
+            throw new TypeError("Custom stub should be function");
+        }
+
+        var wrapper;
+
+        if (func) {
+            wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
+        } else {
+            wrapper = stub.create();
+        }
+
+        if (!object && typeof property === "undefined") {
+            return sinon.stub.create();
+        }
+
+        if (typeof property === "undefined" && typeof object == "object") {
+            for (var prop in object) {
+                if (typeof object[prop] === "function") {
+                    stub(object, prop);
+                }
+            }
+
+            return object;
+        }
+
+        return sinon.wrapMethod(object, property, wrapper);
+    }
+
+    function getDefaultBehavior(stub) {
+        return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);
+    }
+
+    function getParentBehaviour(stub) {
+        return (stub.parent && getCurrentBehavior(stub.parent));
+    }
+
+    function getCurrentBehavior(stub) {
+        var behavior = stub.behaviors[stub.callCount - 1];
+        return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);
+    }
+
+    var uuid = 0;
+
+    sinon.extend(stub, (function () {
+        var proto = {
+            create: function create() {
+                var functionStub = function () {
+                    return getCurrentBehavior(functionStub).invoke(this, arguments);
+                };
+
+                functionStub.id = "stub#" + uuid++;
+                var orig = functionStub;
+                functionStub = sinon.spy.create(functionStub);
+                functionStub.func = orig;
+
+                sinon.extend(functionStub, stub);
+                functionStub._create = sinon.stub.create;
+                functionStub.displayName = "stub";
+                functionStub.toString = sinon.functionToString;
+
+                functionStub.defaultBehavior = null;
+                functionStub.behaviors = [];
+
+                return functionStub;
+            },
+
+            resetBehavior: function () {
+                var i;
+
+                this.defaultBehavior = null;
+                this.behaviors = [];
+
+                delete this.returnValue;
+                delete this.returnArgAt;
+                this.returnThis = false;
+
+                if (this.fakes) {
+                    for (i = 0; i < this.fakes.length; i++) {
+                        this.fakes[i].resetBehavior();
+                    }
+                }
+            },
+
+            onCall: function(index) {
+                if (!this.behaviors[index]) {
+                    this.behaviors[index] = sinon.behavior.create(this);
+                }
+
+                return this.behaviors[index];
+            },
+
+            onFirstCall: function() {
+                return this.onCall(0);
+            },
+
+            onSecondCall: function() {
+                return this.onCall(1);
+            },
+
+            onThirdCall: function() {
+                return this.onCall(2);
+            }
+        };
+
+        for (var method in sinon.behavior) {
+            if (sinon.behavior.hasOwnProperty(method) &&
+                !proto.hasOwnProperty(method) &&
+                method != 'create' &&
+                method != 'withArgs' &&
+                method != 'invoke') {
+                proto[method] = (function(behaviorMethod) {
+                    return function() {
+                        this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);
+                        this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);
+                        return this;
+                    };
+                }(method));
+            }
+        }
+
+        return proto;
+    }()));
+
+    if (commonJSModule) {
+        module.exports = stub;
+    } else {
+        sinon.stub = stub;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],15:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ * @depend sandbox.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Test function, sandboxes fakes
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function test(callback) {
+        var type = typeof callback;
+
+        if (type != "function") {
+            throw new TypeError("sinon.test needs to wrap a test function, got " + type);
+        }
+
+        return function () {
+            var config = sinon.getConfig(sinon.config);
+            config.injectInto = config.injectIntoThis && this || config.injectInto;
+            var sandbox = sinon.sandbox.create(config);
+            var exception, result;
+            var args = Array.prototype.slice.call(arguments).concat(sandbox.args);
+
+            try {
+                result = callback.apply(this, args);
+            } catch (e) {
+                exception = e;
+            }
+
+            if (typeof exception !== "undefined") {
+                sandbox.restore();
+                throw exception;
+            }
+            else {
+                sandbox.verifyAndRestore();
+            }
+
+            return result;
+        };
+    }
+
+    test.config = {
+        injectIntoThis: true,
+        injectInto: null,
+        properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+        useFakeTimers: true,
+        useFakeServer: true
+    };
+
+    if (commonJSModule) {
+        module.exports = test;
+    } else {
+        sinon.test = test;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],16:[function(require,module,exports){
+/**
+ * @depend ../sinon.js
+ * @depend test.js
+ */
+/*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
+/*global module, require, sinon*/
+/**
+ * Test case, sandboxes all test functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon) {
+    var commonJSModule = typeof module !== 'undefined' && module.exports;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon || !Object.prototype.hasOwnProperty) {
+        return;
+    }
+
+    function createTest(property, setUp, tearDown) {
+        return function () {
+            if (setUp) {
+                setUp.apply(this, arguments);
+            }
+
+            var exception, result;
+
+            try {
+                result = property.apply(this, arguments);
+            } catch (e) {
+                exception = e;
+            }
+
+            if (tearDown) {
+                tearDown.apply(this, arguments);
+            }
+
+            if (exception) {
+                throw exception;
+            }
+
+            return result;
+        };
+    }
+
+    function testCase(tests, prefix) {
+        /*jsl:ignore*/
+        if (!tests || typeof tests != "object") {
+            throw new TypeError("sinon.testCase needs an object with test functions");
+        }
+        /*jsl:end*/
+
+        prefix = prefix || "test";
+        var rPrefix = new RegExp("^" + prefix);
+        var methods = {}, testName, property, method;
+        var setUp = tests.setUp;
+        var tearDown = tests.tearDown;
+
+        for (testName in tests) {
+            if (tests.hasOwnProperty(testName)) {
+                property = tests[testName];
+
+                if (/^(setUp|tearDown)$/.test(testName)) {
+                    continue;
+                }
+
+                if (typeof property == "function" && rPrefix.test(testName)) {
+                    method = property;
+
+                    if (setUp || tearDown) {
+                        method = createTest(property, setUp, tearDown);
+                    }
+
+                    methods[testName] = sinon.test(method);
+                } else {
+                    methods[testName] = tests[testName];
+                }
+            }
+        }
+
+        return methods;
+    }
+
+    if (commonJSModule) {
+        module.exports = testCase;
+    } else {
+        sinon.testCase = testCase;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+},{"../sinon":5}],17:[function(require,module,exports){
+(function (global){
+/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
+/*global module, require, window*/
+/**
+ * Fake timer API
+ * setTimeout
+ * setInterval
+ * clearTimeout
+ * clearInterval
+ * tick
+ * reset
+ * Date
+ *
+ * Inspired by jsUnitMockTimeOut from JsUnit
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+if (typeof sinon == "undefined") {
+    var sinon = {};
+}
+
+(function (global) {
+    var id = 1;
+
+    function addTimer(args, recurring) {
+        if (args.length === 0) {
+            throw new Error("Function requires at least 1 parameter");
+        }
+
+        if (typeof args[0] === "undefined") {
+            throw new Error("Callback must be provided to timer calls");
+        }
+
+        var toId = id++;
+        var delay = args[1] || 0;
+
+        if (!this.timeouts) {
+            this.timeouts = {};
+        }
+
+        this.timeouts[toId] = {
+            id: toId,
+            func: args[0],
+            callAt: this.now + delay,
+            invokeArgs: Array.prototype.slice.call(args, 2)
+        };
+
+        if (recurring === true) {
+            this.timeouts[toId].interval = delay;
+        }
+
+        return toId;
+    }
+
+    function parseTime(str) {
+        if (!str) {
+            return 0;
+        }
+
+        var strings = str.split(":");
+        var l = strings.length, i = l;
+        var ms = 0, parsed;
+
+        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+            throw new Error("tick only understands numbers and 'h:m:s'");
+        }
+
+        while (i--) {
+            parsed = parseInt(strings[i], 10);
+
+            if (parsed >= 60) {
+                throw new Error("Invalid time " + str);
+            }
+
+            ms += parsed * Math.pow(60, (l - i - 1));
+        }
+
+        return ms * 1000;
+    }
+
+    function createObject(object) {
+        var newObject;
+
+        if (Object.create) {
+            newObject = Object.create(object);
+        } else {
+            var F = function () {};
+            F.prototype = object;
+            newObject = new F();
+        }
+
+        newObject.Date.clock = newObject;
+        return newObject;
+    }
+
+    sinon.clock = {
+        now: 0,
+
+        create: function create(now) {
+            var clock = createObject(this);
+
+            if (typeof now == "number") {
+                clock.now = now;
+            }
+
+            if (!!now && typeof now == "object") {
+                throw new TypeError("now should be milliseconds since UNIX epoch");
+            }
+
+            return clock;
+        },
+
+        setTimeout: function setTimeout(callback, timeout) {
+            return addTimer.call(this, arguments, false);
+        },
+
+        clearTimeout: function clearTimeout(timerId) {
+            if (!this.timeouts) {
+                this.timeouts = [];
+            }
+
+            if (timerId in this.timeouts) {
+                delete this.timeouts[timerId];
+            }
+        },
+
+        setInterval: function setInterval(callback, timeout) {
+            return addTimer.call(this, arguments, true);
+        },
+
+        clearInterval: function clearInterval(timerId) {
+            this.clearTimeout(timerId);
+        },
+
+        setImmediate: function setImmediate(callback) {
+            var passThruArgs = Array.prototype.slice.call(arguments, 1);
+
+            return addTimer.call(this, [callback, 0].concat(passThruArgs), false);
+        },
+
+        clearImmediate: function clearImmediate(timerId) {
+            this.clearTimeout(timerId);
+        },
+
+        tick: function tick(ms) {
+            ms = typeof ms == "number" ? ms : parseTime(ms);
+            var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
+            var timer = this.firstTimerInRange(tickFrom, tickTo);
+
+            var firstException;
+            while (timer && tickFrom <= tickTo) {
+                if (this.timeouts[timer.id]) {
+                    tickFrom = this.now = timer.callAt;
+                    try {
+                      this.callTimer(timer);
+                    } catch (e) {
+                      firstException = firstException || e;
+                    }
+                }
+
+                timer = this.firstTimerInRange(previous, tickTo);
+                previous = tickFrom;
+            }
+
+            this.now = tickTo;
+
+            if (firstException) {
+              throw firstException;
+            }
+
+            return this.now;
+        },
+
+        firstTimerInRange: function (from, to) {
+            var timer, smallest = null, originalTimer;
+
+            for (var id in this.timeouts) {
+                if (this.timeouts.hasOwnProperty(id)) {
+                    if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
+                        continue;
+                    }
+
+                    if (smallest === null || this.timeouts[id].callAt < smallest) {
+                        originalTimer = this.timeouts[id];
+                        smallest = this.timeouts[id].callAt;
+
+                        timer = {
+                            func: this.timeouts[id].func,
+                            callAt: this.timeouts[id].callAt,
+                            interval: this.timeouts[id].interval,
+                            id: this.timeouts[id].id,
+                            invokeArgs: this.timeouts[id].invokeArgs
+                        };
+                    }
+                }
+            }
+
+            return timer || null;
+        },
+
+        callTimer: function (timer) {
+            if (typeof timer.interval == "number") {
+                this.timeouts[timer.id].callAt += timer.interval;
+            } else {
+                delete this.timeouts[timer.id];
+            }
+
+            try {
+                if (typeof timer.func == "function") {
+                    timer.func.apply(null, timer.invokeArgs);
+                } else {
+                    eval(timer.func);
+                }
+            } catch (e) {
+              var exception = e;
+            }
+
+            if (!this.timeouts[timer.id]) {
+                if (exception) {
+                  throw exception;
+                }
+                return;
+            }
+
+            if (exception) {
+              throw exception;
+            }
+        },
+
+        reset: function reset() {
+            this.timeouts = {};
+        },
+
+        Date: (function () {
+            var NativeDate = Date;
+
+            function ClockDate(year, month, date, hour, minute, second, ms) {
+                // Defensive and verbose to avoid potential harm in passing
+                // explicit undefined when user does not pass argument
+                switch (arguments.length) {
+                case 0:
+                    return new NativeDate(ClockDate.clock.now);
+                case 1:
+                    return new NativeDate(year);
+                case 2:
+                    return new NativeDate(year, month);
+                case 3:
+                    return new NativeDate(year, month, date);
+                case 4:
+                    return new NativeDate(year, month, date, hour);
+                case 5:
+                    return new NativeDate(year, month, date, hour, minute);
+                case 6:
+                    return new NativeDate(year, month, date, hour, minute, second);
+                default:
+                    return new NativeDate(year, month, date, hour, minute, second, ms);
+                }
+            }
+
+            return mirrorDateProperties(ClockDate, NativeDate);
+        }())
+    };
+
+    function mirrorDateProperties(target, source) {
+        if (source.now) {
+            target.now = function now() {
+                return target.clock.now;
+            };
+        } else {
+            delete target.now;
+        }
+
+        if (source.toSource) {
+            target.toSource = function toSource() {
+                return source.toSource();
+            };
+        } else {
+            delete target.toSource;
+        }
+
+        target.toString = function toString() {
+            return source.toString();
+        };
+
+        target.prototype = source.prototype;
+        target.parse = source.parse;
+        target.UTC = source.UTC;
+        target.prototype.toUTCString = source.prototype.toUTCString;
+
+        for (var prop in source) {
+            if (source.hasOwnProperty(prop)) {
+                target[prop] = source[prop];
+            }
+        }
+
+        return target;
+    }
+
+    var methods = ["Date", "setTimeout", "setInterval",
+                   "clearTimeout", "clearInterval"];
+
+    if (typeof global.setImmediate !== "undefined") {
+        methods.push("setImmediate");
+    }
+
+    if (typeof global.clearImmediate !== "undefined") {
+        methods.push("clearImmediate");
+    }
+
+    function restore() {
+        var method;
+
+        for (var i = 0, l = this.methods.length; i < l; i++) {
+            method = this.methods[i];
+
+            if (global[method].hadOwnProperty) {
+                global[method] = this["_" + method];
+            } else {
+                try {
+                    delete global[method];
+                } catch (e) {}
+            }
+        }
+
+        // Prevent multiple executions which will completely remove these props
+        this.methods = [];
+    }
+
+    function stubGlobal(method, clock) {
+        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(global, method);
+        clock["_" + method] = global[method];
+
+        if (method == "Date") {
+            var date = mirrorDateProperties(clock[method], global[method]);
+            global[method] = date;
+        } else {
+            global[method] = function () {
+                return clock[method].apply(clock, arguments);
+            };
+
+            for (var prop in clock[method]) {
+                if (clock[method].hasOwnProperty(prop)) {
+                    global[method][prop] = clock[method][prop];
+                }
+            }
+        }
+
+        global[method].clock = clock;
+    }
+
+    sinon.useFakeTimers = function useFakeTimers(now) {
+        var clock = sinon.clock.create(now);
+        clock.restore = restore;
+        clock.methods = Array.prototype.slice.call(arguments,
+                                                   typeof now == "number" ? 1 : 0);
+
+        if (clock.methods.length === 0) {
+            clock.methods = methods;
+        }
+
+        for (var i = 0, l = clock.methods.length; i < l; i++) {
+            stubGlobal(clock.methods[i], clock);
+        }
+
+        return clock;
+    };
+}(typeof global != "undefined" && typeof global !== "function" ? global : this));
+
+sinon.timers = {
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
+    clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined),
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+    Date: Date
+};
+
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = sinon;
+}
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],18:[function(require,module,exports){
+(function (global){
+((typeof define === "function" && define.amd && function (m) {
+    define("formatio", ["samsam"], m);
+}) || (typeof module === "object" && function (m) {
+    module.exports = m(require("samsam"));
+}) || function (m) { this.formatio = m(this.samsam); }
+)(function (samsam) {
+    "use strict";
+
+    var formatio = {
+        excludeConstructors: ["Object", /^.$/],
+        quoteStrings: true
+    };
+
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    var specialObjects = [];
+    if (typeof global !== "undefined") {
+        specialObjects.push({ object: global, value: "[object global]" });
+    }
+    if (typeof document !== "undefined") {
+        specialObjects.push({
+            object: document,
+            value: "[object HTMLDocument]"
+        });
+    }
+    if (typeof window !== "undefined") {
+        specialObjects.push({ object: window, value: "[object Window]" });
+    }
+
+    function functionName(func) {
+        if (!func) { return ""; }
+        if (func.displayName) { return func.displayName; }
+        if (func.name) { return func.name; }
+        var matches = func.toString().match(/function\s+([^\(]+)/m);
+        return (matches && matches[1]) || "";
+    }
+
+    function constructorName(f, object) {
+        var name = functionName(object && object.constructor);
+        var excludes = f.excludeConstructors ||
+                formatio.excludeConstructors || [];
+
+        var i, l;
+        for (i = 0, l = excludes.length; i < l; ++i) {
+            if (typeof excludes[i] === "string" && excludes[i] === name) {
+                return "";
+            } else if (excludes[i].test && excludes[i].test(name)) {
+                return "";
+            }
+        }
+
+        return name;
+    }
+
+    function isCircular(object, objects) {
+        if (typeof object !== "object") { return false; }
+        var i, l;
+        for (i = 0, l = objects.length; i < l; ++i) {
+            if (objects[i] === object) { return true; }
+        }
+        return false;
+    }
+
+    function ascii(f, object, processed, indent) {
+        if (typeof object === "string") {
+            var qs = f.quoteStrings;
+            var quote = typeof qs !== "boolean" || qs;
+            return processed || quote ? '"' + object + '"' : object;
+        }
+
+        if (typeof object === "function" && !(object instanceof RegExp)) {
+            return ascii.func(object);
+        }
+
+        processed = processed || [];
+
+        if (isCircular(object, processed)) { return "[Circular]"; }
+
+        if (Object.prototype.toString.call(object) === "[object Array]") {
+            return ascii.array.call(f, object, processed);
+        }
+
+        if (!object) { return String((1/object) === -Infinity ? "-0" : object); }
+        if (samsam.isElement(object)) { return ascii.element(object); }
+
+        if (typeof object.toString === "function" &&
+                object.toString !== Object.prototype.toString) {
+            return object.toString();
+        }
+
+        var i, l;
+        for (i = 0, l = specialObjects.length; i < l; i++) {
+            if (object === specialObjects[i].object) {
+                return specialObjects[i].value;
+            }
+        }
+
+        return ascii.object.call(f, object, processed, indent);
+    }
+
+    ascii.func = function (func) {
+        return "function " + functionName(func) + "() {}";
+    };
+
+    ascii.array = function (array, processed) {
+        processed = processed || [];
+        processed.push(array);
+        var i, l, pieces = [];
+        for (i = 0, l = array.length; i < l; ++i) {
+            pieces.push(ascii(this, array[i], processed));
+        }
+        return "[" + pieces.join(", ") + "]";
+    };
+
+    ascii.object = function (object, processed, indent) {
+        processed = processed || [];
+        processed.push(object);
+        indent = indent || 0;
+        var pieces = [], properties = samsam.keys(object).sort();
+        var length = 3;
+        var prop, str, obj, i, l;
+
+        for (i = 0, l = properties.length; i < l; ++i) {
+            prop = properties[i];
+            obj = object[prop];
+
+            if (isCircular(obj, processed)) {
+                str = "[Circular]";
+            } else {
+                str = ascii(this, obj, processed, indent + 2);
+            }
+
+            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+            length += str.length;
+            pieces.push(str);
+        }
+
+        var cons = constructorName(this, object);
+        var prefix = cons ? "[" + cons + "] " : "";
+        var is = "";
+        for (i = 0, l = indent; i < l; ++i) { is += " "; }
+
+        if (length + indent > 80) {
+            return prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" +
+                is + "}";
+        }
+        return prefix + "{ " + pieces.join(", ") + " }";
+    };
+
+    ascii.element = function (element) {
+        var tagName = element.tagName.toLowerCase();
+        var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;
+
+        for (i = 0, l = attrs.length; i < l; ++i) {
+            attr = attrs.item(i);
+            attrName = attr.nodeName.toLowerCase().replace("html:", "");
+            val = attr.nodeValue;
+            if (attrName !== "contenteditable" || val !== "inherit") {
+                if (!!val) { pairs.push(attrName + "=\"" + val + "\""); }
+            }
+        }
+
+        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+        var content = element.innerHTML;
+
+        if (content.length > 20) {
+            content = content.substr(0, 20) + "[...]";
+        }
+
+        var res = formatted + pairs.join(" ") + ">" + content +
+                "</" + tagName + ">";
+
+        return res.replace(/ contentEditable="inherit"/, "");
+    };
+
+    function Formatio(options) {
+        for (var opt in options) {
+            this[opt] = options[opt];
+        }
+    }
+
+    Formatio.prototype = {
+        functionName: functionName,
+
+        configure: function (options) {
+            return new Formatio(options);
+        },
+
+        constructorName: function (object) {
+            return constructorName(this, object);
+        },
+
+        ascii: function (object, processed, indent) {
+            return ascii(this, object, processed, indent);
+        }
+    };
+
+    return Formatio.prototype;
+});
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"samsam":19}],19:[function(require,module,exports){
+((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) ||
+ (typeof module === "object" &&
+      function (m) { module.exports = m(); }) || // Node
+ function (m) { this.samsam = m(); } // Browser globals
+)(function () {
+    var o = Object.prototype;
+    var div = typeof document !== "undefined" && document.createElement("div");
+
+    function isNaN(value) {
+        // Unlike global isNaN, this avoids type coercion
+        // typeof check avoids IE host object issues, hat tip to
+        // lodash
+        var val = value; // JsLint thinks value !== value is "weird"
+        return typeof value === "number" && value !== val;
+    }
+
+    function getClass(value) {
+        // Returns the internal [[Class]] by calling Object.prototype.toString
+        // with the provided value as this. Return value is a string, naming the
+        // internal class, e.g. "Array"
+        return o.toString.call(value).split(/[ \]]/)[1];
+    }
+
+    /**
+     * @name samsam.isArguments
+     * @param Object object
+     *
+     * Returns ``true`` if ``object`` is an ``arguments`` object,
+     * ``false`` otherwise.
+     */
+    function isArguments(object) {
+        if (typeof object !== "object" || typeof object.length !== "number" ||
+                getClass(object) === "Array") {
+            return false;
+        }
+        if (typeof object.callee == "function") { return true; }
+        try {
+            object[object.length] = 6;
+            delete object[object.length];
+        } catch (e) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @name samsam.isElement
+     * @param Object object
+     *
+     * Returns ``true`` if ``object`` is a DOM element node. Unlike
+     * Underscore.js/lodash, this function will return ``false`` if ``object``
+     * is an *element-like* object, i.e. a regular object with a ``nodeType``
+     * property that holds the value ``1``.
+     */
+    function isElement(object) {
+        if (!object || object.nodeType !== 1 || !div) { return false; }
+        try {
+            object.appendChild(div);
+            object.removeChild(div);
+        } catch (e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @name samsam.keys
+     * @param Object object
+     *
+     * Return an array of own property names.
+     */
+    function keys(object) {
+        var ks = [], prop;
+        for (prop in object) {
+            if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
+        }
+        return ks;
+    }
+
+    /**
+     * @name samsam.isDate
+     * @param Object value
+     *
+     * Returns true if the object is a ``Date``, or *date-like*. Duck typing
+     * of date objects work by checking that the object has a ``getTime``
+     * function whose return value equals the return value from the object's
+     * ``valueOf``.
+     */
+    function isDate(value) {
+        return typeof value.getTime == "function" &&
+            value.getTime() == value.valueOf();
+    }
+
+    /**
+     * @name samsam.isNegZero
+     * @param Object value
+     *
+     * Returns ``true`` if ``value`` is ``-0``.
+     */
+    function isNegZero(value) {
+        return value === 0 && 1 / value === -Infinity;
+    }
+
+    /**
+     * @name samsam.equal
+     * @param Object obj1
+     * @param Object obj2
+     *
+     * Returns ``true`` if two objects are strictly equal. Compared to
+     * ``===`` there are two exceptions:
+     *
+     *   - NaN is considered equal to NaN
+     *   - -0 and +0 are not considered equal
+     */
+    function identical(obj1, obj2) {
+        if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
+            return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
+        }
+    }
+
+
+    /**
+     * @name samsam.deepEqual
+     * @param Object obj1
+     * @param Object obj2
+     *
+     * Deep equal comparison. Two values are "deep equal" if:
+     *
+     *   - They are equal, according to samsam.identical
+     *   - They are both date objects representing the same time
+     *   - They are both arrays containing elements that are all deepEqual
+     *   - They are objects with the same set of properties, and each property
+     *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``
+     *
+     * Supports cyclic objects.
+     */
+    function deepEqualCyclic(obj1, obj2) {
+
+        // used for cyclic comparison
+        // contain already visited objects
+        var objects1 = [],
+            objects2 = [],
+        // contain pathes (position in the object structure)
+        // of the already visited objects
+        // indexes same as in objects arrays
+            paths1 = [],
+            paths2 = [],
+        // contains combinations of already compared objects
+        // in the manner: { "$1['ref']$2['ref']": true }
+            compared = {};
+
+        /**
+         * used to check, if the value of a property is an object
+         * (cyclic logic is only needed for objects)
+         * only needed for cyclic logic
+         */
+        function isObject(value) {
+
+            if (typeof value === 'object' && value !== null &&
+                    !(value instanceof Boolean) &&
+                    !(value instanceof Date)    &&
+                    !(value instanceof Number)  &&
+                    !(value instanceof RegExp)  &&
+                    !(value instanceof String)) {
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * returns the index of the given object in the
+         * given objects array, -1 if not contained
+         * only needed for cyclic logic
+         */
+        function getIndex(objects, obj) {
+
+            var i;
+            for (i = 0; i < objects.length; i++) {
+                if (objects[i] === obj) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        // does the recursion for the deep equal check
+        return (function deepEqual(obj1, obj2, path1, path2) {
+            var type1 = typeof obj1;
+            var type2 = typeof obj2;
+
+            // == null also matches undefined
+            if (obj1 === obj2 ||
+                    isNaN(obj1) || isNaN(obj2) ||
+                    obj1 == null || obj2 == null ||
+                    type1 !== "object" || type2 !== "object") {
+
+                return identical(obj1, obj2);
+            }
+
+            // Elements are only equal if identical(expected, actual)
+            if (isElement(obj1) || isElement(obj2)) { return false; }
+
+            var isDate1 = isDate(obj1), isDate2 = isDate(obj2);
+            if (isDate1 || isDate2) {
+                if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {
+                    return false;
+                }
+            }
+
+            if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
+                if (obj1.toString() !== obj2.toString()) { return false; }
+            }
+
+            var class1 = getClass(obj1);
+            var class2 = getClass(obj2);
+            var keys1 = keys(obj1);
+            var keys2 = keys(obj2);
+
+            if (isArguments(obj1) || isArguments(obj2)) {
+                if (obj1.length !== obj2.length) { return false; }
+            } else {
+                if (type1 !== type2 || class1 !== class2 ||
+                        keys1.length !== keys2.length) {
+                    return false;
+                }
+            }
+
+            var key, i, l,
+                // following vars are used for the cyclic logic
+                value1, value2,
+                isObject1, isObject2,
+                index1, index2,
+                newPath1, newPath2;
+
+            for (i = 0, l = keys1.length; i < l; i++) {
+                key = keys1[i];
+                if (!o.hasOwnProperty.call(obj2, key)) {
+                    return false;
+                }
+
+                // Start of the cyclic logic
+
+                value1 = obj1[key];
+                value2 = obj2[key];
+
+                isObject1 = isObject(value1);
+                isObject2 = isObject(value2);
+
+                // determine, if the objects were already visited
+                // (it's faster to check for isObject first, than to
+                // get -1 from getIndex for non objects)
+                index1 = isObject1 ? getIndex(objects1, value1) : -1;
+                index2 = isObject2 ? getIndex(objects2, value2) : -1;
+
+                // determine the new pathes of the objects
+                // - for non cyclic objects the current path will be extended
+                //   by current property name
+                // - for cyclic objects the stored path is taken
+                newPath1 = index1 !== -1
+                    ? paths1[index1]
+                    : path1 + '[' + JSON.stringify(key) + ']';
+                newPath2 = index2 !== -1
+                    ? paths2[index2]
+                    : path2 + '[' + JSON.stringify(key) + ']';
+
+                // stop recursion if current objects are already compared
+                if (compared[newPath1 + newPath2]) {
+                    return true;
+                }
+
+                // remember the current objects and their pathes
+                if (index1 === -1 && isObject1) {
+                    objects1.push(value1);
+                    paths1.push(newPath1);
+                }
+                if (index2 === -1 && isObject2) {
+                    objects2.push(value2);
+                    paths2.push(newPath2);
+                }
+
+                // remember that the current objects are already compared
+                if (isObject1 && isObject2) {
+                    compared[newPath1 + newPath2] = true;
+                }
+
+                // End of cyclic logic
+
+                // neither value1 nor value2 is a cycle
+                // continue with next level
+                if (!deepEqual(value1, value2, newPath1, newPath2)) {
+                    return false;
+                }
+            }
+
+            return true;
+
+        }(obj1, obj2, '$1', '$2'));
+    }
+
+    var match;
+
+    function arrayContains(array, subset) {
+        if (subset.length === 0) { return true; }
+        var i, l, j, k;
+        for (i = 0, l = array.length; i < l; ++i) {
+            if (match(array[i], subset[0])) {
+                for (j = 0, k = subset.length; j < k; ++j) {
+                    if (!match(array[i + j], subset[j])) { return false; }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @name samsam.match
+     * @param Object object
+     * @param Object matcher
+     *
+     * Compare arbitrary value ``object`` with matcher.
+     */
+    match = function match(object, matcher) {
+        if (matcher && typeof matcher.test === "function") {
+            return matcher.test(object);
+        }
+
+        if (typeof matcher === "function") {
+            return matcher(object) === true;
+        }
+
+        if (typeof matcher === "string") {
+            matcher = matcher.toLowerCase();
+            var notNull = typeof object === "string" || !!object;
+            return notNull &&
+                (String(object)).toLowerCase().indexOf(matcher) >= 0;
+        }
+
+        if (typeof matcher === "number") {
+            return matcher === object;
+        }
+
+        if (typeof matcher === "boolean") {
+            return matcher === object;
+        }
+
+        if (getClass(object) === "Array" && getClass(matcher) === "Array") {
+            return arrayContains(object, matcher);
+        }
+
+        if (matcher && typeof matcher === "object") {
+            var prop;
+            for (prop in matcher) {
+                if (!match(object[prop], matcher[prop])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        throw new Error("Matcher was not a string, a number, a " +
+                        "function, a boolean or an object");
+    };
+
+    return {
+        isArguments: isArguments,
+        isElement: isElement,
+        isDate: isDate,
+        isNegZero: isNegZero,
+        identical: identical,
+        deepEqual: deepEqualCyclic,
+        match: match,
+        keys: keys
+    };
+});
+
+},{}],20:[function(require,module,exports){
+(function (global){
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],21:[function(require,module,exports){
+var $ = require('unopinionate').selector;
+
+var $document   = $(document),
+    bindings    = {};
+
+var click = function(events) {
+    click.bind.apply(click, arguments);
+    return click;
+};
+
+/*** Configuration Options ***/
+click.distanceLimit = 10;
+click.timeLimit     = 140;
+
+/*** Useful Properties ***/
+click.isTouch = ('ontouchstart' in window) ||
+                window.DocumentTouch &&
+                document instanceof DocumentTouch;
+
+/*** Cached Functions ***/
+var onTouchstart = function(e) {
+    var $this       = $(this),
+        startTime   = new Date().getTime(),
+        startPos    = click._getPos(e);
+
+    $this.one('touchend', function(e) {
+        e.preventDefault(); //Prevents click event from firing
+        
+        var time        = new Date().getTime() - startTime,
+            endPos      = click._getPos(e),
+            distance    = Math.sqrt(
+                Math.pow(endPos.x - startPos.x, 2) +
+                Math.pow(endPos.y - startPos.y, 2)
+            );
+
+        if(time < click.timeLimit && distance < click.distanceLimit) {
+            //Find the correct callback
+            $.each(bindings, function(selector, callback) {
+                if($this.is(selector)) {
+                    callback.apply(e.target, [e]);
+                    return false;
+                }
+            });
+        }
+    });
+};
+
+/*** API ***/
+click.bind = function(events) {
+
+    //Argument Surgery
+    if(!$.isPlainObject(events)) {
+        newEvents = {};
+        newEvents[arguments[0]] = arguments[1];
+        events = newEvents;
+    }
+
+    $.each(events, function(selector, callback) {
+
+        /*** Register Binding ***/
+        if(typeof bindings[selector] != 'undefined') {
+            click.unbind(selector); //Ensure no duplicates
+        }
+        
+        bindings[selector] = callback;
+
+        /*** Touch Support ***/
+        if(click.isTouch) {
+            $document.delegate(selector, 'touchstart', onTouchstart);
+        }
+
+        /*** Mouse Support ***/
+        $document.delegate(selector, 'click', callback);
+    });
+
+    return this;
+};
+
+click.unbind = function(selector) {
+    $document
+        .undelegate(selector, 'touchstart')
+        .undelegate(selector, 'click');
+
+    delete bindings[selector];
+
+    return this;
+};
+
+click.unbindAll = function() {
+    $.each(bindings, function(selector, callback) {
+        $document
+            .undelegate(selector, 'touchstart')
+            .undelegate(selector, 'click');
+    });
+    
+    bindings = {};
+
+    return this;
+};
+
+click.trigger = function(selector, e) {
+    e = e || $.Event('click');
+
+    if(typeof bindings[selector] != 'undefined') {
+        bindings[selector](e);
+    }
+    else {
+        console.error("No click events bound for selector '"+selector+"'.");
+    }
+
+    return this;
+};
+
+/*** Internal (but useful) Methods ***/
+click._getPos = function(e) {
+    e = e.originalEvent;
+
+    if(e.pageX || e.pageY) {
+        return {
+            x: e.pageX,
+            y: e.pageY
+        };
+    }
+    else if(e.changedTouches) {
+        return {
+            x: e.changedTouches[0].clientX,
+            y: e.changedTouches[0].clientY
+        };
+    }
+    else {
+        return {
+            x: e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft,
+            y: e.clientY + document.body.scrollTop  + document.documentElement.scrollTop
+        };
+    }
+};
+
+module.exports = click;
+
+
+},{"unopinionate":20}],22:[function(require,module,exports){
+var sinon = require('sinon'),
+    click = require('../src/onClick'),
+    module = window.module,
+    sandbox,
+    testCallback;
+
+module("onClick", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+        testCallback    = sinon.spy();
+    },
+    teardown: function() {
+        click.unbindAll();
+    }
+});
+
+test("#trigger", function() {
+    click({
+        '#button': testCallback
+    });
+
+    click.trigger('#button');
+    ok(testCallback.called);
+});
+
+test("#unbindAll", function() {
+    click({
+        '#button': testCallback
+    })
+        .unbindAll()
+        .trigger('#button');
+
+    ok(!testCallback.called);
+});
+
+test("#bind object syntax", function() {
+    click
+        .bind({
+            '#button': testCallback
+        })
+        .trigger('#button');
+
+    ok(testCallback.called);
+});
+
+test("#bind argument syntax", function() {
+    click
+        .bind('#button', testCallback)
+        .trigger('#button');
+
+    ok(testCallback.called);
+});
+
+test("#unbind", function() {
+    click
+        .bind('#button', testCallback)
+        .unbind('#button')
+        .trigger('#button');
+
+    ok(!testCallback.called);
+});
+
+test("#_getPos", function() {
+    //pageX/pageY
+    var pos = click._getPos({
+        originalEvent: {
+            pageX: 100,
+            pageY: 200
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (pageX/pageY case)");
+    deepEqual(pos.y, 200, "y Position (pageX/pageY case)");
+
+    //changedTouches
+    pos = click._getPos({
+        originalEvent: {
+            changedTouches: [
+                {
+                    clientX: 100,
+                    clientY: 200
+                }
+            ]
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (changedTouches)");
+    deepEqual(pos.y, 200, "y Position (changedTouches)");
+
+    //clientX
+    pos = click._getPos({
+        originalEvent: {
+            clientX: 100,
+            clientY: 200
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (changedTouches)");
+    deepEqual(pos.y, 200, "y Position (changedTouches)");
+});
+
+test("Standard Click Event (Browser w/ Mouse)", function() {
+    click({
+        '#button': testCallback
+    });
+
+    $('#button').click();
+    ok(testCallback.called);
+});
+
+test("Two arguments (not object configuration)", function() {
+    click('#button', testCallback);
+
+    $('#button').click();
+    ok(testCallback.called);
+});
+
+/*** Touch Tests ***/
+var $button,
+    eStart,
+    eEnd;
+
+module("Touch Click", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+        testCallback    = sinon.spy();
+
+        click.isTouch = true; //Fake touch
+
+        $button = $('#button');
+
+        click({
+            '#button': testCallback
+        });
+
+        eStart = $.Event('touchstart');
+        eStart.originalEvent = {
+            pageX: 1,
+            pageY: 1
+        };
+
+        eEnd = $.Event('touchend');
+        eEnd.originalEvent = {
+            pageX: 1,
+            pageY: 1
+        };
+    },
+    teardown: function() {
+        click.unbindAll();
+        click.isTouch = false;
+    }
+});
+
+asyncTest("Successful Touch Click", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(testCallback.called);
+        start();
+    }, 10);
+});
+
+asyncTest("Distance Fail", function() {
+    eEnd.originalEvent = {
+        pageX: click.distanceLimit,
+        pageY: click.distanceLimit
+    };
+
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, 10);
+});
+
+asyncTest("Timeout Fail", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, click.timeLimit + 1);
+});
+
+asyncTest("Different Element Fail", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $('body').trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, 10);
+});
+
+
+},{"../src/onClick":21,"sinon":5}]},{},[22])
\ No newline at end of file
diff --git a/node_modules/onclick/test/index.html b/node_modules/onclick/test/index.html
new file mode 100755
index 000000000..3e56cd32a
--- /dev/null
+++ b/node_modules/onclick/test/index.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>QUnit Example</title>
+        <link rel="stylesheet" href="../node_modules/qunitjs/qunit/qunit.css">
+    </head>
+    <body>
+        <div id="sandbox">
+            <button id='button'>Click Me</button>
+        </div>
+
+        <div id="qunit"></div>
+        <div id="qunit-fixture"></div>
+
+        <script src="../node_modules/qunitjs/qunit/qunit.js"></script>
+        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+        <script src="build.js"></script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/node_modules/onclick/test/test.js b/node_modules/onclick/test/test.js
new file mode 100755
index 000000000..d695b5da5
--- /dev/null
+++ b/node_modules/onclick/test/test.js
@@ -0,0 +1,198 @@
+var sinon = require('sinon'),
+    click = require('../src/onClick'),
+    module = window.module,
+    sandbox,
+    testCallback;
+
+module("onClick", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+        testCallback    = sinon.spy();
+    },
+    teardown: function() {
+        click.unbindAll();
+    }
+});
+
+test("#trigger", function() {
+    click({
+        '#button': testCallback
+    });
+
+    click.trigger('#button');
+    ok(testCallback.called);
+});
+
+test("#unbindAll", function() {
+    click({
+        '#button': testCallback
+    })
+        .unbindAll()
+        .trigger('#button');
+
+    ok(!testCallback.called);
+});
+
+test("#bind object syntax", function() {
+    click
+        .bind({
+            '#button': testCallback
+        })
+        .trigger('#button');
+
+    ok(testCallback.called);
+});
+
+test("#bind argument syntax", function() {
+    click
+        .bind('#button', testCallback)
+        .trigger('#button');
+
+    ok(testCallback.called);
+});
+
+test("#unbind", function() {
+    click
+        .bind('#button', testCallback)
+        .unbind('#button')
+        .trigger('#button');
+
+    ok(!testCallback.called);
+});
+
+test("#_getPos", function() {
+    //pageX/pageY
+    var pos = click._getPos({
+        originalEvent: {
+            pageX: 100,
+            pageY: 200
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (pageX/pageY case)");
+    deepEqual(pos.y, 200, "y Position (pageX/pageY case)");
+
+    //changedTouches
+    pos = click._getPos({
+        originalEvent: {
+            changedTouches: [
+                {
+                    clientX: 100,
+                    clientY: 200
+                }
+            ]
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (changedTouches)");
+    deepEqual(pos.y, 200, "y Position (changedTouches)");
+
+    //clientX
+    pos = click._getPos({
+        originalEvent: {
+            clientX: 100,
+            clientY: 200
+        }
+    });
+
+    deepEqual(pos.x, 100, "x Position (changedTouches)");
+    deepEqual(pos.y, 200, "y Position (changedTouches)");
+});
+
+test("Standard Click Event (Browser w/ Mouse)", function() {
+    click({
+        '#button': testCallback
+    });
+
+    $('#button').click();
+    ok(testCallback.called);
+});
+
+test("Two arguments (not object configuration)", function() {
+    click('#button', testCallback);
+
+    $('#button').click();
+    ok(testCallback.called);
+});
+
+/*** Touch Tests ***/
+var $button,
+    eStart,
+    eEnd;
+
+module("Touch Click", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+        testCallback    = sinon.spy();
+
+        click.isTouch = true; //Fake touch
+
+        $button = $('#button');
+
+        click({
+            '#button': testCallback
+        });
+
+        eStart = $.Event('touchstart');
+        eStart.originalEvent = {
+            pageX: 1,
+            pageY: 1
+        };
+
+        eEnd = $.Event('touchend');
+        eEnd.originalEvent = {
+            pageX: 1,
+            pageY: 1
+        };
+    },
+    teardown: function() {
+        click.unbindAll();
+        click.isTouch = false;
+    }
+});
+
+asyncTest("Successful Touch Click", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(testCallback.called);
+        start();
+    }, 10);
+});
+
+asyncTest("Distance Fail", function() {
+    eEnd.originalEvent = {
+        pageX: click.distanceLimit,
+        pageY: click.distanceLimit
+    };
+
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, 10);
+});
+
+asyncTest("Timeout Fail", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $button.trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, click.timeLimit + 1);
+});
+
+asyncTest("Different Element Fail", function() {
+    $button.trigger(eStart);
+
+    setTimeout(function() {
+        $('body').trigger(eEnd);
+        ok(!testCallback.called, "Distance Fail");
+        start();
+    }, 10);
+});
+
diff --git a/node_modules/onscroll/.npmignore b/node_modules/onscroll/.npmignore
new file mode 100755
index 000000000..69fd427f4
--- /dev/null
+++ b/node_modules/onscroll/.npmignore
@@ -0,0 +1,43 @@
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Node Stuff #
+##############
+node_modules/
+
+
diff --git a/node_modules/onscroll/.travis.yml b/node_modules/onscroll/.travis.yml
new file mode 100644
index 000000000..eb8ff8b24
--- /dev/null
+++ b/node_modules/onscroll/.travis.yml
@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.8"
+before_script: 
+  - npm install grunt-cli -g
diff --git a/node_modules/onscroll/Gruntfile.js b/node_modules/onscroll/Gruntfile.js
new file mode 100755
index 000000000..ca09a238a
--- /dev/null
+++ b/node_modules/onscroll/Gruntfile.js
@@ -0,0 +1,71 @@
+module.exports = function(grunt) {
+    grunt.initConfig({
+        pkg: grunt.file.readJSON('package.json'),
+        browserify: {
+            dist: {
+                files: {
+                    'dist/lib.js':          ['onScroll.js'],
+                    'examples/build.js':    ['examples/example.js']
+                },
+                options: {
+                    //standalone: '',
+                    transform: ['grunt-less-browserify']
+                }
+            },
+            test: {
+                files: {
+                    'test/build.js': ['test/test.js']
+                },
+                options: {
+                    transform: ['grunt-less-browserify'],
+                    debug:     true
+                }
+            }
+        },
+        watch: {
+            files: [ "onScroll.js", "examples/example.js"],
+            tasks: [ 'browserify:dist' ]
+        },
+        jshint: {
+            options: {
+                curly:  true,
+                eqeqeq: true,
+                eqnull: true,
+                browser: true
+            },
+            uses_defaults: ['src/**/*.js']
+        },
+        uglify: {
+            dist: {
+                files: {
+                    'dist/lib.min.js': ['dist/lib.js']
+                },
+                options: {
+                    sourceMap: true
+                }
+            }
+        },
+        qunit: {
+            files: ['test/index.html']
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-browserify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-contrib-qunit');
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+    grunt.loadNpmTasks('grunt-contrib-jshint');
+
+    grunt.registerTask('test', [
+        'browserify:test',
+        'qunit',
+        'jshint'
+    ]);
+
+    grunt.registerTask('build', [
+        'test',
+        'browserify:dist',
+        'uglify'
+    ]);
+};
+
diff --git a/node_modules/onscroll/README.md b/node_modules/onscroll/README.md
new file mode 100755
index 000000000..71b78c4e3
--- /dev/null
+++ b/node_modules/onscroll/README.md
@@ -0,0 +1,18 @@
+onScroll
+========
+
+A scroll binding library with mobile support.
+
+Usage
+-----
+
+Installation `npm install onscroll`
+
+Development
+-----------
+
+To Build: `grunt build`
+
+To Develop: `grunt watch`
+
+To Test: `npm test`
diff --git a/node_modules/onscroll/dist/lib.js b/node_modules/onscroll/dist/lib.js
new file mode 100644
index 000000000..c8aff262b
--- /dev/null
+++ b/node_modules/onscroll/dist/lib.js
@@ -0,0 +1,51 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (global){
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],2:[function(require,module,exports){
+var $ = require('unopinionate').selector;
+
+var bodyScrollers = [];
+
+$(function() {
+    var $html = $('html'),
+        $body = $('body');
+
+    $(window, document, 'body').bind('scroll touchmove', function() {
+        var top = $html[0].scrollTop || $body[0].scrollTop;
+
+        for(var i=0; i<bodyScrollers.length; i++) {
+            bodyScrollers[i](top);
+        }
+    });
+});
+
+var onScroll = function(callback) {
+    bodyScrollers.push(callback);
+};
+
+module.exports = onScroll;
+},{"unopinionate":1}]},{},[2])
\ No newline at end of file
diff --git a/node_modules/onscroll/examples/build.js b/node_modules/onscroll/examples/build.js
new file mode 100644
index 000000000..cc4bf30cf
--- /dev/null
+++ b/node_modules/onscroll/examples/build.js
@@ -0,0 +1,57 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+var onScroll = require("../onScroll.js");
+
+onScroll(function(top) {
+    console.log('Body Scroll: ' + top);
+});
+},{"../onScroll.js":3}],2:[function(require,module,exports){
+(function (global){
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],3:[function(require,module,exports){
+var $ = require('unopinionate').selector;
+
+var bodyScrollers = [];
+
+$(function() {
+    var $html = $('html'),
+        $body = $('body');
+
+    $(window, document, 'body').bind('scroll touchmove', function() {
+        var top = $html[0].scrollTop || $body[0].scrollTop;
+
+        for(var i=0; i<bodyScrollers.length; i++) {
+            bodyScrollers[i](top);
+        }
+    });
+});
+
+var onScroll = function(callback) {
+    bodyScrollers.push(callback);
+};
+
+module.exports = onScroll;
+},{"unopinionate":2}]},{},[1])
\ No newline at end of file
diff --git a/node_modules/onscroll/examples/example.css b/node_modules/onscroll/examples/example.css
new file mode 100755
index 000000000..a65e15d1b
--- /dev/null
+++ b/node_modules/onscroll/examples/example.css
@@ -0,0 +1,4 @@
+body {
+    font-family: Avenir, "Helvetica Neue", Helvetica, sans-serif;
+    height: 2000px;
+}
diff --git a/node_modules/onscroll/examples/example.js b/node_modules/onscroll/examples/example.js
new file mode 100755
index 000000000..44827390f
--- /dev/null
+++ b/node_modules/onscroll/examples/example.js
@@ -0,0 +1,5 @@
+var onScroll = require("../onScroll.js");
+
+onScroll(function(top) {
+    console.log('Body Scroll: ' + top);
+});
\ No newline at end of file
diff --git a/node_modules/onscroll/examples/index.html b/node_modules/onscroll/examples/index.html
new file mode 100755
index 000000000..8bbafddbc
--- /dev/null
+++ b/node_modules/onscroll/examples/index.html
@@ -0,0 +1,22 @@
+<html>
+    <head>
+        <title>Example</title>
+
+        <!-- Prevent Mobile Zooming -->
+        <meta content='True' name='HandheldFriendly' />
+        <meta name="apple-mobile-web-app-capable" content="yes" />
+        <meta name="viewport" content="width=device-width, minimum-scale=1.0, maximum-scale=1.0, initial-scale=1.0, user-scalable=no">
+        
+        <!-- Prevent Tap Highlight on Windows 8 -->
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="msapplication-tap-highlight" content="no"/>
+        
+        <link rel="stylesheet" type="text/css" href="example.css">
+    </head>
+
+    <body>
+        <h1>Scroll Me and Watch Your Console</h1>
+        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+        <script src="build.js"></script>
+    </body>
+</html>
diff --git a/node_modules/onscroll/onScroll.js b/node_modules/onscroll/onScroll.js
new file mode 100755
index 000000000..9382f19bc
--- /dev/null
+++ b/node_modules/onscroll/onScroll.js
@@ -0,0 +1,22 @@
+var $ = require('unopinionate').selector;
+
+var bodyScrollers = [];
+
+$(function() {
+    var $html = $('html'),
+        $body = $('body');
+
+    $(window, document, 'body').bind('scroll touchmove', function() {
+        var top = $html[0].scrollTop || $body[0].scrollTop;
+
+        for(var i=0; i<bodyScrollers.length; i++) {
+            bodyScrollers[i](top);
+        }
+    });
+});
+
+var onScroll = function(callback) {
+    bodyScrollers.push(callback);
+};
+
+module.exports = onScroll;
\ No newline at end of file
diff --git a/node_modules/onscroll/package.json b/node_modules/onscroll/package.json
new file mode 100755
index 000000000..5423dd558
--- /dev/null
+++ b/node_modules/onscroll/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "onscroll",
+  "description": "A scroll event binding with mobile support.",
+  "version": "0.0.3",
+  "author": {
+    "name": "Brian Peacock"
+  },
+  "main": "onScroll.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bpeacock/onScroll"
+  },
+  "dependencies": {
+    "unopinionate": "0.0.x"
+  },
+  "devDependencies": {
+    "grunt": "~0.4.2",
+    "grunt-contrib-watch": "0.5.x",
+    "grunt-browserify": "1.3.x",
+    "grunt-less-browserify": "0.0.x",
+    "grunt-contrib-jshint": "0.8.x",
+    "grunt-contrib-uglify": "0.3.x",
+    "grunt-contrib-qunit": "~0.4.0",
+    "qunitjs": "~1.14.0",
+    "sinon": "~1.8.2"
+  },
+  "license": "MIT",
+  "keywords": [
+    "scroll",
+    "on3"
+  ],
+  "scripts": {
+    "test": "grunt test"
+  },
+  "readme": "onScroll\n========\n\nA scroll binding library with mobile support.\n\nUsage\n-----\n\nInstallation `npm install onscroll`\n\nDevelopment\n-----------\n\nTo Build: `grunt build`\n\nTo Develop: `grunt watch`\n\nTo Test: `npm test`\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/bpeacock/onScroll/issues"
+  },
+  "homepage": "https://github.com/bpeacock/onScroll",
+  "_id": "onscroll@0.0.3",
+  "_shasum": "7d01d9fa0ccca34ac3599c5011942289807bfec3",
+  "_from": "onscroll@>=0.0.3 <1.0.0-0",
+  "_resolved": "https://registry.npmjs.org/onscroll/-/onscroll-0.0.3.tgz"
+}
diff --git a/node_modules/onscroll/test/index.html b/node_modules/onscroll/test/index.html
new file mode 100755
index 000000000..dbf61cd33
--- /dev/null
+++ b/node_modules/onscroll/test/index.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>QUnit Example</title>
+        <link rel="stylesheet" href="../node_modules/qunitjs/qunit/qunit.css">
+    </head>
+    <body>
+        <div id="qunit"></div>
+        <div id="qunit-fixture"></div>
+
+        <script src="../node_modules/qunitjs/qunit/qunit.js"></script>
+        <script src="build.js"></script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/node_modules/onscroll/test/test.js b/node_modules/onscroll/test/test.js
new file mode 100644
index 000000000..c51ca6f41
--- /dev/null
+++ b/node_modules/onscroll/test/test.js
@@ -0,0 +1,17 @@
+var sinon = require('sinon'),
+    module = window.module,
+    sandbox;
+
+module("onClick", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+
+    },
+    teardown: function() {
+        
+    }
+});
+
+test('sample', function() {
+    ok(true);
+});
diff --git a/node_modules/sinopia-htpasswd/.editorconfig b/node_modules/sinopia-htpasswd/.editorconfig
new file mode 100644
index 000000000..4a41c149d
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/.editorconfig
@@ -0,0 +1,13 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js,json}]
+indent_style = space
+indent_size = 2
+
+[Makefile]
+indent_style = tab
+
diff --git a/node_modules/sinopia-htpasswd/.npmignore b/node_modules/sinopia-htpasswd/.npmignore
new file mode 100644
index 000000000..e6c5aafa8
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/.npmignore
@@ -0,0 +1,2 @@
+node_modules
+/tests/test-htpasswd
diff --git a/node_modules/sinopia-htpasswd/.travis.yml b/node_modules/sinopia-htpasswd/.travis.yml
new file mode 100644
index 000000000..c4d4a4261
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/.travis.yml
@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - '0.10'
+  - '0.11'
+matrix:
+  allow_failures:
+   - node_js: "0.11"
+  fast_finish: true
+script: npm install . && npm run test
diff --git a/node_modules/sinopia-htpasswd/README.md b/node_modules/sinopia-htpasswd/README.md
new file mode 100644
index 000000000..39344ad6c
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/README.md
@@ -0,0 +1,61 @@
+
+**work in progress**
+
+## Installation
+
+```sh
+$ npm install sinopia
+$ npm install sinopia-htpasswd
+```
+
+PS: Actually, this module is bundled with sinopia, so you don't have to install it like this. But with other auth plugins you have to.
+
+## Config
+
+Add to your `config.yaml`:
+
+```yaml
+auth:
+  htpasswd:
+    users_file: ./htpasswd
+
+    # Maximum amount of users allowed to register, defaults to "+inf".
+    # You can set this to 0 to disable registration.
+    #max_users: 1000
+```
+
+## For plugin writers
+
+It's called as:
+
+```js
+require('sinopia-htpasswd')(config, stuff)
+```
+
+Where:
+
+ - config - module's own config
+ - stuff - collection of different internal sinopia objects
+   - stuff.config - main config
+   - stuff.logger - logger
+
+This should export two functions:
+
+ - `adduser(user, password, cb)`
+   
+   It should respond with:
+    - `cb(err)` in case of an error (error will be returned to user)
+    - `cb(null, false)` in case registration is disabled (next auth plugin will be executed)
+    - `cb(null, true)` in case user registered successfully
+   
+   It's useful to set `err.status` property to set http status code (e.g. `err.status = 403`).
+
+ - `authenticate(user, password, cb)`
+   
+   It should respond with:
+    - `cb(err)` in case of a fatal error (error will be returned to user, keep those rare)
+    - `cb(null, false)` in case user not authenticated (next auth plugin will be executed)
+    - `cb(null, [groups])` in case user is authenticated
+   
+   Groups is an array of all users/usergroups this user has access to. You should probably include username itself here.
+   
diff --git a/node_modules/sinopia-htpasswd/index.js b/node_modules/sinopia-htpasswd/index.js
new file mode 100644
index 000000000..e9816295f
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/index.js
@@ -0,0 +1,123 @@
+var fs = require('fs')
+var Path = require('path')
+var utils = require('./utils')
+
+module.exports = HTPasswd
+
+function HTPasswd(config, stuff) {
+  var self = Object.create(HTPasswd.prototype)
+  self._users = {}
+
+  // config for this module
+  self._config = config
+
+  // sinopia logger
+  self._logger = stuff.logger
+
+  // sinopia main config object
+  self._sinopia_config = stuff.config
+
+  // all this "sinopia_config" stuff is for b/w compatibility only
+  self._maxusers = self._config.max_users || self._sinopia_config.max_users
+
+  self._last_time = null
+  var file = self._config.file || self._sinopia_config.users_file
+  if (!file) throw new Error('should specify "file" in config')
+  self._path = Path.resolve(Path.dirname(self._sinopia_config.self_path), file)
+  return self
+}
+
+HTPasswd.prototype.authenticate = function(user, password, cb) {
+  var self = this
+  self._reload(function(err) {
+    if (err) return cb(err.code === 'ENOENT' ? null : err)
+    if (!self._users[user]) return cb(null, false)
+    if (!utils.verify_password(user, password, self._users[user])) return cb(null, false)
+
+    // authentication succeeded!
+    // return all usergroups this user has access to;
+    // (this particular package has no concept of usergroups, so just return user herself)
+    return cb(null, [user])
+  })
+}
+
+// hopefully race-condition-free way to add users:
+// 1. lock file for writing (other processes can still read)
+// 2. reload .htpasswd
+// 3. write new data into .htpasswd.tmp
+// 4. move .htpasswd.tmp to .htpasswd
+// 5. reload .htpasswd
+// 6. unlock file
+HTPasswd.prototype.adduser = function(user, password, real_cb) {
+  var self = this
+
+  function sanity_check() {
+    var err = null
+    if (self._users[user]) {
+      err = Error('this user already exists')
+    } else if (Object.keys(self._users).length >= self._maxusers) {
+      err = Error('maximum amount of users reached')
+    }
+    if (err) err.status = 403
+    return err
+  }
+
+  // preliminary checks, just to ensure that file won't be reloaded if it's not needed
+  var s_err = sanity_check()
+  if (s_err) return real_cb(s_err, false)
+
+  utils.lock_and_read(self._path, function(err, fd, res) {
+    // callback that cleanups fd first
+    function cb(err) {
+      if (!fd) return real_cb(err, !err)
+      fs.close(fd, function() {
+        real_cb(err, !err)
+      })
+    }
+
+    // ignore ENOENT errors, we'll just create .htpasswd in that case
+    if (err && err.code != 'ENOENT') return cb(err)
+
+    var body = (res || '').toString('utf8')
+    self._users = utils.parse_htpasswd(body)
+
+    // real checks, to prevent race conditions
+    var s_err = sanity_check()
+    if (s_err) return cb(s_err)
+
+    try {
+      body = utils.add_user_to_htpasswd(body, user, password)
+    } catch(err) {
+      return cb(err)
+    }
+    fs.writeFile(self._path, body, function(err) {
+      if (err) return cb(err)
+      self._reload(function() {
+        cb(null, true)
+      })
+    })
+  })
+}
+
+HTPasswd.prototype._reload = function(callback) {
+  var self = this
+
+  fs.open(self._path, 'r', function(err, fd) {
+    if (err) return callback(err)
+
+    fs.fstat(fd, function(err, st) {
+      if (err) return callback(err)
+      if (self._last_time === st.mtime) return callback()
+      self._last_time = st.mtime
+
+      var buffer = new Buffer(st.size)
+      fs.read(fd, buffer, 0, st.size, null, function(err, bytesRead, buffer) {
+        if (err) return callback(err)
+        if (bytesRead != st.size) return callback(new Error('st.size != bytesRead'))
+        self._users = utils.parse_htpasswd(buffer.toString('utf8'))
+        callback()
+      })
+    })
+  })
+}
+
diff --git a/node_modules/sinopia-htpasswd/package.json b/node_modules/sinopia-htpasswd/package.json
new file mode 100644
index 000000000..c56577d6e
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/package.json
@@ -0,0 +1,39 @@
+{
+  "name"                : "sinopia-htpasswd",
+  "version"             : "0.4.1",
+  "description"         : "auth plugin for sinopia supporting htpasswd format",
+
+  "author"              : { "name": "Alex Kocharin"
+                          , "email": "alex@kocharin.ru" },
+
+  "repository"          : { "type": "git"
+                          , "url": "git://github.com/rlidwka/sinopia-htpasswd" },
+
+  "optionalDependencies": { "crypt3": ">=0.1.5 <1.0.0-0"
+                          , "fs-ext": "*" },
+
+  "devDependencies"     : { "mocha": ">=1.17.0 <2.0.0-0" },
+
+  "scripts"             : { "test": "mocha ./tests" },
+
+  "keywords"            : [ "sinopia", "auth", "plugin", "htpasswd" ],
+
+  "publishConfig"       : { "registry": "https://registry.npmjs.org/" },
+
+  "license"             : { "type": "WTFPL"
+                          , "url": "http://www.wtfpl.net/txt/copying/" },
+  "readme"             : "\n**work in progress**\n\n## Installation\n\n```sh\n$ npm install sinopia\n$ npm install sinopia-htpasswd\n```\n\nPS: Actually, this module is bundled with sinopia, so you don't have to install it like this. But with other auth plugins you have to.\n\n## Config\n\nAdd to your `config.yaml`:\n\n```yaml\nauth:\n  htpasswd:\n    users_file: ./htpasswd\n\n    # Maximum amount of users allowed to register, defaults to \"+inf\".\n    # You can set this to 0 to disable registration.\n    #max_users: 1000\n```\n\n## For plugin writers\n\nIt's called as:\n\n```js\nrequire('sinopia-htpasswd')(config, stuff)\n```\n\nWhere:\n\n - config - module's own config\n - stuff - collection of different internal sinopia objects\n   - stuff.config - main config\n   - stuff.logger - logger\n\nThis should export two functions:\n\n - `adduser(user, password, cb)`\n   \n   It should respond with:\n    - `cb(err)` in case of an error (error will be returned to user)\n    - `cb(null, false)` in case registration is disabled (next auth plugin will be executed)\n    - `cb(null, true)` in case user registered successfully\n   \n   It's useful to set `err.status` property to set http status code (e.g. `err.status = 403`).\n\n - `authenticate(user, password, cb)`\n   \n   It should respond with:\n    - `cb(err)` in case of a fatal error (error will be returned to user, keep those rare)\n    - `cb(null, false)` in case user not authenticated (next auth plugin will be executed)\n    - `cb(null, [groups])` in case user is authenticated\n   \n   Groups is an array of all users/usergroups this user has access to. You should probably include username itself here.\n   \n",
+  "readmeFilename"             : "README.md",
+  "bugs"             : {
+    "url": "https://github.com/rlidwka/sinopia-htpasswd/issues"
+  },
+  "homepage"             : "https://github.com/rlidwka/sinopia-htpasswd",
+  "dependencies"             : {
+    "crypt3": ">=0.1.5 <1.0.0-0",
+    "fs-ext": "*"
+  },
+  "_id"             : "sinopia-htpasswd@0.4.1",
+  "_shasum"             : "f76c2acf42f6153faae736f50181c819a0c6b8b0",
+  "_from"             : "sinopia-htpasswd@>= 0.2.0",
+  "_resolved"             : "https://registry.npmjs.org/sinopia-htpasswd/-/sinopia-htpasswd-0.4.1.tgz"
+}
diff --git a/node_modules/sinopia-htpasswd/tests/acceptance.js b/node_modules/sinopia-htpasswd/tests/acceptance.js
new file mode 100644
index 000000000..6a2f4eef6
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/tests/acceptance.js
@@ -0,0 +1,94 @@
+var plugin = require('../')
+var assert = require('assert')
+var stuff = {config:{self_path:__dirname+'/config'},logger:{}}
+
+describe('acc', function() {
+  before(function(cb) {
+    require('fs').unlink(__dirname + '/test-htpasswd', function() {
+      cb()
+    })
+  })
+
+  it('should have plugin interface', function() {
+    assert.equal(typeof plugin, 'function')
+    var p = plugin({file: './test-htpasswd'}, stuff)
+    assert.equal(typeof p.authenticate, 'function')
+  }) 
+
+  it('should not authenticate random user', function(cb) {
+    var p = plugin({file: './test-htpasswd'}, stuff)
+    p.authenticate('blah', 'blah', function(err, groups) {
+      assert(!err)
+      assert(!groups)
+      cb()
+    })
+  }) 
+
+  it('should add user', function(cb) {
+    var p = plugin({file: './test-htpasswd'}, stuff)
+    p.adduser('foo1', 'bar1', function(err, ok) {
+      assert(!err)
+      assert(ok)
+      cb()
+    })
+  })
+
+  describe('user', function() {
+    var p = plugin({file: './test-htpasswd'}, stuff)
+    before(function(cb) {
+      p.adduser('foo', 'bar', function(err, ok) {
+        assert(!err)
+        assert(ok)
+        cb()
+      })
+    })
+
+    it('should authenticate user', function(cb) {
+      p.authenticate('foo', 'bar', function(err, groups) {
+        assert(!err)
+        assert.deepEqual(groups, ['foo'])
+        cb()
+      })
+    })
+
+    it('should fail different pass', function(cb) {
+      p.authenticate('foo', 'bar111', function(err, groups) {
+        assert(!err)
+        assert(!groups)
+        cb()
+      })
+    })
+
+    it('should fail adding it again', function(cb) {
+      p.adduser('foo', 'bar111', function(err, ok) {
+        assert(err)
+        cb()
+      })
+    })
+
+    it('still should not authenticate random user', function(cb) {
+      p.authenticate('blah', 'wow', function(err, groups) {
+        assert(!err)
+        assert(!groups)
+        cb()
+      })
+    }) 
+  })
+
+  describe('max_users', function() {
+    var p = plugin({file: './test-htpasswd', max_users: 1}, stuff)
+    before(function(cb) {
+      p.adduser('foo', 'bar', function(err, ok) {
+        cb()
+      })
+    })
+
+    it('should not add more users', function(cb) {
+      p.adduser('foozzz', 'bar', function(err) {
+        assert(err)
+        cb()
+      })
+    })
+  })
+})
+
diff --git a/node_modules/sinopia-htpasswd/tests/htpasswd.js b/node_modules/sinopia-htpasswd/tests/htpasswd.js
new file mode 100644
index 000000000..3e880d36c
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/tests/htpasswd.js
@@ -0,0 +1,56 @@
+var assert = require('assert')
+  , parse_htpasswd = require('../utils').parse_htpasswd
+  , verify_password = require('../utils').verify_password
+  , add_user_to_htpasswd = require('../utils').add_user_to_htpasswd
+
+describe('parse_htpasswd', function() {
+  // TODO
+})
+
+describe('verify_password', function() {
+  it('should verify plain', function() {
+    assert(verify_password('user', 'pass', '{PLAIN}pass'))
+    assert(!verify_password('user', 'p', '{PLAIN}pass'))
+  })
+  it('should verify sha', function() {
+    assert(verify_password('user', 'pass', '{SHA}nU4eI71bcnBGqeO0t9tXvY1u5oQ='))
+    assert(!verify_password('user', 'p', '{SHA}nU4eI71bcnBGqeO0t9tXvY1u5oQ='))
+  })
+  it('should verify crypt', function() {
+    assert(verify_password('user', 'pass', 'ulINxGnqObi36'))
+    assert(!verify_password('user', 'p', 'ulINxGnqObi36'))
+  })
+  it('should verify crypt-sha', function() {
+    assert(verify_password('user', 'pass', '$6$Qx0eNSKPbxocgA==$ugjO0.z9yOFiaJXJK4ulvGYIxF/KZBV4lGqasArYPqPPT4orZ6NlnIE5KhtiOVs.5EoWxLg1sjp318G8RpI2x1'))
+    assert(!verify_password('user', 'p', '$6$Qx0eNSKPbxocgA==$ugjO0.z9yOFiaJXJK4ulvGYIxF/KZBV4lGqasArYPqPPT4orZ6NlnIE5KhtiOVs.5EoWxLg1sjp318G8RpI2x1'))
+  })
+})
+
+describe('add_user_to_htpasswd', function() {
+  it('should add user to empty file', function() {
+    var res = add_user_to_htpasswd('', 'user', 'passwd')
+    assert(res.match(/^user:[^:\n]+:autocreated [^\n]+\n$/))
+  })
+
+  it('should append user / newline checks', function() {
+    var res = add_user_to_htpasswd('testtest', 'user', 'passwd')
+    assert(res.match(/^testtest\nuser:[^:\n]+:autocreated [^\n]+\n$/))
+    var res = add_user_to_htpasswd('testtest\n', 'user', 'passwd')
+    assert(res.match(/^testtest\nuser:[^:\n]+:autocreated [^\n]+\n$/))
+    var res = add_user_to_htpasswd('testtest\n\n', 'user', 'passwd')
+    assert(res.match(/^testtest\n\nuser:[^:\n]+:autocreated [^\n]+\n$/))
+  })
+
+  it('should not append invalid users', function() {
+    assert.throws(function() {
+      add_user_to_htpasswd('', 'us:er', 'passwd')
+    }, /non-uri-safe/)
+    assert.throws(function() {
+      add_user_to_htpasswd('', 'us\ner', 'passwd')
+    }, /non-uri-safe/)
+    assert.throws(function() {
+      add_user_to_htpasswd('', 'us#er', 'passwd')
+    }, /non-uri-safe/)
+  })
+})
+
diff --git a/node_modules/sinopia-htpasswd/utils.js b/node_modules/sinopia-htpasswd/utils.js
new file mode 100644
index 000000000..9f2984c9c
--- /dev/null
+++ b/node_modules/sinopia-htpasswd/utils.js
@@ -0,0 +1,108 @@
+var crypto = require('crypto')
+var fs = require('fs')
+
+try {
+  // optional, won't be available on windows
+  var crypt3 = require('crypt3')
+} catch(err) {
+  crypt3 = function() {
+    return NaN
+  }
+}
+
+try {
+  var fsExt = require('fs-ext')
+} catch(e) {
+  fsExt = {
+    flock: function() {
+      arguments[arguments.length-1]()
+    }
+  }
+}
+
+// open and flock with exponential backoff
+function open_flock(name, opmod, flmod, tries, backoff, cb) {
+	fs.open(name, opmod, function(err, fd) {
+		if (err) return cb(err, fd)
+
+		fsExt.flock(fd, flmod, function(err) {
+			if (err) {
+				if (!tries) {
+					fs.close(fd, function() {
+						cb(err)
+					})
+				} else {
+					fs.close(fd, function() {
+						setTimeout(function() {
+							open_flock(name, opmod, flmod, tries-1, backoff*2, cb)
+						}, backoff)
+					})
+				}
+			} else {
+				cb(null, fd)
+			}
+		})
+	})
+}
+
+// this function neither unlocks file nor closes it
+// it'll have to be done manually later
+function lock_and_read(name, callback) {
+  open_flock(name, 'r', 'exnb', 4, 10, function(err, fd) {
+    if (err) return callback(err, fd)
+
+    fs.fstat(fd, function(err, st) {
+      if (err) return callback(err, fd)
+
+      var buffer = new Buffer(st.size)
+      fs.read(fd, buffer, 0, st.size, null, function(err, bytesRead, buffer) {
+        if (err) return callback(err)
+        if (bytesRead != st.size) return callback(new Error('st.size != bytesRead'), fd)
+
+        callback(null, fd, buffer)
+      })
+    })
+  })
+}
+
+function parse_htpasswd(input) {
+  var result = {}
+  input.split('\n').forEach(function(line) {
+    var args = line.split(':', 3)
+    if (args.length > 1) result[args[0]] = args[1]
+  })
+  return result
+}
+
+function verify_password(user, passwd, hash) {
+  if (hash.indexOf('{PLAIN}') === 0) {
+    return passwd === hash.substr(7)
+  } else if (hash.indexOf('{SHA}') === 0) {
+    return crypto.createHash('sha1').update(passwd, 'binary').digest('base64') === hash.substr(5)
+  } else {
+    return crypt3(passwd, hash) === hash
+  }
+}
+
+function add_user_to_htpasswd(body, user, passwd) {
+  if (user != encodeURIComponent(user)) {
+    var err = Error("username shouldn't contain non-uri-safe characters")
+    err.status = 409
+    throw err
+  }
+
+  passwd = crypt3(passwd)
+  if (!passwd) {
+    passwd = '{SHA}' + crypto.createHash('sha1').update(passwd, 'binary').digest('base64')
+  }
+  var comment = 'autocreated ' + (new Date()).toJSON()
+
+  var newline = user + ':' + passwd + ':' + comment + '\n'
+  if (body.length && body[body.length-1] != '\n') newline = '\n' + newline
+  return body + newline
+}
+
+module.exports.parse_htpasswd = parse_htpasswd
+module.exports.verify_password = verify_password
+module.exports.add_user_to_htpasswd = add_user_to_htpasswd
+module.exports.lock_and_read = lock_and_read
diff --git a/node_modules/tar.gz/.npmignore b/node_modules/tar.gz/.npmignore
new file mode 100644
index 000000000..80da007c7
--- /dev/null
+++ b/node_modules/tar.gz/.npmignore
@@ -0,0 +1,3 @@
+/*.sublime-workspace
+/*.sublime-project
+/node_modules
diff --git a/node_modules/tar.gz/Cakefile b/node_modules/tar.gz/Cakefile
new file mode 100644
index 000000000..bb955f07a
--- /dev/null
+++ b/node_modules/tar.gz/Cakefile
@@ -0,0 +1,75 @@
+# Basic Cakefile for project automation
+# 
+# @author Alan Hoffmeister <alan@cranic.com.br>
+# @version 0.0.1
+# @date 2012-12-06 128:41 GMT -3:00
+# @license MIT <http://en.wikipedia.org/wiki/MIT_License#License_terms>
+
+util = require 'util'
+walker = require 'walk'
+wrench = require 'wrench'
+exec = require('child_process').exec
+fs = require 'fs'
+
+options = 
+    source : __dirname + '/src'
+    target : __dirname + '/lib'
+    convert :
+        'coffee' : 'coffee -b --compile --output "{targetDir}" "{sourceFile}"'
+    blacklist : ['log']
+    watch :
+        'coffee' : 'coffee -b --compile --output "{targetDir}" "{sourceFile}"'
+
+totals =
+    converted : 0
+    deleted : 0
+    total : 0
+    watched : 0
+
+replace = (str, root, name) ->
+    str.replace('{sourceFile}', "#{root}/#{name}").replace('{targetDir}', root);
+
+task 'build', 'Main build task', ->
+    util.log "Build started at #{options.source}"
+    util.log "Cleaning up the target directory #{options.target}"
+    wrench.rmdirSyncRecursive options.target, true
+    util.log 'Creating empty target folder.'
+    wrench.mkdirSyncRecursive options.target, '0777'
+    util.log 'Coping files from source to target.'
+    wrench.copyDirSyncRecursive options.source, options.target
+    util.log 'Starting to convert files.'
+    walk = walker.walk options.target, followLinks: false
+    walk.on 'file', (root, stat, next) ->
+        totals.total++
+        extension = stat.name.split('.').pop()
+        if options.blacklist.indexOf(extension) != -1
+            fs.unlinkSync "#{root}/#{stat.name}"
+            util.log "Removing by blacklist: #{root}/#{stat.name}"
+            totals.deleted++
+            next()
+        else if options.convert[extension]
+            util.log "Converting #{root}/#{stat.name}"
+            exec replace(options.convert[extension], root, stat.name), (err, stdout, stderr) ->
+                throw err if err
+                fs.unlinkSync "#{root}/#{stat.name}"
+                totals.converted++
+                next()
+
+    walk.on 'end', ->
+        util.log "Build script ended. #{totals.total} files copyed, #{totals.deleted} deleted and #{totals.converted} converted."
+
+task 'watch', 'Watch for filechanges.', ->
+    util.log "Watching files in #{options.source}"
+    walk = walker.walk options.source, followLinks: false
+    walk.on 'file', (root, stat, next) ->
+        extension = stat.name.split('.').pop()
+        if options.watch[extension]
+            totals.watched++
+            util.log "Watching #{root}/#{stat.name}"
+            fs.watchFile "#{root}/#{stat.name}", (curt, pret) ->
+                util.log "File changed: #{root}/#{stat.name}"
+                exec 'cake build', (err, stdout, stderr) ->
+                    throw err if err           
+        next()
+    walk.on 'end', ->
+        util.log "Watching #{totals.watched} files."
\ No newline at end of file
diff --git a/node_modules/tar.gz/LICENSE b/node_modules/tar.gz/LICENSE
new file mode 100644
index 000000000..233454021
--- /dev/null
+++ b/node_modules/tar.gz/LICENSE
@@ -0,0 +1,20 @@
+Copyright (C) 2012 Cranic Tecnologia e Informática LTDA
+
+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.
\ No newline at end of file
diff --git a/node_modules/tar.gz/README.md b/node_modules/tar.gz/README.md
new file mode 100644
index 000000000..695bfbcd4
--- /dev/null
+++ b/node_modules/tar.gz/README.md
@@ -0,0 +1,103 @@
+# **node-tar.gz**
+Native gzip compression and decompression utility for Node.js.
+
+### **Installation**
+
+For simple installation:
+
+    npm install tar.gz
+
+If you want to use the `targz` command line:
+
+    npm intall -g tar.gz
+
+### **Usage**
+
+At the moment this package can only compress a folder and everything that
+is inside it. To compress something is easy:
+
+    var targz = require('tar.gz');
+    var compress = new targz().compress('/path/to/compress', '/path/to/store.tar.gz', function(err){
+        if(err)
+            console.log(err);
+
+        console.log('The compression has ended!');
+    });
+
+With the same easy you can extract a gziped file:
+
+    var targz = require('tar.gz');
+    var compress = new targz().extract('/path/to/stored.tar.gz', '/path/to/extract', function(err){
+        if(err)
+            console.log(err);
+
+        console.log('The extraction has ended!');
+    });
+
+You can pass some configuration parameters to the constructor before compress:
+
+    var targz = require('tar.gz');
+
+    var level = 6 //the compression level from 0-9, default: 6
+    var memLevel = 6 //the memory allocation level from 1-9, default: 6
+    var proprietary = true //to include or not proprietary headers, default: true
+
+    var compress = new targz(level, memLevel, proprietary).compress(...)
+
+### **Command line**
+
+    $ targz -h
+
+      Usage: targz [options]
+
+      Options:
+
+        -h, --help           output usage information
+        -V, --version        output the version number
+        -c, --compress       Compress folder to archive
+        -x, --extract        Extract archive to folder
+        -l, --level [n]      Compression level from 0-9. Default 6.
+        -m, --memory [n]     Memory allocation level from 1-9. Default 6.
+        -n, --noproprietary  Remove proprietary headers.
+
+      Examples:
+
+        Default compression
+        $ targz -c /folder/to/compres /path/to/archive.tar.gz
+
+        Extracting some archive
+        $ targz -x /path/to/archive.tar.gz /destination/folder
+
+        Maximum compression
+        $ targz -l 9 -m 9 -c /folder/to/compres /path/to/archive.tar.gz
+
+
+### **TODO**
+
+ * Vows.js tests
+ * Single file compression
+ * Add more todos...
+
+
+### **License (MIT)**
+
+Copyright (C) 2012 Cranic Tecnologia e Informática LTDA
+
+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.
\ No newline at end of file
diff --git a/node_modules/tar.gz/bin/targz b/node_modules/tar.gz/bin/targz
new file mode 100755
index 000000000..1f9992c1c
--- /dev/null
+++ b/node_modules/tar.gz/bin/targz
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+var compress, level, memLevel, program, proprietary, targz;
+
+targz = require('../lib/targz');
+
+program = require('commander');
+
+program.version('0.0.1').option('-c, --compress', 'Compress folder to archive').option('-x, --extract', 'Extract archive to folder').option('-l, --level [n]', 'Compression level from 0-9. Default 6.', parseInt).option('-m, --memory [n]', 'Memory allocation level from 1-9. Default 6.', parseInt).option('-n, --noproprietary', 'Remove proprietary headers.');
+
+program.on('--help', function() {
+  console.log('  Examples:');
+  console.log('');
+  console.log('    Default compression');
+  console.log('    $ targz -c /folder/to/compres /path/to/archive.tar.gz');
+  console.log('');
+  console.log('    Extracting some archive');
+  console.log('    $ targz -x /path/to/archive.tar.gz /destination/folder');
+  console.log('');
+  console.log('    Maximum compression');
+  console.log('    $ targz -l 9 -m 9 -c /folder/to/compres /path/to/archive.tar.gz');
+  return console.log('');
+});
+
+program.parse(process.argv);
+
+if (program.level) {
+  level = program.level;
+} else {
+  level = 6;
+}
+
+if (program.memory) {
+  memLevel = program.memory;
+} else {
+  memLevel = 6;
+}
+
+if (program.noproprietary) {
+  proprietary = false;
+} else {
+  proprietary = true;
+}
+
+if (program.compress) {
+  console.log('Compressing...');
+  compress = new targz(level, memLevel, proprietary).compress(program.args[0], program.args[1], function() {
+    return console.log('Done!');
+  });
+} else if (program.extract) {
+  console.log('Extracting...');
+  compress = new targz().extract(program.args[0], program.args[1], function() {
+    return console.log('Done!');
+  });
+}
diff --git a/node_modules/tar.gz/example/example.coffee b/node_modules/tar.gz/example/example.coffee
new file mode 100644
index 000000000..a084e9544
--- /dev/null
+++ b/node_modules/tar.gz/example/example.coffee
@@ -0,0 +1,10 @@
+targz = require '../index'
+gzip = new targz()
+
+# Compressing this folder
+gzip.compress __dirname + '/../test/compress', __dirname + '/../test/compress.tar.gz', (err) ->
+    console.log 'Done compressing'
+    
+    # Extracting a tar.gz file
+    gzip.extract __dirname + '/../test/compress.tar.gz', __dirname + '/../test/extract/', (err) ->
+        console.log 'Done extracting.'
\ No newline at end of file
diff --git a/node_modules/tar.gz/example/example.js b/node_modules/tar.gz/example/example.js
new file mode 100644
index 000000000..9c5a74ed0
--- /dev/null
+++ b/node_modules/tar.gz/example/example.js
@@ -0,0 +1,10 @@
+var gzip, targz;
+targz = require('../index');
+gzip = new targz();
+
+gzip.compress(__dirname + '/../test/compress', __dirname + '/../test/compress.tar.gz', function(err) {
+    console.log('Done compressing');
+    return gzip.extract(__dirname + '/../test/compress.tar.gz', __dirname + '/../test/extract/', function(err) {
+        return console.log('Done extracting.');
+    });
+});
\ No newline at end of file
diff --git a/node_modules/tar.gz/lib/targz.js b/node_modules/tar.gz/lib/targz.js
new file mode 100644
index 000000000..31ee8bb26
--- /dev/null
+++ b/node_modules/tar.gz/lib/targz.js
@@ -0,0 +1,82 @@
+// Generated by CoffeeScript 1.4.0
+var TarGz, fs, fstream, tar, zlib;
+
+fstream = require('fstream');
+
+tar = require('tar');
+
+zlib = require('zlib');
+
+fs = require('fs');
+
+TarGz = (function() {
+
+  function TarGz(level, memLevel, proprietary) {
+    this.level = level != null ? level : 6;
+    this.memLevel = memLevel != null ? memLevel : 6;
+    this.proprietary = proprietary != null ? proprietary : true;
+    this;
+
+  }
+
+  TarGz.prototype.compress = function(source, destination, callback) {
+    var self;
+    self = this;
+    fs.stat(source, function(err, stat) {
+      var type;
+      type = 'Directory';
+      return process.nextTick(function() {
+        var gzip, props, reader;
+        gzip = zlib.createGzip({
+          level: self.level,
+          memLevel: self.memLevel
+        });
+        if (type === 'Directory') {
+          reader = fstream.Reader({
+            path: source,
+            type: type
+          });
+        }
+        if (self.proprietary === true) {
+          props = {
+            noProprietary: false
+          };
+        }
+        if (self.proprietary === false) {
+          props = {
+            noProprietary: true
+          };
+        }
+        return reader.pipe(tar.Pack(props)).pipe(gzip).pipe(fstream.Writer(destination).on('close', function() {
+          if (typeof callback === 'function') {
+            return callback(null);
+          }
+        }));
+      });
+    });
+    return this;
+  };
+
+  TarGz.prototype.extract = function(source, destination, callback) {
+    var self;
+    self = this;
+    process.nextTick(function() {
+      return fstream.Reader({
+        path: source,
+        type: 'File'
+      }).pipe(zlib.createGunzip()).pipe(tar.Extract({
+        path: destination
+      })).on('end', function() {
+        if (typeof callback === 'function') {
+          return callback(null);
+        }
+      });
+    });
+    return this;
+  };
+
+  return TarGz;
+
+})();
+
+module.exports = TarGz;
diff --git a/node_modules/tar.gz/node_modules/commander/.npmignore b/node_modules/tar.gz/node_modules/commander/.npmignore
new file mode 100644
index 000000000..f1250e584
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/.npmignore
@@ -0,0 +1,4 @@
+support
+test
+examples
+*.sock
diff --git a/node_modules/tar.gz/node_modules/commander/.travis.yml b/node_modules/tar.gz/node_modules/commander/.travis.yml
new file mode 100644
index 000000000..f1d0f13c8
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/.travis.yml
@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.6
diff --git a/node_modules/tar.gz/node_modules/commander/History.md b/node_modules/tar.gz/node_modules/commander/History.md
new file mode 100644
index 000000000..160dc6bd1
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/History.md
@@ -0,0 +1,152 @@
+
+1.1.1 / 2012-11-20 
+==================
+
+  * add more sub-command padding
+  * fix .usage() when args are present. Closes #106
+
+1.1.0 / 2012-11-16 
+==================
+
+  * add git-style executable subcommand support. Closes #94
+
+1.0.5 / 2012-10-09 
+==================
+
+  * fix `--name` clobbering. Closes #92
+  * fix examples/help. Closes #89
+
+1.0.4 / 2012-09-03 
+==================
+
+  * add `outputHelp()` method.
+
+1.0.3 / 2012-08-30 
+==================
+
+  * remove invalid .version() defaulting
+
+1.0.2 / 2012-08-24 
+==================
+
+  * add `--foo=bar` support [arv]
+  * fix password on node 0.8.8. Make backward compatible with 0.6 [focusaurus]
+
+1.0.1 / 2012-08-03 
+==================
+
+  * fix issue #56
+  * fix tty.setRawMode(mode) was moved to tty.ReadStream#setRawMode() (i.e. process.stdin.setRawMode())
+
+1.0.0 / 2012-07-05 
+==================
+
+  * add support for optional option descriptions
+  * add defaulting of `.version()` to package.json's version
+
+0.6.1 / 2012-06-01 
+==================
+
+  * Added: append (yes or no) on confirmation
+  * Added: allow node.js v0.7.x
+
+0.6.0 / 2012-04-10 
+==================
+
+  * Added `.prompt(obj, callback)` support. Closes #49
+  * Added default support to .choose(). Closes #41
+  * Fixed the choice example
+
+0.5.1 / 2011-12-20 
+==================
+
+  * Fixed `password()` for recent nodes. Closes #36
+
+0.5.0 / 2011-12-04 
+==================
+
+  * Added sub-command option support [itay]
+
+0.4.3 / 2011-12-04 
+==================
+
+  * Fixed custom help ordering. Closes #32
+
+0.4.2 / 2011-11-24 
+==================
+
+  * Added travis support
+  * Fixed: line-buffered input automatically trimmed. Closes #31
+
+0.4.1 / 2011-11-18 
+==================
+
+  * Removed listening for "close" on --help
+
+0.4.0 / 2011-11-15 
+==================
+
+  * Added support for `--`. Closes #24
+
+0.3.3 / 2011-11-14 
+==================
+
+  * Fixed: wait for close event when writing help info [Jerry Hamlet]
+
+0.3.2 / 2011-11-01 
+==================
+
+  * Fixed long flag definitions with values [felixge]
+
+0.3.1 / 2011-10-31 
+==================
+
+  * Changed `--version` short flag to `-V` from `-v`
+  * Changed `.version()` so it's configurable [felixge]
+
+0.3.0 / 2011-10-31 
+==================
+
+  * Added support for long flags only. Closes #18
+
+0.2.1 / 2011-10-24 
+==================
+
+  * "node": ">= 0.4.x < 0.7.0". Closes #20
+
+0.2.0 / 2011-09-26 
+==================
+
+  * Allow for defaults that are not just boolean. Default peassignment only occurs for --no-*, optional, and required arguments. [Jim Isaacs]
+
+0.1.0 / 2011-08-24 
+==================
+
+  * Added support for custom `--help` output
+
+0.0.5 / 2011-08-18 
+==================
+
+  * Changed: when the user enters nothing prompt for password again
+  * Fixed issue with passwords beginning with numbers [NuckChorris]
+
+0.0.4 / 2011-08-15 
+==================
+
+  * Fixed `Commander#args`
+
+0.0.3 / 2011-08-15 
+==================
+
+  * Added default option value support
+
+0.0.2 / 2011-08-15 
+==================
+
+  * Added mask support to `Command#password(str[, mask], fn)`
+  * Added `Command#password(str, fn)`
+
+0.0.1 / 2010-01-03
+==================
+
+  * Initial release
diff --git a/node_modules/tar.gz/node_modules/commander/Makefile b/node_modules/tar.gz/node_modules/commander/Makefile
new file mode 100644
index 000000000..007462553
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/Makefile
@@ -0,0 +1,7 @@
+
+TESTS = $(shell find test/test.*.js)
+
+test:
+	@./test/run $(TESTS)
+
+.PHONY: test
\ No newline at end of file
diff --git a/node_modules/tar.gz/node_modules/commander/Readme.md b/node_modules/tar.gz/node_modules/commander/Readme.md
new file mode 100644
index 000000000..f93f3622a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/Readme.md
@@ -0,0 +1,270 @@
+# Commander.js
+
+  The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/visionmedia/commander).
+
+ [![Build Status](https://secure.travis-ci.org/visionmedia/commander.js.png)](http://travis-ci.org/visionmedia/commander.js)
+
+## Installation
+
+    $ npm install commander
+
+## Option parsing
+
+ Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+  .version('0.0.1')
+  .option('-p, --peppers', 'Add peppers')
+  .option('-P, --pineapple', 'Add pineapple')
+  .option('-b, --bbq', 'Add bbq sauce')
+  .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble')
+  .parse(process.argv);
+
+console.log('you ordered a pizza with:');
+if (program.peppers) console.log('  - peppers');
+if (program.pineapple) console.log('  - pineappe');
+if (program.bbq) console.log('  - bbq');
+console.log('  - %s cheese', program.cheese);
+```
+
+ Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as "--template-engine" are camel-cased, becoming `program.templateEngine` etc.
+
+## Automated --help
+
+ The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free:
+
+```  
+ $ ./examples/pizza --help
+
+   Usage: pizza [options]
+
+   Options:
+
+     -V, --version        output the version number
+     -p, --peppers        Add peppers
+     -P, --pineapple      Add pineappe
+     -b, --bbq            Add bbq sauce
+     -c, --cheese <type>  Add the specified type of cheese [marble]
+     -h, --help           output usage information
+
+```
+
+## Coercion
+
+```js
+function range(val) {
+  return val.split('..').map(Number);
+}
+
+function list(val) {
+  return val.split(',');
+}
+
+program
+  .version('0.0.1')
+  .usage('[options] <file ...>')
+  .option('-i, --integer <n>', 'An integer argument', parseInt)
+  .option('-f, --float <n>', 'A float argument', parseFloat)
+  .option('-r, --range <a>..<b>', 'A range', range)
+  .option('-l, --list <items>', 'A list', list)
+  .option('-o, --optional [value]', 'An optional value')
+  .parse(process.argv);
+
+console.log(' int: %j', program.integer);
+console.log(' float: %j', program.float);
+console.log(' optional: %j', program.optional);
+program.range = program.range || [];
+console.log(' range: %j..%j', program.range[0], program.range[1]);
+console.log(' list: %j', program.list);
+console.log(' args: %j', program.args);
+```
+
+## Custom help
+
+ You can display arbitrary `-h, --help` information
+ by listening for "--help". Commander will automatically
+ exit once you are done so that the remainder of your program
+ does not execute causing undesired behaviours, for example
+ in the following executable "stuff" will not output when
+ `--help` is used.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('../');
+
+function list(val) {
+  return val.split(',').map(Number);
+}
+
+program
+  .version('0.0.1')
+  .option('-f, --foo', 'enable some foo')
+  .option('-b, --bar', 'enable some bar')
+  .option('-B, --baz', 'enable some baz');
+
+// must be before .parse() since
+// node's emit() is immediate
+
+program.on('--help', function(){
+  console.log('  Examples:');
+  console.log('');
+  console.log('    $ custom-help --help');
+  console.log('    $ custom-help -h');
+  console.log('');
+});
+
+program.parse(process.argv);
+
+console.log('stuff');
+```
+
+yielding the following help output:
+
+```
+
+Usage: custom-help [options]
+
+Options:
+
+  -h, --help     output usage information
+  -V, --version  output the version number
+  -f, --foo      enable some foo
+  -b, --bar      enable some bar
+  -B, --baz      enable some baz
+
+Examples:
+
+  $ custom-help --help
+  $ custom-help -h
+
+```
+
+## .prompt(msg, fn)
+
+ Single-line prompt:
+
+```js
+program.prompt('name: ', function(name){
+  console.log('hi %s', name);
+});
+```
+
+ Multi-line prompt:
+
+```js
+program.prompt('description:', function(name){
+  console.log('hi %s', name);
+});
+```
+
+ Coercion:
+
+```js
+program.prompt('Age: ', Number, function(age){
+  console.log('age: %j', age);
+});
+```
+
+```js
+program.prompt('Birthdate: ', Date, function(date){
+  console.log('date: %s', date);
+});
+```
+
+## .password(msg[, mask], fn)
+
+Prompt for password without echoing:
+
+```js
+program.password('Password: ', function(pass){
+  console.log('got "%s"', pass);
+  process.stdin.destroy();
+});
+```
+
+Prompt for password with mask char "*":
+
+```js
+program.password('Password: ', '*', function(pass){
+  console.log('got "%s"', pass);
+  process.stdin.destroy();
+});
+```
+
+## .confirm(msg, fn)
+
+ Confirm with the given `msg`:
+
+```js
+program.confirm('continue? ', function(ok){
+  console.log(' got %j', ok);
+});
+```
+
+## .choose(list, fn)
+
+ Let the user choose from a `list`:
+
+```js
+var list = ['tobi', 'loki', 'jane', 'manny', 'luna'];
+
+console.log('Choose the coolest pet:');
+program.choose(list, function(i){
+  console.log('you chose %d "%s"', i, list[i]);
+});
+```
+
+## .outputHelp()
+
+  Output help information without exiting.
+
+## .help()
+
+  Output help information and exit immediately.
+
+## Links
+
+ - [API documentation](http://visionmedia.github.com/commander.js/)
+ - [ascii tables](https://github.com/LearnBoost/cli-table)
+ - [progress bars](https://github.com/visionmedia/node-progress)
+ - [more progress bars](https://github.com/substack/node-multimeter)
+ - [examples](https://github.com/visionmedia/commander.js/tree/master/examples)
+
+## License 
+
+(The MIT License)
+
+Copyright (c) 2011 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.
\ No newline at end of file
diff --git a/node_modules/tar.gz/node_modules/commander/index.js b/node_modules/tar.gz/node_modules/commander/index.js
new file mode 100644
index 000000000..bddca73af
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/index.js
@@ -0,0 +1,1131 @@
+/*!
+ * commander
+ * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var EventEmitter = require('events').EventEmitter
+  , spawn = require('child_process').spawn
+  , keypress = require('keypress')
+  , fs = require('fs')
+  , exists = fs.existsSync
+  , path = require('path')
+  , tty = require('tty')
+  , dirname = path.dirname
+  , basename = path.basename;
+
+/**
+ * Expose the root command.
+ */
+
+exports = module.exports = new Command;
+
+/**
+ * Expose `Command`.
+ */
+
+exports.Command = Command;
+
+/**
+ * Expose `Option`.
+ */
+
+exports.Option = Option;
+
+/**
+ * Initialize a new `Option` with the given `flags` and `description`.
+ *
+ * @param {String} flags
+ * @param {String} description
+ * @api public
+ */
+
+function Option(flags, description) {
+  this.flags = flags;
+  this.required = ~flags.indexOf('<');
+  this.optional = ~flags.indexOf('[');
+  this.bool = !~flags.indexOf('-no-');
+  flags = flags.split(/[ ,|]+/);
+  if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
+  this.long = flags.shift();
+  this.description = description || '';
+}
+
+/**
+ * Return option name.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Option.prototype.name = function(){
+  return this.long
+    .replace('--', '')
+    .replace('no-', '');
+};
+
+/**
+ * Check if `arg` matches the short or long flag.
+ *
+ * @param {String} arg
+ * @return {Boolean}
+ * @api private
+ */
+
+Option.prototype.is = function(arg){
+  return arg == this.short
+    || arg == this.long;
+};
+
+/**
+ * Initialize a new `Command`.
+ *
+ * @param {String} name
+ * @api public
+ */
+
+function Command(name) {
+  this.commands = [];
+  this.options = [];
+  this._args = [];
+  this._name = name;
+}
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+
+Command.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Add command `name`.
+ *
+ * The `.action()` callback is invoked when the
+ * command `name` is specified via __ARGV__,
+ * and the remaining arguments are applied to the
+ * function for access.
+ *
+ * When the `name` is "*" an un-matched command
+ * will be passed as the first arg, followed by
+ * the rest of __ARGV__ remaining.
+ *
+ * Examples:
+ *
+ *      program
+ *        .version('0.0.1')
+ *        .option('-C, --chdir <path>', 'change the working directory')
+ *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
+ *        .option('-T, --no-tests', 'ignore test hook')
+ *     
+ *      program
+ *        .command('setup')
+ *        .description('run remote setup commands')
+ *        .action(function(){
+ *          console.log('setup');
+ *        });
+ *     
+ *      program
+ *        .command('exec <cmd>')
+ *        .description('run the given remote command')
+ *        .action(function(cmd){
+ *          console.log('exec "%s"', cmd);
+ *        });
+ *     
+ *      program
+ *        .command('*')
+ *        .description('deploy the given env')
+ *        .action(function(env){
+ *          console.log('deploying "%s"', env);
+ *        });
+ *     
+ *      program.parse(process.argv);
+  *
+ * @param {String} name
+ * @param {String} [desc]
+ * @return {Command} the new command
+ * @api public
+ */
+
+Command.prototype.command = function(name, desc){
+  var args = name.split(/ +/);
+  var cmd = new Command(args.shift());
+  if (desc) cmd.description(desc);
+  if (desc) this.executables = true;
+  this.commands.push(cmd);
+  cmd.parseExpectedArgs(args);
+  cmd.parent = this;
+  if (desc) return this;
+  return cmd;
+};
+
+/**
+ * Add an implicit `help [cmd]` subcommand
+ * which invokes `--help` for the given command.
+ *
+ * @api private
+ */
+
+Command.prototype.addImplicitHelpCommand = function() {
+  this.command('help [cmd]', 'display help for [cmd]');
+};
+
+/**
+ * Parse expected `args`.
+ *
+ * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+ *
+ * @param {Array} args
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.parseExpectedArgs = function(args){
+  if (!args.length) return;
+  var self = this;
+  args.forEach(function(arg){
+    switch (arg[0]) {
+      case '<':
+        self._args.push({ required: true, name: arg.slice(1, -1) });
+        break;
+      case '[':
+        self._args.push({ required: false, name: arg.slice(1, -1) });
+        break;
+    }
+  });
+  return this;
+};
+
+/**
+ * Register callback `fn` for the command.
+ *
+ * Examples:
+ *
+ *      program
+ *        .command('help')
+ *        .description('display verbose help')
+ *        .action(function(){
+ *           // output help here
+ *        });
+ *
+ * @param {Function} fn
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.action = function(fn){
+  var self = this;
+  this.parent.on(this._name, function(args, unknown){    
+    // Parse any so-far unknown options
+    unknown = unknown || [];
+    var parsed = self.parseOptions(unknown);
+    
+    // Output help if necessary
+    outputHelpIfNecessary(self, parsed.unknown);
+    
+    // If there are still any unknown options, then we simply 
+    // die, unless someone asked for help, in which case we give it
+    // to them, and then we die.
+    if (parsed.unknown.length > 0) {      
+      self.unknownOption(parsed.unknown[0]);
+    }
+    
+    // Leftover arguments need to be pushed back. Fixes issue #56
+    if (parsed.args.length) args = parsed.args.concat(args);
+    
+    self._args.forEach(function(arg, i){
+      if (arg.required && null == args[i]) {
+        self.missingArgument(arg.name);
+      }
+    });
+    
+    // Always append ourselves to the end of the arguments,
+    // to make sure we match the number of arguments the user
+    // expects
+    if (self._args.length) {
+      args[self._args.length] = self;
+    } else {
+      args.push(self);
+    }
+    
+    fn.apply(this, args);
+  });
+  return this;
+};
+
+/**
+ * Define option with `flags`, `description` and optional
+ * coercion `fn`. 
+ *
+ * The `flags` string should contain both the short and long flags,
+ * separated by comma, a pipe or space. The following are all valid
+ * all will output this way when `--help` is used.
+ *
+ *    "-p, --pepper"
+ *    "-p|--pepper"
+ *    "-p --pepper"
+ *
+ * Examples:
+ *
+ *     // simple boolean defaulting to false
+ *     program.option('-p, --pepper', 'add pepper');
+ *
+ *     --pepper
+ *     program.pepper
+ *     // => Boolean
+ *
+ *     // simple boolean defaulting to false
+ *     program.option('-C, --no-cheese', 'remove cheese');
+ *
+ *     program.cheese
+ *     // => true
+ *
+ *     --no-cheese
+ *     program.cheese
+ *     // => true
+ *
+ *     // required argument
+ *     program.option('-C, --chdir <path>', 'change the working directory');
+ *
+ *     --chdir /tmp
+ *     program.chdir
+ *     // => "/tmp"
+ *
+ *     // optional argument
+ *     program.option('-c, --cheese [type]', 'add cheese [marble]');
+ *
+ * @param {String} flags
+ * @param {String} description
+ * @param {Function|Mixed} fn or default
+ * @param {Mixed} defaultValue
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.option = function(flags, description, fn, defaultValue){
+  var self = this
+    , option = new Option(flags, description)
+    , oname = option.name()
+    , name = camelcase(oname);
+
+  // default as 3rd arg
+  if ('function' != typeof fn) defaultValue = fn, fn = null;
+
+  // preassign default value only for --no-*, [optional], or <required>
+  if (false == option.bool || option.optional || option.required) {
+    // when --no-* we make sure default is true
+    if (false == option.bool) defaultValue = true;
+    // preassign only if we have a default
+    if (undefined !== defaultValue) self[name] = defaultValue;
+  }
+
+  // register the option
+  this.options.push(option);
+
+  // when it's passed assign the value
+  // and conditionally invoke the callback
+  this.on(oname, function(val){
+    // coercion
+    if (null != val && fn) val = fn(val);
+
+    // unassigned or bool
+    if ('boolean' == typeof self[name] || 'undefined' == typeof self[name]) {
+      // if no value, bool true, and we have a default, then use it!
+      if (null == val) {
+        self[name] = option.bool
+          ? defaultValue || true
+          : false;
+      } else {
+        self[name] = val;
+      }
+    } else if (null !== val) {
+      // reassign
+      self[name] = val;
+    }
+  });
+
+  return this;
+};
+
+/**
+ * Parse `argv`, settings options and invoking commands when defined.
+ *
+ * @param {Array} argv
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.parse = function(argv){
+  // implicit help
+  if (this.executables) this.addImplicitHelpCommand();
+
+  // store raw args
+  this.rawArgs = argv;
+
+  // guess name
+  this._name = this._name || basename(argv[1]);
+
+  // process argv
+  var parsed = this.parseOptions(this.normalize(argv.slice(2)));
+  var args = this.args = parsed.args;
+ 
+  // executable sub-commands, skip .parseArgs()
+  if (this.executables) return this.executeSubCommand(argv, args, parsed.unknown);
+
+  return this.parseArgs(this.args, parsed.unknown);
+};
+
+/**
+ * Execute a sub-command executable.
+ *
+ * @param {Array} argv
+ * @param {Array} args
+ * @param {Array} unknown
+ * @api private
+ */
+
+Command.prototype.executeSubCommand = function(argv, args, unknown) {
+  args = args.concat(unknown);
+
+  if (!args.length) this.help();
+  if ('help' == args[0] && 1 == args.length) this.help();
+
+  // <cmd> --help
+  if ('help' == args[0]) {
+    args[0] = args[1];
+    args[1] = '--help';
+  }
+
+  // executable
+  var dir = dirname(argv[1]);
+  var bin = basename(argv[1]) + '-' + args[0];
+
+  // check for ./<bin> first
+  var local = path.join(dir, bin);
+  if (exists(local)) bin = local;
+
+  // run it
+  args = args.slice(1);
+  var proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] });
+  proc.on('exit', function(code){
+    if (code == 127) {
+      console.error('\n  %s(1) does not exist\n', bin);
+    }
+  });
+};
+
+/**
+ * Normalize `args`, splitting joined short flags. For example
+ * the arg "-abc" is equivalent to "-a -b -c".
+ * This also normalizes equal sign and splits "--abc=def" into "--abc def".
+ *
+ * @param {Array} args
+ * @return {Array}
+ * @api private
+ */
+
+Command.prototype.normalize = function(args){
+  var ret = []
+    , arg
+    , index;
+
+  for (var i = 0, len = args.length; i < len; ++i) {
+    arg = args[i];
+    if (arg.length > 1 && '-' == arg[0] && '-' != arg[1]) {
+      arg.slice(1).split('').forEach(function(c){
+        ret.push('-' + c);
+      });
+    } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) {
+      ret.push(arg.slice(0, index), arg.slice(index + 1));
+    } else {
+      ret.push(arg);
+    }
+  }
+
+  return ret;
+};
+
+/**
+ * Parse command `args`.
+ *
+ * When listener(s) are available those
+ * callbacks are invoked, otherwise the "*"
+ * event is emitted and those actions are invoked.
+ *
+ * @param {Array} args
+ * @return {Command} for chaining
+ * @api private
+ */
+
+Command.prototype.parseArgs = function(args, unknown){
+  var cmds = this.commands
+    , len = cmds.length
+    , name;
+
+  if (args.length) {
+    name = args[0];
+    if (this.listeners(name).length) {
+      this.emit(args.shift(), args, unknown);
+    } else {
+      this.emit('*', args);
+    }
+  } else {
+    outputHelpIfNecessary(this, unknown);
+    
+    // If there were no args and we have unknown options,
+    // then they are extraneous and we need to error.
+    if (unknown.length > 0) {      
+      this.unknownOption(unknown[0]);
+    }
+  }
+
+  return this;
+};
+
+/**
+ * Return an option matching `arg` if any.
+ *
+ * @param {String} arg
+ * @return {Option}
+ * @api private
+ */
+
+Command.prototype.optionFor = function(arg){
+  for (var i = 0, len = this.options.length; i < len; ++i) {
+    if (this.options[i].is(arg)) {
+      return this.options[i];
+    }
+  }
+};
+
+/**
+ * Parse options from `argv` returning `argv`
+ * void of these options.
+ *
+ * @param {Array} argv
+ * @return {Array}
+ * @api public
+ */
+
+Command.prototype.parseOptions = function(argv){
+  var args = []
+    , len = argv.length
+    , literal
+    , option
+    , arg;
+
+  var unknownOptions = [];
+
+  // parse options
+  for (var i = 0; i < len; ++i) {
+    arg = argv[i];
+
+    // literal args after --
+    if ('--' == arg) {
+      literal = true;
+      continue;
+    }
+
+    if (literal) {
+      args.push(arg);
+      continue;
+    }
+
+    // find matching Option
+    option = this.optionFor(arg);
+
+    // option is defined
+    if (option) {
+      // requires arg
+      if (option.required) {
+        arg = argv[++i];
+        if (null == arg) return this.optionMissingArgument(option);
+        if ('-' == arg[0]) return this.optionMissingArgument(option, arg);
+        this.emit(option.name(), arg);
+      // optional arg
+      } else if (option.optional) {
+        arg = argv[i+1];
+        if (null == arg || '-' == arg[0]) {
+          arg = null;
+        } else {
+          ++i;
+        }
+        this.emit(option.name(), arg);
+      // bool
+      } else {
+        this.emit(option.name());
+      }
+      continue;
+    }
+    
+    // looks like an option
+    if (arg.length > 1 && '-' == arg[0]) {
+      unknownOptions.push(arg);
+      
+      // If the next argument looks like it might be
+      // an argument for this option, we pass it on.
+      // If it isn't, then it'll simply be ignored
+      if (argv[i+1] && '-' != argv[i+1][0]) {
+        unknownOptions.push(argv[++i]);
+      }
+      continue;
+    }
+    
+    // arg
+    args.push(arg);
+  }
+  
+  return { args: args, unknown: unknownOptions };
+};
+
+/**
+ * Argument `name` is missing.
+ *
+ * @param {String} name
+ * @api private
+ */
+
+Command.prototype.missingArgument = function(name){
+  console.error();
+  console.error("  error: missing required argument `%s'", name);
+  console.error();
+  process.exit(1);
+};
+
+/**
+ * `Option` is missing an argument, but received `flag` or nothing.
+ *
+ * @param {String} option
+ * @param {String} flag
+ * @api private
+ */
+
+Command.prototype.optionMissingArgument = function(option, flag){
+  console.error();
+  if (flag) {
+    console.error("  error: option `%s' argument missing, got `%s'", option.flags, flag);
+  } else {
+    console.error("  error: option `%s' argument missing", option.flags);
+  }
+  console.error();
+  process.exit(1);
+};
+
+/**
+ * Unknown option `flag`.
+ *
+ * @param {String} flag
+ * @api private
+ */
+
+Command.prototype.unknownOption = function(flag){
+  console.error();
+  console.error("  error: unknown option `%s'", flag);
+  console.error();
+  process.exit(1);
+};
+
+
+/**
+ * Set the program version to `str`.
+ *
+ * This method auto-registers the "-V, --version" flag
+ * which will print the version number when passed.
+ *
+ * @param {String} str
+ * @param {String} flags
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.version = function(str, flags){
+  if (0 == arguments.length) return this._version;
+  this._version = str;
+  flags = flags || '-V, --version';
+  this.option(flags, 'output the version number');
+  this.on('version', function(){
+    console.log(str);
+    process.exit(0);
+  });
+  return this;
+};
+
+/**
+ * Set the description `str`.
+ *
+ * @param {String} str
+ * @return {String|Command}
+ * @api public
+ */
+
+Command.prototype.description = function(str){
+  if (0 == arguments.length) return this._description;
+  this._description = str;
+  return this;
+};
+
+/**
+ * Set / get the command usage `str`.
+ *
+ * @param {String} str
+ * @return {String|Command}
+ * @api public
+ */
+
+Command.prototype.usage = function(str){
+  var args = this._args.map(function(arg){
+    return arg.required
+      ? '<' + arg.name + '>'
+      : '[' + arg.name + ']';
+  });
+
+  var usage = '[options'
+    + (this.commands.length ? '] [command' : '')
+    + ']'
+    + (this._args.length ? ' ' + args : '');
+
+  if (0 == arguments.length) return this._usage || usage;
+  this._usage = str;
+
+  return this;
+};
+
+/**
+ * Return the largest option length.
+ *
+ * @return {Number}
+ * @api private
+ */
+
+Command.prototype.largestOptionLength = function(){
+  return this.options.reduce(function(max, option){
+    return Math.max(max, option.flags.length);
+  }, 0);
+};
+
+/**
+ * Return help for options.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.optionHelp = function(){
+  var width = this.largestOptionLength();
+  
+  // Prepend the help information
+  return [pad('-h, --help', width) + '  ' + 'output usage information']
+    .concat(this.options.map(function(option){
+      return pad(option.flags, width)
+        + '  ' + option.description;
+      }))
+    .join('\n');
+};
+
+/**
+ * Return command help documentation.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.commandHelp = function(){
+  if (!this.commands.length) return '';
+  return [
+      ''
+    , '  Commands:'
+    , ''
+    , this.commands.map(function(cmd){
+      var args = cmd._args.map(function(arg){
+        return arg.required
+          ? '<' + arg.name + '>'
+          : '[' + arg.name + ']';
+      }).join(' ');
+
+      return pad(cmd._name
+        + (cmd.options.length 
+          ? ' [options]'
+          : '') + ' ' + args, 22)
+        + (cmd.description()
+          ? ' ' + cmd.description()
+          : '');
+    }).join('\n').replace(/^/gm, '    ')
+    , ''
+  ].join('\n');
+};
+
+/**
+ * Return program help documentation.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.helpInformation = function(){
+  return [
+      ''
+    , '  Usage: ' + this._name + ' ' + this.usage()
+    , '' + this.commandHelp()
+    , '  Options:'
+    , ''
+    , '' + this.optionHelp().replace(/^/gm, '    ')
+    , ''
+    , ''
+  ].join('\n');
+};
+
+/**
+ * Prompt for a `Number`.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptForNumber = function(str, fn){
+  var self = this;
+  this.promptSingleLine(str, function parseNumber(val){
+    val = Number(val);
+    if (isNaN(val)) return self.promptSingleLine(str + '(must be a number) ', parseNumber);
+    fn(val);
+  });
+};
+
+/**
+ * Prompt for a `Date`.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptForDate = function(str, fn){
+  var self = this;
+  this.promptSingleLine(str, function parseDate(val){
+    val = new Date(val);
+    if (isNaN(val.getTime())) return self.promptSingleLine(str + '(must be a date) ', parseDate);
+    fn(val);
+  });
+};
+
+/**
+ * Single-line prompt.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptSingleLine = function(str, fn){
+  if ('function' == typeof arguments[2]) {
+    return this['promptFor' + (fn.name || fn)](str, arguments[2]);
+  }
+
+  process.stdout.write(str);
+  process.stdin.setEncoding('utf8');
+  process.stdin.once('data', function(val){
+    fn(val.trim());
+  }).resume();
+};
+
+/**
+ * Multi-line prompt.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptMultiLine = function(str, fn){
+  var buf = [];
+  console.log(str);
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', function(val){
+    if ('\n' == val || '\r\n' == val) {
+      process.stdin.removeAllListeners('data');
+      fn(buf.join('\n'));
+    } else {
+      buf.push(val.trimRight());
+    }
+  }).resume();
+};
+
+/**
+ * Prompt `str` and callback `fn(val)`
+ *
+ * Commander supports single-line and multi-line prompts.
+ * To issue a single-line prompt simply add white-space
+ * to the end of `str`, something like "name: ", whereas
+ * for a multi-line prompt omit this "description:".
+ *
+ *
+ * Examples:
+ *
+ *     program.prompt('Username: ', function(name){
+ *       console.log('hi %s', name);
+ *     });
+ *     
+ *     program.prompt('Description:', function(desc){
+ *       console.log('description was "%s"', desc.trim());
+ *     });
+ *
+ * @param {String|Object} str
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.prompt = function(str, fn){
+  var self = this;
+
+  if ('string' == typeof str) {
+    if (/ $/.test(str)) return this.promptSingleLine.apply(this, arguments);
+    this.promptMultiLine(str, fn);
+  } else {
+    var keys = Object.keys(str)
+      , obj = {};
+
+    function next() {
+      var key = keys.shift()
+        , label = str[key];
+
+      if (!key) return fn(obj);
+      self.prompt(label, function(val){
+        obj[key] = val;
+        next();
+      });
+    }
+
+    next();
+  }
+};
+
+/**
+ * Prompt for password with `str`, `mask` char and callback `fn(val)`.
+ *
+ * The mask string defaults to '', aka no output is
+ * written while typing, you may want to use "*" etc.
+ *
+ * Examples:
+ *
+ *     program.password('Password: ', function(pass){
+ *       console.log('got "%s"', pass);
+ *       process.stdin.destroy();
+ *     });
+ *
+ *     program.password('Password: ', '*', function(pass){
+ *       console.log('got "%s"', pass);
+ *       process.stdin.destroy();
+ *     });
+ *
+ * @param {String} str
+ * @param {String} mask
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.password = function(str, mask, fn){
+  var self = this
+    , buf = '';
+
+  // default mask
+  if ('function' == typeof mask) {
+    fn = mask;
+    mask = '';
+  }
+
+  keypress(process.stdin);
+
+  function setRawMode(mode) {
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(mode);
+    } else {
+      tty.setRawMode(mode);
+    }
+  };
+  setRawMode(true);
+  process.stdout.write(str);
+
+  // keypress
+  process.stdin.on('keypress', function(c, key){
+    if (key && 'enter' == key.name) {
+      console.log();
+      process.stdin.pause();
+      process.stdin.removeAllListeners('keypress');
+      setRawMode(false);
+      if (!buf.trim().length) return self.password(str, mask, fn);
+      fn(buf);
+      return;
+    }
+
+    if (key && key.ctrl && 'c' == key.name) {
+      console.log('%s', buf);
+      process.exit();
+    }
+
+    process.stdout.write(mask);
+    buf += c;
+  }).resume();
+};
+
+/**
+ * Confirmation prompt with `str` and callback `fn(bool)`
+ *
+ * Examples:
+ *
+ *      program.confirm('continue? ', function(ok){
+ *        console.log(' got %j', ok);
+ *        process.stdin.destroy();
+ *      });
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api public
+ */
+
+
+Command.prototype.confirm = function(str, fn, verbose){
+  var self = this;
+  this.prompt(str, function(ok){
+    if (!ok.trim()) {
+      if (!verbose) str += '(yes or no) ';
+      return self.confirm(str, fn, true);
+    }
+    fn(parseBool(ok));
+  });
+};
+
+/**
+ * Choice prompt with `list` of items and callback `fn(index, item)`
+ *
+ * Examples:
+ *
+ *      var list = ['tobi', 'loki', 'jane', 'manny', 'luna'];
+ *      
+ *      console.log('Choose the coolest pet:');
+ *      program.choose(list, function(i){
+ *        console.log('you chose %d "%s"', i, list[i]);
+ *        process.stdin.destroy();
+ *      });
+ *
+ * @param {Array} list
+ * @param {Number|Function} index or fn
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.choose = function(list, index, fn){
+  var self = this
+    , hasDefault = 'number' == typeof index;
+
+  if (!hasDefault) {
+    fn = index;
+    index = null;
+  }
+
+  list.forEach(function(item, i){
+    if (hasDefault && i == index) {
+      console.log('* %d) %s', i + 1, item);
+    } else {
+      console.log('  %d) %s', i + 1, item);
+    }
+  });
+
+  function again() {
+    self.prompt('  : ', function(val){
+      val = parseInt(val, 10) - 1;
+      if (hasDefault && isNaN(val)) val = index;
+
+      if (null == list[val]) {
+        again();
+      } else {
+        fn(val, list[val]);
+      }
+    });
+  }
+
+  again();
+};
+
+
+/**
+ * Output help information for this command
+ *
+ * @api public
+ */
+
+Command.prototype.outputHelp = function(){
+  process.stdout.write(this.helpInformation());
+  this.emit('--help');
+};
+
+/**
+ * Output help information and exit.
+ *
+ * @api public
+ */
+
+Command.prototype.help = function(){
+  this.outputHelp();
+  process.exit();
+};
+
+/**
+ * Camel-case the given `flag`
+ *
+ * @param {String} flag
+ * @return {String}
+ * @api private
+ */
+
+function camelcase(flag) {
+  return flag.split('-').reduce(function(str, word){
+    return str + word[0].toUpperCase() + word.slice(1);
+  });
+}
+
+/**
+ * Parse a boolean `str`.
+ *
+ * @param {String} str
+ * @return {Boolean}
+ * @api private
+ */
+
+function parseBool(str) {
+  return /^y|yes|ok|true$/i.test(str);
+}
+
+/**
+ * Pad `str` to `width`.
+ *
+ * @param {String} str
+ * @param {Number} width
+ * @return {String}
+ * @api private
+ */
+
+function pad(str, width) {
+  var len = Math.max(0, width - str.length);
+  return str + Array(len + 1).join(' ');
+}
+
+/**
+ * Output help information if necessary
+ *
+ * @param {Command} command to output help for
+ * @param {Array} array of options to search for -h or --help
+ * @api private
+ */
+
+function outputHelpIfNecessary(cmd, options) {
+  options = options || [];
+  for (var i = 0; i < options.length; i++) {
+    if (options[i] == '--help' || options[i] == '-h') {
+      cmd.outputHelp();
+      process.exit(0);
+    }
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/commander/node_modules/keypress/README.md b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/README.md
new file mode 100644
index 000000000..a768e8f59
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/README.md
@@ -0,0 +1,101 @@
+keypress
+========
+### Make any Node ReadableStream emit "keypress" events
+
+
+Previous to Node `v0.8.x`, there was an undocumented `"keypress"` event that
+`process.stdin` would emit when it was a TTY. Some people discovered this hidden
+gem, and started using it in their own code.
+
+Now in Node `v0.8.x`, this `"keypress"` event does not get emitted by default,
+but rather only when it is being used in conjuction with the `readline` (or by
+extension, the `repl`) module.
+
+This module is the exact logic from the node `v0.8.x` releases ripped out into its
+own module.
+
+__Bonus:__ Now with mouse support!
+
+Installation
+------------
+
+Install with `npm`:
+
+``` bash
+$ npm install keypress
+```
+
+Or add it to the `"dependencies"` section of your _package.json_ file.
+
+
+Example
+-------
+
+#### Listening for "keypress" events
+
+``` js
+var keypress = require('keypress');
+
+// make `process.stdin` begin emitting "keypress" events
+keypress(process.stdin);
+
+// listen for the "keypress" event
+process.stdin.on('keypress', function (ch, key) {
+  console.log('got "keypress"', key);
+  if (key && key.ctrl && key.name == 'c') {
+    process.stdin.pause();
+  }
+});
+
+process.stdin.setRawMode(true);
+process.stdin.resume();
+```
+
+#### Listening for "mousepress" events
+
+``` js
+var keypress = require('keypress');
+
+// make `process.stdin` begin emitting "mousepress" (and "keypress") events
+keypress(process.stdin);
+
+// you must enable the mouse events before they will begin firing
+keypress.enableMouse(process.stdout);
+
+process.stdin.on('mousepress', function (info) {
+  console.log('got "mousepress" event at %d x %d', info.x, info.y);
+});
+
+process.on('exit', function () {
+  // disable mouse on exit, so that the state
+  // is back to normal for the terminal
+  keypress.disableMouse(process.stdout);
+});
+```
+
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&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/tar.gz/node_modules/commander/node_modules/keypress/index.js b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/index.js
new file mode 100644
index 000000000..c2ba488ba
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/index.js
@@ -0,0 +1,346 @@
+
+/**
+ * This module offers the internal "keypress" functionality from node-core's
+ * `readline` module, for your own programs and modules to use.
+ *
+ * Usage:
+ *
+ *   require('keypress')(process.stdin);
+ *
+ *   process.stdin.on('keypress', function (ch, key) {
+ *     console.log(ch, key);
+ *     if (key.ctrl && key.name == 'c') {
+ *       process.stdin.pause();
+ *     }
+ *   });
+ *   proces.stdin.resume();
+ */
+var exports = module.exports = keypress;
+
+exports.enableMouse = function (stream) {
+  stream.write('\x1b' +'[?1000h')
+}
+
+exports.disableMouse = function (stream) {
+  stream.write('\x1b' +'[?1000l')
+}
+
+
+/**
+ * accepts a readable Stream instance and makes it emit "keypress" events
+ */
+
+function keypress(stream) {
+  if (isEmittingKeypress(stream)) return;
+  stream._emitKeypress = true;
+
+  function onData(b) {
+    if (stream.listeners('keypress').length > 0) {
+      emitKey(stream, b);
+    } else {
+      // Nobody's watching anyway
+      stream.removeListener('data', onData);
+      stream.on('newListener', onNewListener);
+    }
+  }
+
+  function onNewListener(event) {
+    if (event == 'keypress') {
+      stream.on('data', onData);
+      stream.removeListener('newListener', onNewListener);
+    }
+  }
+
+  if (stream.listeners('keypress').length > 0) {
+    stream.on('data', onData);
+  } else {
+    stream.on('newListener', onNewListener);
+  }
+}
+
+/**
+ * Returns `true` if the stream is already emitting "keypress" events.
+ * `false` otherwise.
+ */
+
+function isEmittingKeypress(stream) {
+  var rtn = stream._emitKeypress;
+  if (!rtn) {
+    // hack: check for the v0.6.x "data" event
+    stream.listeners('data').forEach(function (l) {
+      if (l.name == 'onData' && /emitKey/.test(l.toString())) {
+        rtn = true;
+        stream._emitKeypress = true;
+      }
+    });
+  }
+  if (!rtn) {
+    // hack: check for the v0.6.x "newListener" event
+    stream.listeners('newListener').forEach(function (l) {
+      if (l.name == 'onNewListener' && /keypress/.test(l.toString())) {
+        rtn = true;
+        stream._emitKeypress = true;
+      }
+    });
+  }
+  return rtn;
+}
+
+
+/*
+  Some patterns seen in terminal key escape codes, derived from combos seen
+  at http://www.midnight-commander.org/browser/lib/tty/key.c
+
+  ESC letter
+  ESC [ letter
+  ESC [ modifier letter
+  ESC [ 1 ; modifier letter
+  ESC [ num char
+  ESC [ num ; modifier char
+  ESC O letter
+  ESC O modifier letter
+  ESC O 1 ; modifier letter
+  ESC N letter
+  ESC [ [ num ; modifier char
+  ESC [ [ 1 ; modifier letter
+  ESC ESC [ num char
+  ESC ESC O letter
+
+  - char is usually ~ but $ and ^ also happen with rxvt
+  - modifier is 1 +
+                (shift     * 1) +
+                (left_alt  * 2) +
+                (ctrl      * 4) +
+                (right_alt * 8)
+  - two leading ESCs apparently mean the same as one leading ESC
+*/
+
+// Regexes used for ansi escape code splitting
+var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
+var functionKeyCodeRe =
+    /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+
+function emitKey(stream, s) {
+  var ch,
+      key = {
+        name: undefined,
+        ctrl: false,
+        meta: false,
+        shift: false
+      },
+      parts;
+
+  if (Buffer.isBuffer(s)) {
+    if (s[0] > 127 && s[1] === undefined) {
+      s[0] -= 128;
+      s = '\x1b' + s.toString(stream.encoding || 'utf-8');
+    } else {
+      s = s.toString(stream.encoding || 'utf-8');
+    }
+  }
+
+  key.sequence = s;
+
+  if (s === '\r' || s === '\n') {
+    // enter
+    key.name = 'enter';
+
+  } else if (s === '\t') {
+    // tab
+    key.name = 'tab';
+
+  } else if (s === '\b' || s === '\x7f' ||
+             s === '\x1b\x7f' || s === '\x1b\b') {
+    // backspace or ctrl+h
+    key.name = 'backspace';
+    key.meta = (s.charAt(0) === '\x1b');
+
+  } else if (s === '\x1b' || s === '\x1b\x1b') {
+    // escape key
+    key.name = 'escape';
+    key.meta = (s.length === 2);
+
+  } else if (s === ' ' || s === '\x1b ') {
+    key.name = 'space';
+    key.meta = (s.length === 2);
+
+  } else if (s <= '\x1a') {
+    // ctrl+letter
+    key.name = String.fromCharCode(s.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
+    key.ctrl = true;
+
+  } else if (s.length === 1 && s >= 'a' && s <= 'z') {
+    // lowercase letter
+    key.name = s;
+
+  } else if (s.length === 1 && s >= 'A' && s <= 'Z') {
+    // shift+letter
+    key.name = s.toLowerCase();
+    key.shift = true;
+
+  } else if (parts = metaKeyCodeRe.exec(s)) {
+    // meta+character key
+    key.name = parts[1].toLowerCase();
+    key.meta = true;
+    key.shift = /^[A-Z]$/.test(parts[1]);
+
+  } else if (parts = functionKeyCodeRe.exec(s)) {
+    // ansi escape sequence
+
+    // reassemble the key code leaving out leading \x1b's,
+    // the modifier key bitflag and any meaningless "1;" sequence
+    var code = (parts[1] || '') + (parts[2] || '') +
+               (parts[4] || '') + (parts[6] || ''),
+        modifier = (parts[3] || parts[5] || 1) - 1;
+
+    // Parse the key modifier
+    key.ctrl = !!(modifier & 4);
+    key.meta = !!(modifier & 10);
+    key.shift = !!(modifier & 1);
+    key.code = code;
+
+    // Parse the key itself
+    switch (code) {
+      /* xterm/gnome ESC O letter */
+      case 'OP': key.name = 'f1'; break;
+      case 'OQ': key.name = 'f2'; break;
+      case 'OR': key.name = 'f3'; break;
+      case 'OS': key.name = 'f4'; break;
+
+      /* xterm/rxvt ESC [ number ~ */
+      case '[11~': key.name = 'f1'; break;
+      case '[12~': key.name = 'f2'; break;
+      case '[13~': key.name = 'f3'; break;
+      case '[14~': key.name = 'f4'; break;
+
+      /* from Cygwin and used in libuv */
+      case '[[A': key.name = 'f1'; break;
+      case '[[B': key.name = 'f2'; break;
+      case '[[C': key.name = 'f3'; break;
+      case '[[D': key.name = 'f4'; break;
+      case '[[E': key.name = 'f5'; break;
+
+      /* common */
+      case '[15~': key.name = 'f5'; break;
+      case '[17~': key.name = 'f6'; break;
+      case '[18~': key.name = 'f7'; break;
+      case '[19~': key.name = 'f8'; break;
+      case '[20~': key.name = 'f9'; break;
+      case '[21~': key.name = 'f10'; break;
+      case '[23~': key.name = 'f11'; break;
+      case '[24~': key.name = 'f12'; break;
+
+      /* xterm ESC [ letter */
+      case '[A': key.name = 'up'; break;
+      case '[B': key.name = 'down'; break;
+      case '[C': key.name = 'right'; break;
+      case '[D': key.name = 'left'; break;
+      case '[E': key.name = 'clear'; break;
+      case '[F': key.name = 'end'; break;
+      case '[H': key.name = 'home'; break;
+
+      /* xterm/gnome ESC O letter */
+      case 'OA': key.name = 'up'; break;
+      case 'OB': key.name = 'down'; break;
+      case 'OC': key.name = 'right'; break;
+      case 'OD': key.name = 'left'; break;
+      case 'OE': key.name = 'clear'; break;
+      case 'OF': key.name = 'end'; break;
+      case 'OH': key.name = 'home'; break;
+
+      /* xterm/rxvt ESC [ number ~ */
+      case '[1~': key.name = 'home'; break;
+      case '[2~': key.name = 'insert'; break;
+      case '[3~': key.name = 'delete'; break;
+      case '[4~': key.name = 'end'; break;
+      case '[5~': key.name = 'pageup'; break;
+      case '[6~': key.name = 'pagedown'; break;
+
+      /* putty */
+      case '[[5~': key.name = 'pageup'; break;
+      case '[[6~': key.name = 'pagedown'; break;
+
+      /* rxvt */
+      case '[7~': key.name = 'home'; break;
+      case '[8~': key.name = 'end'; break;
+
+      /* rxvt keys with modifiers */
+      case '[a': key.name = 'up'; key.shift = true; break;
+      case '[b': key.name = 'down'; key.shift = true; break;
+      case '[c': key.name = 'right'; key.shift = true; break;
+      case '[d': key.name = 'left'; key.shift = true; break;
+      case '[e': key.name = 'clear'; key.shift = true; break;
+
+      case '[2$': key.name = 'insert'; key.shift = true; break;
+      case '[3$': key.name = 'delete'; key.shift = true; break;
+      case '[5$': key.name = 'pageup'; key.shift = true; break;
+      case '[6$': key.name = 'pagedown'; key.shift = true; break;
+      case '[7$': key.name = 'home'; key.shift = true; break;
+      case '[8$': key.name = 'end'; key.shift = true; break;
+
+      case 'Oa': key.name = 'up'; key.ctrl = true; break;
+      case 'Ob': key.name = 'down'; key.ctrl = true; break;
+      case 'Oc': key.name = 'right'; key.ctrl = true; break;
+      case 'Od': key.name = 'left'; key.ctrl = true; break;
+      case 'Oe': key.name = 'clear'; key.ctrl = true; break;
+
+      case '[2^': key.name = 'insert'; key.ctrl = true; break;
+      case '[3^': key.name = 'delete'; key.ctrl = true; break;
+      case '[5^': key.name = 'pageup'; key.ctrl = true; break;
+      case '[6^': key.name = 'pagedown'; key.ctrl = true; break;
+      case '[7^': key.name = 'home'; key.ctrl = true; break;
+      case '[8^': key.name = 'end'; key.ctrl = true; break;
+
+      /* misc. */
+      case '[Z': key.name = 'tab'; key.shift = true; break;
+      default: key.name = 'undefined'; break;
+
+    }
+  } else if (s.length > 1 && s[0] !== '\x1b') {
+    // Got a longer-than-one string of characters.
+    // Probably a paste, since it wasn't a control sequence.
+    Array.prototype.forEach.call(s, function(c) {
+      emitKey(stream, c);
+    });
+    return;
+  }
+
+  if (key.code == '[M') {
+    key.name = 'mouse';
+    var s = key.sequence;
+    var b = s.charCodeAt(3);
+    key.x = s.charCodeAt(4) - 040;
+    key.y = s.charCodeAt(5) - 040;
+
+    key.scroll = 0;
+
+    key.ctrl  = !!(1<<4 & b);
+    key.meta  = !!(1<<3 & b);
+    key.shift = !!(1<<2 & b);
+
+    key.release = (3 & b) === 3;
+
+    if (1<<6 & b) { //scroll
+      key.scroll = 1 & b ? 1 : -1;
+    }
+
+    if (!key.release && !key.scroll) {
+      key.button = b & 3;
+    }
+  }
+
+  // Don't emit a key if no name was found
+  if (key.name === undefined) {
+    key = undefined;
+  }
+
+  if (s.length === 1) {
+    ch = s;
+  }
+
+  if (key && key.name == 'mouse') {
+    stream.emit('mousepress', key)
+  } else if (key || ch) {
+    stream.emit('keypress', ch, key);
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/commander/node_modules/keypress/package.json b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/package.json
new file mode 100644
index 000000000..4d6f6d91f
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "keypress",
+  "version": "0.1.0",
+  "description": "Make any Node ReadableStream emit \"keypress\" events",
+  "author": {
+    "name": "Nathan Rajlich",
+    "email": "nathan@tootallnate.net",
+    "url": "http://tootallnate.net"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/TooTallNate/keypress.git"
+  },
+  "keywords": [
+    "keypress",
+    "readline",
+    "core"
+  ],
+  "license": "MIT",
+  "readme": "keypress\n========\n### Make any Node ReadableStream emit \"keypress\" events\n\n\nPrevious to Node `v0.8.x`, there was an undocumented `\"keypress\"` event that\n`process.stdin` would emit when it was a TTY. Some people discovered this hidden\ngem, and started using it in their own code.\n\nNow in Node `v0.8.x`, this `\"keypress\"` event does not get emitted by default,\nbut rather only when it is being used in conjuction with the `readline` (or by\nextension, the `repl`) module.\n\nThis module is the exact logic from the node `v0.8.x` releases ripped out into its\nown module.\n\n__Bonus:__ Now with mouse support!\n\nInstallation\n------------\n\nInstall with `npm`:\n\n``` bash\n$ npm install keypress\n```\n\nOr add it to the `\"dependencies\"` section of your _package.json_ file.\n\n\nExample\n-------\n\n#### Listening for \"keypress\" events\n\n``` js\nvar keypress = require('keypress');\n\n// make `process.stdin` begin emitting \"keypress\" events\nkeypress(process.stdin);\n\n// listen for the \"keypress\" event\nprocess.stdin.on('keypress', function (ch, key) {\n  console.log('got \"keypress\"', key);\n  if (key && key.ctrl && key.name == 'c') {\n    process.stdin.pause();\n  }\n});\n\nprocess.stdin.setRawMode(true);\nprocess.stdin.resume();\n```\n\n#### Listening for \"mousepress\" events\n\n``` js\nvar keypress = require('keypress');\n\n// make `process.stdin` begin emitting \"mousepress\" (and \"keypress\") events\nkeypress(process.stdin);\n\n// you must enable the mouse events before they will begin firing\nkeypress.enableMouse(process.stdout);\n\nprocess.stdin.on('mousepress', function (info) {\n  console.log('got \"mousepress\" event at %d x %d', info.x, info.y);\n});\n\nprocess.on('exit', function () {\n  // disable mouse on exit, so that the state\n  // is back to normal for the terminal\n  keypress.disableMouse(process.stdout);\n});\n```\n\n\nLicense\n-------\n\n(The MIT License)\n\nCopyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/TooTallNate/keypress/issues"
+  },
+  "homepage": "https://github.com/TooTallNate/keypress",
+  "_id": "keypress@0.1.0",
+  "_shasum": "4a3188d4291b66b4f65edb99f806aa9ae293592a",
+  "_from": "keypress@0.1.x",
+  "_resolved": "https://registry.npmjs.org/keypress/-/keypress-0.1.0.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/commander/node_modules/keypress/test.js b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/test.js
new file mode 100644
index 000000000..c3f61d79d
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/node_modules/keypress/test.js
@@ -0,0 +1,28 @@
+
+var keypress = require('./')
+keypress(process.stdin)
+
+if (process.stdin.setRawMode)
+  process.stdin.setRawMode(true)
+else
+  require('tty').setRawMode(true)
+
+process.stdin.on('keypress', function (c, key) {
+  console.log(0, c, key)
+  if (key && key.ctrl && key.name == 'c') {
+    process.stdin.pause()
+  }
+})
+process.stdin.on('mousepress', function (mouse) {
+  console.log(mouse)
+})
+
+keypress.enableMouse(process.stdout)
+process.on('exit', function () {
+  //disable mouse on exit, so that the state is back to normal
+  //for the terminal.
+  keypress.disableMouse(process.stdout)
+})
+
+process.stdin.resume()
+
diff --git a/node_modules/tar.gz/node_modules/commander/package.json b/node_modules/tar.gz/node_modules/commander/package.json
new file mode 100644
index 000000000..50f953225
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/commander/package.json
@@ -0,0 +1,18 @@
+{
+    "name": "commander"
+  , "version": "1.1.1"
+  , "description": "the complete solution for node.js command-line programs"
+  , "keywords": ["command", "option", "parser", "prompt", "stdin"]
+  , "author": {
+   "name": "TJ Holowaychuk",
+   "email": "tj@vision-media.ca"
+ }
+  , "repository": { "type": "git", "url": "https://github.com/visionmedia/commander.js.git" }  
+  , "dependencies": { "keypress": "0.1.x"}
+  , "devDependencies": { "should": ">= 0.0.1" }
+  , "scripts": { "test": "make test" }
+  , "main": "index"
+  , "engines": { "node": ">= 0.6.x" }, "readme": "# Commander.js\n\n  The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/visionmedia/commander).\n\n [![Build Status](https://secure.travis-ci.org/visionmedia/commander.js.png)](http://travis-ci.org/visionmedia/commander.js)\n\n## Installation\n\n    $ npm install commander\n\n## Option parsing\n\n Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options.\n\n```js\n#!/usr/bin/env node\n\n/**\n * Module dependencies.\n */\n\nvar program = require('commander');\n\nprogram\n  .version('0.0.1')\n  .option('-p, --peppers', 'Add peppers')\n  .option('-P, --pineapple', 'Add pineapple')\n  .option('-b, --bbq', 'Add bbq sauce')\n  .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble')\n  .parse(process.argv);\n\nconsole.log('you ordered a pizza with:');\nif (program.peppers) console.log('  - peppers');\nif (program.pineapple) console.log('  - pineappe');\nif (program.bbq) console.log('  - bbq');\nconsole.log('  - %s cheese', program.cheese);\n```\n\n Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as \"--template-engine\" are camel-cased, becoming `program.templateEngine` etc.\n\n## Automated --help\n\n The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free:\n\n```  \n $ ./examples/pizza --help\n\n   Usage: pizza [options]\n\n   Options:\n\n     -V, --version        output the version number\n     -p, --peppers        Add peppers\n     -P, --pineapple      Add pineappe\n     -b, --bbq            Add bbq sauce\n     -c, --cheese <type>  Add the specified type of cheese [marble]\n     -h, --help           output usage information\n\n```\n\n## Coercion\n\n```js\nfunction range(val) {\n  return val.split('..').map(Number);\n}\n\nfunction list(val) {\n  return val.split(',');\n}\n\nprogram\n  .version('0.0.1')\n  .usage('[options] <file ...>')\n  .option('-i, --integer <n>', 'An integer argument', parseInt)\n  .option('-f, --float <n>', 'A float argument', parseFloat)\n  .option('-r, --range <a>..<b>', 'A range', range)\n  .option('-l, --list <items>', 'A list', list)\n  .option('-o, --optional [value]', 'An optional value')\n  .parse(process.argv);\n\nconsole.log(' int: %j', program.integer);\nconsole.log(' float: %j', program.float);\nconsole.log(' optional: %j', program.optional);\nprogram.range = program.range || [];\nconsole.log(' range: %j..%j', program.range[0], program.range[1]);\nconsole.log(' list: %j', program.list);\nconsole.log(' args: %j', program.args);\n```\n\n## Custom help\n\n You can display arbitrary `-h, --help` information\n by listening for \"--help\". Commander will automatically\n exit once you are done so that the remainder of your program\n does not execute causing undesired behaviours, for example\n in the following executable \"stuff\" will not output when\n `--help` is used.\n\n```js\n#!/usr/bin/env node\n\n/**\n * Module dependencies.\n */\n\nvar program = require('../');\n\nfunction list(val) {\n  return val.split(',').map(Number);\n}\n\nprogram\n  .version('0.0.1')\n  .option('-f, --foo', 'enable some foo')\n  .option('-b, --bar', 'enable some bar')\n  .option('-B, --baz', 'enable some baz');\n\n// must be before .parse() since\n// node's emit() is immediate\n\nprogram.on('--help', function(){\n  console.log('  Examples:');\n  console.log('');\n  console.log('    $ custom-help --help');\n  console.log('    $ custom-help -h');\n  console.log('');\n});\n\nprogram.parse(process.argv);\n\nconsole.log('stuff');\n```\n\nyielding the following help output:\n\n```\n\nUsage: custom-help [options]\n\nOptions:\n\n  -h, --help     output usage information\n  -V, --version  output the version number\n  -f, --foo      enable some foo\n  -b, --bar      enable some bar\n  -B, --baz      enable some baz\n\nExamples:\n\n  $ custom-help --help\n  $ custom-help -h\n\n```\n\n## .prompt(msg, fn)\n\n Single-line prompt:\n\n```js\nprogram.prompt('name: ', function(name){\n  console.log('hi %s', name);\n});\n```\n\n Multi-line prompt:\n\n```js\nprogram.prompt('description:', function(name){\n  console.log('hi %s', name);\n});\n```\n\n Coercion:\n\n```js\nprogram.prompt('Age: ', Number, function(age){\n  console.log('age: %j', age);\n});\n```\n\n```js\nprogram.prompt('Birthdate: ', Date, function(date){\n  console.log('date: %s', date);\n});\n```\n\n## .password(msg[, mask], fn)\n\nPrompt for password without echoing:\n\n```js\nprogram.password('Password: ', function(pass){\n  console.log('got \"%s\"', pass);\n  process.stdin.destroy();\n});\n```\n\nPrompt for password with mask char \"*\":\n\n```js\nprogram.password('Password: ', '*', function(pass){\n  console.log('got \"%s\"', pass);\n  process.stdin.destroy();\n});\n```\n\n## .confirm(msg, fn)\n\n Confirm with the given `msg`:\n\n```js\nprogram.confirm('continue? ', function(ok){\n  console.log(' got %j', ok);\n});\n```\n\n## .choose(list, fn)\n\n Let the user choose from a `list`:\n\n```js\nvar list = ['tobi', 'loki', 'jane', 'manny', 'luna'];\n\nconsole.log('Choose the coolest pet:');\nprogram.choose(list, function(i){\n  console.log('you chose %d \"%s\"', i, list[i]);\n});\n```\n\n## .outputHelp()\n\n  Output help information without exiting.\n\n## .help()\n\n  Output help information and exit immediately.\n\n## Links\n\n - [API documentation](http://visionmedia.github.com/commander.js/)\n - [ascii tables](https://github.com/LearnBoost/cli-table)\n - [progress bars](https://github.com/visionmedia/node-progress)\n - [more progress bars](https://github.com/substack/node-multimeter)\n - [examples](https://github.com/visionmedia/commander.js/tree/master/examples)\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2011 TJ Holowaychuk &lt;tj@vision-media.ca&gt;\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.", "readmeFilename": "Readme.md", "bugs": {
+   "url": "https://github.com/visionmedia/commander.js/issues"
+ }, "homepage": "https://github.com/visionmedia/commander.js", "_id": "commander@1.1.1", "_shasum": "50d1651868ae60eccff0a2d9f34595376bc6b041", "_from": "commander@1.1.x", "_resolved": "https://registry.npmjs.org/commander/-/commander-1.1.1.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/.npmignore b/node_modules/tar.gz/node_modules/fstream/.npmignore
new file mode 100644
index 000000000..494272a81
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/.npmignore
@@ -0,0 +1,5 @@
+.*.swp
+node_modules/
+examples/deep-copy/
+examples/path/
+examples/filter-copy/
diff --git a/node_modules/tar.gz/node_modules/fstream/.travis.yml b/node_modules/tar.gz/node_modules/fstream/.travis.yml
new file mode 100644
index 000000000..2d26206d5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/.travis.yml
@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - 0.6
diff --git a/node_modules/tar.gz/node_modules/fstream/LICENSE b/node_modules/tar.gz/node_modules/fstream/LICENSE
new file mode 100644
index 000000000..0c44ae716
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) Isaac Z. Schlueter ("Author")
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/tar.gz/node_modules/fstream/README.md b/node_modules/tar.gz/node_modules/fstream/README.md
new file mode 100644
index 000000000..9d8cb77e5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/README.md
@@ -0,0 +1,76 @@
+Like FS streams, but with stat on them, and supporting directories and
+symbolic links, as well as normal files.  Also, you can use this to set
+the stats on a file, even if you don't change its contents, or to create
+a symlink, etc.
+
+So, for example, you can "write" a directory, and it'll call `mkdir`.  You
+can specify a uid and gid, and it'll call `chown`.  You can specify a
+`mtime` and `atime`, and it'll call `utimes`.  You can call it a symlink
+and provide a `linkpath` and it'll call `symlink`.
+
+Note that it won't automatically resolve symbolic links.  So, if you
+call `fstream.Reader('/some/symlink')` then you'll get an object
+that stats and then ends immediately (since it has no data).  To follow
+symbolic links, do this: `fstream.Reader({path:'/some/symlink', follow:
+true })`.
+
+There are various checks to make sure that the bytes emitted are the
+same as the intended size, if the size is set.
+
+## Examples
+
+```javascript
+fstream
+  .Writer({ path: "path/to/file"
+          , mode: 0755
+          , size: 6
+          })
+  .write("hello\n")
+  .end()
+```
+
+This will create the directories if they're missing, and then write
+`hello\n` into the file, chmod it to 0755, and assert that 6 bytes have
+been written when it's done.
+
+```javascript
+fstream
+  .Writer({ path: "path/to/file"
+          , mode: 0755
+          , size: 6
+          , flags: "a"
+          })
+  .write("hello\n")
+  .end()
+```
+
+You can pass flags in, if you want to append to a file.
+
+```javascript
+fstream
+  .Writer({ path: "path/to/symlink"
+          , linkpath: "./file"
+          , SymbolicLink: true
+          , mode: "0755" // octal strings supported
+          })
+  .end()
+```
+
+If isSymbolicLink is a function, it'll be called, and if it returns
+true, then it'll treat it as a symlink.  If it's not a function, then
+any truish value will make a symlink, or you can set `type:
+'SymbolicLink'`, which does the same thing.
+
+Note that the linkpath is relative to the symbolic link location, not
+the parent dir or cwd.
+
+```javascript
+fstream
+  .Reader("path/to/dir")
+  .pipe(fstream.Writer("path/to/other/dir"))
+```
+
+This will do like `cp -Rp path/to/dir path/to/other/dir`.  If the other
+dir exists and isn't a directory, then it'll emit an error.  It'll also
+set the uid, gid, mode, etc. to be identical.  In this way, it's more
+like `rsync -a` than simply a copy.
diff --git a/node_modules/tar.gz/node_modules/fstream/examples/filter-pipe.js b/node_modules/tar.gz/node_modules/fstream/examples/filter-pipe.js
new file mode 100644
index 000000000..c6b55b3e0
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/examples/filter-pipe.js
@@ -0,0 +1,131 @@
+var fstream = require("../fstream.js")
+var path = require("path")
+
+var r = fstream.Reader({ path: path.dirname(__dirname)
+                       , filter: function () {
+                           return !this.basename.match(/^\./) &&
+                                  !this.basename.match(/^node_modules$/)
+                                  !this.basename.match(/^deep-copy$/)
+                                  !this.basename.match(/^filter-copy$/)
+                         }
+                       })
+
+// this writer will only write directories
+var w = fstream.Writer({ path: path.resolve(__dirname, "filter-copy")
+                       , type: "Directory"
+                       , filter: function () {
+                           return this.type === "Directory"
+                         }
+                       })
+
+var indent = ""
+var escape = {}
+
+r.on("entry", appears)
+r.on("ready", function () {
+  console.error("ready to begin!", r.path)
+})
+
+function appears (entry) {
+  console.error(indent + "a %s appears!", entry.type, entry.basename, typeof entry.basename)
+  if (foggy) {
+    console.error("FOGGY!")
+    var p = entry
+    do {
+      console.error(p.depth, p.path, p._paused)
+    } while (p = p.parent)
+
+    throw new Error("\033[mshould not have entries while foggy")
+  }
+  indent += "\t"
+  entry.on("data", missile(entry))
+  entry.on("end", runaway(entry))
+  entry.on("entry", appears)
+}
+
+var foggy
+function missile (entry) {
+  if (entry.type === "Directory") {
+    var ended = false
+    entry.once("end", function () { ended = true })
+    return function (c) {
+      // throw in some pathological pause()/resume() behavior
+      // just for extra fun.
+      process.nextTick(function () {
+        if (!foggy && !ended) { // && Math.random() < 0.3) {
+          console.error(indent +"%s casts a spell", entry.basename)
+          console.error("\na slowing fog comes over the battlefield...\n\033[32m")
+          entry.pause()
+          entry.once("resume", liftFog)
+          foggy = setTimeout(liftFog, 1000)
+
+          function liftFog (who) {
+            if (!foggy) return
+            if (who) {
+              console.error("%s breaks the spell!", who && who.path)
+            } else {
+              console.error("the spell expires!")
+            }
+            console.error("\033[mthe fog lifts!\n")
+            clearTimeout(foggy)
+            foggy = null
+            if (entry._paused) entry.resume()
+          }
+
+        }
+      })
+    }
+  }
+
+  return function (c) {
+    var e = Math.random() < 0.5
+    console.error(indent + "%s %s for %d damage!",
+                entry.basename,
+                e ? "is struck" : "fires a chunk",
+                c.length)
+  }
+}
+
+function runaway (entry) { return function () {
+  var e = Math.random() < 0.5
+  console.error(indent + "%s %s",
+                entry.basename,
+                e ? "turns to flee" : "is vanquished!")
+  indent = indent.slice(0, -1)
+}}
+
+
+w.on("entry", attacks)
+//w.on("ready", function () { attacks(w) })
+function attacks (entry) {
+  console.error(indent + "%s %s!", entry.basename,
+              entry.type === "Directory" ? "calls for backup" : "attacks")
+  entry.on("entry", attacks)
+}
+
+ended = false
+var i = 1
+r.on("end", function () {
+  if (foggy) clearTimeout(foggy)
+  console.error("\033[mIT'S OVER!!")
+  console.error("A WINNAR IS YOU!")
+
+  console.log("ok " + (i ++) + " A WINNAR IS YOU")
+  ended = true
+  // now go through and verify that everything in there is a dir.
+  var p = path.resolve(__dirname, "filter-copy")
+  var checker = fstream.Reader({ path: p })
+  checker.checker = true
+  checker.on("child", function (e) {
+    var ok = e.type === "Directory"
+    console.log((ok ? "" : "not ") + "ok " + (i ++) +
+                " should be a dir: " +
+                e.path.substr(checker.path.length + 1))
+  })
+})
+
+process.on("exit", function () {
+  console.log((ended ? "" : "not ") + "ok " + (i ++) + " ended")
+})
+
+r.pipe(w)
diff --git a/node_modules/tar.gz/node_modules/fstream/examples/pipe.js b/node_modules/tar.gz/node_modules/fstream/examples/pipe.js
new file mode 100644
index 000000000..648ec8493
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/examples/pipe.js
@@ -0,0 +1,115 @@
+var fstream = require("../fstream.js")
+var path = require("path")
+
+var r = fstream.Reader({ path: path.dirname(__dirname)
+                       , filter: function () {
+                           return !this.basename.match(/^\./) &&
+                                  !this.basename.match(/^node_modules$/)
+                                  !this.basename.match(/^deep-copy$/)
+                         }
+                       })
+
+var w = fstream.Writer({ path: path.resolve(__dirname, "deep-copy")
+                       , type: "Directory"
+                       })
+
+var indent = ""
+var escape = {}
+
+r.on("entry", appears)
+r.on("ready", function () {
+  console.error("ready to begin!", r.path)
+})
+
+function appears (entry) {
+  console.error(indent + "a %s appears!", entry.type, entry.basename, typeof entry.basename, entry)
+  if (foggy) {
+    console.error("FOGGY!")
+    var p = entry
+    do {
+      console.error(p.depth, p.path, p._paused)
+    } while (p = p.parent)
+
+    throw new Error("\033[mshould not have entries while foggy")
+  }
+  indent += "\t"
+  entry.on("data", missile(entry))
+  entry.on("end", runaway(entry))
+  entry.on("entry", appears)
+}
+
+var foggy
+function missile (entry) {
+  if (entry.type === "Directory") {
+    var ended = false
+    entry.once("end", function () { ended = true })
+    return function (c) {
+      // throw in some pathological pause()/resume() behavior
+      // just for extra fun.
+      process.nextTick(function () {
+        if (!foggy && !ended) { // && Math.random() < 0.3) {
+          console.error(indent +"%s casts a spell", entry.basename)
+          console.error("\na slowing fog comes over the battlefield...\n\033[32m")
+          entry.pause()
+          entry.once("resume", liftFog)
+          foggy = setTimeout(liftFog, 10)
+
+          function liftFog (who) {
+            if (!foggy) return
+            if (who) {
+              console.error("%s breaks the spell!", who && who.path)
+            } else {
+              console.error("the spell expires!")
+            }
+            console.error("\033[mthe fog lifts!\n")
+            clearTimeout(foggy)
+            foggy = null
+            if (entry._paused) entry.resume()
+          }
+
+        }
+      })
+    }
+  }
+
+  return function (c) {
+    var e = Math.random() < 0.5
+    console.error(indent + "%s %s for %d damage!",
+                entry.basename,
+                e ? "is struck" : "fires a chunk",
+                c.length)
+  }
+}
+
+function runaway (entry) { return function () {
+  var e = Math.random() < 0.5
+  console.error(indent + "%s %s",
+                entry.basename,
+                e ? "turns to flee" : "is vanquished!")
+  indent = indent.slice(0, -1)
+}}
+
+
+w.on("entry", attacks)
+//w.on("ready", function () { attacks(w) })
+function attacks (entry) {
+  console.error(indent + "%s %s!", entry.basename,
+              entry.type === "Directory" ? "calls for backup" : "attacks")
+  entry.on("entry", attacks)
+}
+
+ended = false
+r.on("end", function () {
+  if (foggy) clearTimeout(foggy)
+  console.error("\033[mIT'S OVER!!")
+  console.error("A WINNAR IS YOU!")
+
+  console.log("ok 1 A WINNAR IS YOU")
+  ended = true
+})
+
+process.on("exit", function () {
+  console.log((ended ? "" : "not ") + "ok 2 ended")
+})
+
+r.pipe(w)
diff --git a/node_modules/tar.gz/node_modules/fstream/examples/reader.js b/node_modules/tar.gz/node_modules/fstream/examples/reader.js
new file mode 100644
index 000000000..9aa1a9538
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/examples/reader.js
@@ -0,0 +1,54 @@
+var fstream = require("../fstream.js")
+var tap = require("tap")
+var fs = require("fs")
+var path = require("path")
+var children = -1
+var dir = path.dirname(__dirname)
+
+var gotReady = false
+var ended = false
+
+tap.test("reader test", function (t) {
+
+  var r = fstream.Reader({ path: dir
+                         , filter: function () {
+                             // return this.parent === r
+                             return this.parent === r || this === r
+                           }
+                         })
+
+  r.on("ready", function () {
+    gotReady = true
+    children = fs.readdirSync(dir).length
+    console.error("Setting expected children to "+children)
+    t.equal(r.type, "Directory", "should be a directory")
+  })
+
+  r.on("entry", function (entry) {
+    children --
+    if (!gotReady) {
+      t.fail("children before ready!")
+    }
+    t.equal(entry.dirname, r.path, "basename is parent dir")
+  })
+
+  r.on("error", function (er) {
+    t.fail(er)
+    t.end()
+    process.exit(1)
+  })
+
+  r.on("end", function () {
+    t.equal(children, 0, "should have seen all children")
+    ended = true
+  })
+
+  var closed = false
+  r.on("close", function () {
+    t.ok(ended, "saw end before close")
+    t.notOk(closed, "close should only happen once")
+    closed = true
+    t.end()
+  })
+
+})
diff --git a/node_modules/tar.gz/node_modules/fstream/examples/symlink-write.js b/node_modules/tar.gz/node_modules/fstream/examples/symlink-write.js
new file mode 100644
index 000000000..d7816d24d
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/examples/symlink-write.js
@@ -0,0 +1,24 @@
+var fstream = require("../fstream.js")
+  , closed = false
+
+fstream
+  .Writer({ path: "path/to/symlink"
+          , linkpath: "./file"
+          , isSymbolicLink: true
+          , mode: "0755" // octal strings supported
+          })
+  .on("close", function () {
+    closed = true
+    var fs = require("fs")
+    var s = fs.lstatSync("path/to/symlink")
+    var isSym = s.isSymbolicLink()
+    console.log((isSym?"":"not ") +"ok 1 should be symlink")
+    var t = fs.readlinkSync("path/to/symlink")
+    var isTarget = t === "./file"
+    console.log((isTarget?"":"not ") +"ok 2 should link to ./file")
+  })
+  .end()
+
+process.on("exit", function () {
+  console.log((closed?"":"not ")+"ok 3 should be closed")
+})
diff --git a/node_modules/tar.gz/node_modules/fstream/fstream.js b/node_modules/tar.gz/node_modules/fstream/fstream.js
new file mode 100644
index 000000000..c66d26f51
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/fstream.js
@@ -0,0 +1,31 @@
+exports.Abstract = require("./lib/abstract.js")
+exports.Reader = require("./lib/reader.js")
+exports.Writer = require("./lib/writer.js")
+
+exports.File =
+  { Reader: require("./lib/file-reader.js")
+  , Writer: require("./lib/file-writer.js") }
+
+exports.Dir = 
+  { Reader : require("./lib/dir-reader.js")
+  , Writer : require("./lib/dir-writer.js") }
+
+exports.Link =
+  { Reader : require("./lib/link-reader.js")
+  , Writer : require("./lib/link-writer.js") }
+
+exports.Proxy =
+  { Reader : require("./lib/proxy-reader.js")
+  , Writer : require("./lib/proxy-writer.js") }
+
+exports.Reader.Dir = exports.DirReader = exports.Dir.Reader
+exports.Reader.File = exports.FileReader = exports.File.Reader
+exports.Reader.Link = exports.LinkReader = exports.Link.Reader
+exports.Reader.Proxy = exports.ProxyReader = exports.Proxy.Reader
+
+exports.Writer.Dir = exports.DirWriter = exports.Dir.Writer
+exports.Writer.File = exports.FileWriter = exports.File.Writer
+exports.Writer.Link = exports.LinkWriter = exports.Link.Writer
+exports.Writer.Proxy = exports.ProxyWriter = exports.Proxy.Writer
+
+exports.collect = require("./lib/collect.js")
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/abstract.js b/node_modules/tar.gz/node_modules/fstream/lib/abstract.js
new file mode 100644
index 000000000..11ef0e28f
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/abstract.js
@@ -0,0 +1,85 @@
+// the parent class for all fstreams.
+
+module.exports = Abstract
+
+var Stream = require("stream").Stream
+  , inherits = require("inherits")
+
+function Abstract () {
+  Stream.call(this)
+}
+
+inherits(Abstract, Stream)
+
+Abstract.prototype.on = function (ev, fn) {
+  if (ev === "ready" && this.ready) {
+    process.nextTick(fn.bind(this))
+  } else {
+    Stream.prototype.on.call(this, ev, fn)
+  }
+  return this
+}
+
+Abstract.prototype.abort = function () {
+  this._aborted = true
+  this.emit("abort")
+}
+
+Abstract.prototype.destroy = function () {}
+
+Abstract.prototype.warn = function (msg, code) {
+  var me = this
+    , er = decorate(msg, code, me)
+  if (!me.listeners("warn")) {
+    console.error("%s %s\n" +
+                  "path = %s\n" +
+                  "syscall = %s\n" +
+                  "fstream_type = %s\n" +
+                  "fstream_path = %s\n" +
+                  "fstream_unc_path = %s\n" +
+                  "fstream_class = %s\n" +
+                  "fstream_stack =\n%s\n",
+                  code || "UNKNOWN",
+                  er.stack,
+                  er.path,
+                  er.syscall,
+                  er.fstream_type,
+                  er.fstream_path,
+                  er.fstream_unc_path,
+                  er.fstream_class,
+                  er.fstream_stack.join("\n"))
+  } else {
+    me.emit("warn", er)
+  }
+}
+
+Abstract.prototype.info = function (msg, code) {
+  this.emit("info", msg, code)
+}
+
+Abstract.prototype.error = function (msg, code, th) {
+  var er = decorate(msg, code, this)
+  if (th) throw er
+  else this.emit("error", er)
+}
+
+function decorate (er, code, me) {
+  if (!(er instanceof Error)) er = new Error(er)
+  er.code = er.code || code
+  er.path = er.path || me.path
+  er.fstream_type = er.fstream_type || me.type
+  er.fstream_path = er.fstream_path || me.path
+  if (me._path !== me.path) {
+    er.fstream_unc_path = er.fstream_unc_path || me._path
+  }
+  if (me.linkpath) {
+    er.fstream_linkpath = er.fstream_linkpath || me.linkpath
+  }
+  er.fstream_class = er.fstream_class || me.constructor.name
+  er.fstream_stack = er.fstream_stack ||
+    new Error().stack.split(/\n/).slice(3).map(function (s) {
+      return s.replace(/^    at /, "")
+    })
+
+  return er
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/collect.js b/node_modules/tar.gz/node_modules/fstream/lib/collect.js
new file mode 100644
index 000000000..a36f780eb
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/collect.js
@@ -0,0 +1,67 @@
+module.exports = collect
+
+function collect (stream) {
+  if (stream._collected) return
+
+  stream._collected = true
+  stream.pause()
+
+  stream.on("data", save)
+  stream.on("end", save)
+  var buf = []
+  function save (b) {
+    if (typeof b === "string") b = new Buffer(b)
+    if (Buffer.isBuffer(b) && !b.length) return
+    buf.push(b)
+  }
+
+  stream.on("entry", saveEntry)
+  var entryBuffer = []
+  function saveEntry (e) {
+    collect(e)
+    entryBuffer.push(e)
+  }
+
+  stream.on("proxy", proxyPause)
+  function proxyPause (p) {
+    p.pause()
+  }
+
+
+  // replace the pipe method with a new version that will
+  // unlock the buffered stuff.  if you just call .pipe()
+  // without a destination, then it'll re-play the events.
+  stream.pipe = (function (orig) { return function (dest) {
+    // console.error(" === open the pipes", dest && dest.path)
+
+    // let the entries flow through one at a time.
+    // Once they're all done, then we can resume completely.
+    var e = 0
+    ;(function unblockEntry () {
+      var entry = entryBuffer[e++]
+      // console.error(" ==== unblock entry", entry && entry.path)
+      if (!entry) return resume()
+      entry.on("end", unblockEntry)
+      if (dest) dest.add(entry)
+      else stream.emit("entry", entry)
+    })()
+
+    function resume () {
+      stream.removeListener("entry", saveEntry)
+      stream.removeListener("data", save)
+      stream.removeListener("end", save)
+
+      stream.pipe = orig
+      if (dest) stream.pipe(dest)
+
+      buf.forEach(function (b) {
+        if (b) stream.emit("data", b)
+        else stream.emit("end")
+      })
+
+      stream.resume()
+    }
+
+    return dest
+  }})(stream.pipe)
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/dir-reader.js b/node_modules/tar.gz/node_modules/fstream/lib/dir-reader.js
new file mode 100644
index 000000000..346ac2b83
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/dir-reader.js
@@ -0,0 +1,251 @@
+// A thing that emits "entry" events with Reader objects
+// Pausing it causes it to stop emitting entry events, and also
+// pauses the current entry if there is one.
+
+module.exports = DirReader
+
+var fs = require("graceful-fs")
+  , fstream = require("../fstream.js")
+  , Reader = fstream.Reader
+  , inherits = require("inherits")
+  , mkdir = require("mkdirp")
+  , path = require("path")
+  , Reader = require("./reader.js")
+  , assert = require("assert").ok
+
+inherits(DirReader, Reader)
+
+function DirReader (props) {
+  var me = this
+  if (!(me instanceof DirReader)) throw new Error(
+    "DirReader must be called as constructor.")
+
+  // should already be established as a Directory type
+  if (props.type !== "Directory" || !props.Directory) {
+    throw new Error("Non-directory type "+ props.type)
+  }
+
+  me.entries = null
+  me._index = -1
+  me._paused = false
+  me._length = -1
+
+  if (props.sort) {
+    this.sort = props.sort
+  }
+
+  Reader.call(this, props)
+}
+
+DirReader.prototype._getEntries = function () {
+  var me = this
+
+  // race condition.  might pause() before calling _getEntries,
+  // and then resume, and try to get them a second time.
+  if (me._gotEntries) return
+  me._gotEntries = true
+
+  fs.readdir(me._path, function (er, entries) {
+    if (er) return me.error(er)
+
+    me.entries = entries
+
+    me.emit("entries", entries)
+    if (me._paused) me.once("resume", processEntries)
+    else processEntries()
+
+    function processEntries () {
+      me._length = me.entries.length
+      if (typeof me.sort === "function") {
+        me.entries = me.entries.sort(me.sort.bind(me))
+      }
+      me._read()
+    }
+  })
+}
+
+// start walking the dir, and emit an "entry" event for each one.
+DirReader.prototype._read = function () {
+  var me = this
+
+  if (!me.entries) return me._getEntries()
+
+  if (me._paused || me._currentEntry || me._aborted) {
+    // console.error("DR paused=%j, current=%j, aborted=%j", me._paused, !!me._currentEntry, me._aborted)
+    return
+  }
+
+  me._index ++
+  if (me._index >= me.entries.length) {
+    if (!me._ended) {
+      me._ended = true
+      me.emit("end")
+      me.emit("close")
+    }
+    return
+  }
+
+  // ok, handle this one, then.
+
+  // save creating a proxy, by stat'ing the thing now.
+  var p = path.resolve(me._path, me.entries[me._index])
+  assert(p !== me._path)
+  assert(me.entries[me._index])
+
+  // set this to prevent trying to _read() again in the stat time.
+  me._currentEntry = p
+  fs[ me.props.follow ? "stat" : "lstat" ](p, function (er, stat) {
+    if (er) return me.error(er)
+
+    var who = me._proxy || me
+
+    stat.path = p
+    stat.basename = path.basename(p)
+    stat.dirname = path.dirname(p)
+    var childProps = me.getChildProps.call(who, stat)
+    childProps.path = p
+    childProps.basename = path.basename(p)
+    childProps.dirname = path.dirname(p)
+
+    var entry = Reader(childProps, stat)
+
+    // console.error("DR Entry", p, stat.size)
+
+    me._currentEntry = entry
+
+    // "entry" events are for direct entries in a specific dir.
+    // "child" events are for any and all children at all levels.
+    // This nomenclature is not completely final.
+
+    entry.on("pause", function (who) {
+      if (!me._paused && !entry._disowned) {
+        me.pause(who)
+      }
+    })
+
+    entry.on("resume", function (who) {
+      if (me._paused && !entry._disowned) {
+        me.resume(who)
+      }
+    })
+
+    entry.on("stat", function (props) {
+      me.emit("_entryStat", entry, props)
+      if (entry._aborted) return
+      if (entry._paused) entry.once("resume", function () {
+        me.emit("entryStat", entry, props)
+      })
+      else me.emit("entryStat", entry, props)
+    })
+
+    entry.on("ready", function EMITCHILD () {
+      // console.error("DR emit child", entry._path)
+      if (me._paused) {
+        // console.error("  DR emit child - try again later")
+        // pause the child, and emit the "entry" event once we drain.
+        // console.error("DR pausing child entry")
+        entry.pause(me)
+        return me.once("resume", EMITCHILD)
+      }
+
+      // skip over sockets.  they can't be piped around properly,
+      // so there's really no sense even acknowledging them.
+      // if someone really wants to see them, they can listen to
+      // the "socket" events.
+      if (entry.type === "Socket") {
+        me.emit("socket", entry)
+      } else {
+        me.emitEntry(entry)
+      }
+    })
+
+    var ended = false
+    entry.on("close", onend)
+    entry.on("disown", onend)
+    function onend () {
+      if (ended) return
+      ended = true
+      me.emit("childEnd", entry)
+      me.emit("entryEnd", entry)
+      me._currentEntry = null
+      if (!me._paused) {
+        me._read()
+      }
+    }
+
+    // XXX Remove this.  Works in node as of 0.6.2 or so.
+    // Long filenames should not break stuff.
+    entry.on("error", function (er) {
+      if (entry._swallowErrors) {
+        me.warn(er)
+        entry.emit("end")
+        entry.emit("close")
+      } else {
+        me.emit("error", er)
+      }
+    })
+
+    // proxy up some events.
+    ; [ "child"
+      , "childEnd"
+      , "warn"
+      ].forEach(function (ev) {
+        entry.on(ev, me.emit.bind(me, ev))
+      })
+  })
+}
+
+DirReader.prototype.disown = function (entry) {
+  entry.emit("beforeDisown")
+  entry._disowned = true
+  entry.parent = entry.root = null
+  if (entry === this._currentEntry) {
+    this._currentEntry = null
+  }
+  entry.emit("disown")
+}
+
+DirReader.prototype.getChildProps = function (stat) {
+  return { depth: this.depth + 1
+         , root: this.root || this
+         , parent: this
+         , follow: this.follow
+         , filter: this.filter
+         , sort: this.props.sort
+         , hardlinks: this.props.hardlinks
+         }
+}
+
+DirReader.prototype.pause = function (who) {
+  var me = this
+  if (me._paused) return
+  who = who || me
+  me._paused = true
+  if (me._currentEntry && me._currentEntry.pause) {
+    me._currentEntry.pause(who)
+  }
+  me.emit("pause", who)
+}
+
+DirReader.prototype.resume = function (who) {
+  var me = this
+  if (!me._paused) return
+  who = who || me
+
+  me._paused = false
+  // console.error("DR Emit Resume", me._path)
+  me.emit("resume", who)
+  if (me._paused) {
+    // console.error("DR Re-paused", me._path)
+    return
+  }
+
+  if (me._currentEntry) {
+    if (me._currentEntry.resume) me._currentEntry.resume(who)
+  } else me._read()
+}
+
+DirReader.prototype.emitEntry = function (entry) {
+  this.emit("entry", entry)
+  this.emit("child", entry)
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/dir-writer.js b/node_modules/tar.gz/node_modules/fstream/lib/dir-writer.js
new file mode 100644
index 000000000..7073b883e
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/dir-writer.js
@@ -0,0 +1,171 @@
+// It is expected that, when .add() returns false, the consumer
+// of the DirWriter will pause until a "drain" event occurs. Note
+// that this is *almost always going to be the case*, unless the
+// thing being written is some sort of unsupported type, and thus
+// skipped over.
+
+module.exports = DirWriter
+
+var fs = require("graceful-fs")
+  , fstream = require("../fstream.js")
+  , Writer = require("./writer.js")
+  , inherits = require("inherits")
+  , mkdir = require("mkdirp")
+  , path = require("path")
+  , collect = require("./collect.js")
+
+inherits(DirWriter, Writer)
+
+function DirWriter (props) {
+  var me = this
+  if (!(me instanceof DirWriter)) me.error(
+    "DirWriter must be called as constructor.", null, true)
+
+  // should already be established as a Directory type
+  if (props.type !== "Directory" || !props.Directory) {
+    me.error("Non-directory type "+ props.type + " " +
+                    JSON.stringify(props), null, true)
+  }
+
+  Writer.call(this, props)
+}
+
+DirWriter.prototype._create = function () {
+  var me = this
+  mkdir(me._path, Writer.dirmode, function (er) {
+    if (er) return me.error(er)
+    // ready to start getting entries!
+    me.ready = true
+    me.emit("ready")
+    me._process()
+  })
+}
+
+// a DirWriter has an add(entry) method, but its .write() doesn't
+// do anything.  Why a no-op rather than a throw?  Because this
+// leaves open the door for writing directory metadata for
+// gnu/solaris style dumpdirs.
+DirWriter.prototype.write = function () {
+  return true
+}
+
+DirWriter.prototype.end = function () {
+  this._ended = true
+  this._process()
+}
+
+DirWriter.prototype.add = function (entry) {
+  var me = this
+
+  // console.error("\tadd", entry._path, "->", me._path)
+  collect(entry)
+  if (!me.ready || me._currentEntry) {
+    me._buffer.push(entry)
+    return false
+  }
+
+  // create a new writer, and pipe the incoming entry into it.
+  if (me._ended) {
+    return me.error("add after end")
+  }
+
+  me._buffer.push(entry)
+  me._process()
+
+  return 0 === this._buffer.length
+}
+
+DirWriter.prototype._process = function () {
+  var me = this
+
+  // console.error("DW Process p=%j", me._processing, me.basename)
+
+  if (me._processing) return
+
+  var entry = me._buffer.shift()
+  if (!entry) {
+    // console.error("DW Drain")
+    me.emit("drain")
+    if (me._ended) me._finish()
+    return
+  }
+
+  me._processing = true
+  // console.error("DW Entry", entry._path)
+
+  me.emit("entry", entry)
+
+  // ok, add this entry
+  //
+  // don't allow recursive copying
+  var p = entry
+  do {
+    var pp = p._path || p.path
+    if (pp === me.root._path || pp === me._path ||
+        (pp && pp.indexOf(me._path) === 0)) {
+      // console.error("DW Exit (recursive)", entry.basename, me._path)
+      me._processing = false
+      if (entry._collected) entry.pipe()
+      return me._process()
+    }
+  } while (p = p.parent)
+
+  // console.error("DW not recursive")
+
+  // chop off the entry's root dir, replace with ours
+  var props = { parent: me
+              , root: me.root || me
+              , type: entry.type
+              , depth: me.depth + 1 }
+
+  var p = entry._path || entry.path || entry.props.path
+  if (entry.parent) {
+    p = p.substr(entry.parent._path.length + 1)
+  }
+  // get rid of any ../../ shenanigans
+  props.path = path.join(me.path, path.join("/", p))
+
+  // if i have a filter, the child should inherit it.
+  props.filter = me.filter
+
+  // all the rest of the stuff, copy over from the source.
+  Object.keys(entry.props).forEach(function (k) {
+    if (!props.hasOwnProperty(k)) {
+      props[k] = entry.props[k]
+    }
+  })
+
+  // not sure at this point what kind of writer this is.
+  var child = me._currentChild = new Writer(props)
+  child.on("ready", function () {
+    // console.error("DW Child Ready", child.type, child._path)
+    // console.error("  resuming", entry._path)
+    entry.pipe(child)
+    entry.resume()
+  })
+
+  // XXX Make this work in node.
+  // Long filenames should not break stuff.
+  child.on("error", function (er) {
+    if (child._swallowErrors) {
+      me.warn(er)
+      child.emit("end")
+      child.emit("close")
+    } else {
+      me.emit("error", er)
+    }
+  })
+
+  // we fire _end internally *after* end, so that we don't move on
+  // until any "end" listeners have had their chance to do stuff.
+  child.on("close", onend)
+  var ended = false
+  function onend () {
+    if (ended) return
+    ended = true
+    // console.error("* DW Child end", child.basename)
+    me._currentChild = null
+    me._processing = false
+    me._process()
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/file-reader.js b/node_modules/tar.gz/node_modules/fstream/lib/file-reader.js
new file mode 100644
index 000000000..b1f986183
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/file-reader.js
@@ -0,0 +1,147 @@
+// Basically just a wrapper around an fs.ReadStream
+
+module.exports = FileReader
+
+var fs = require("graceful-fs")
+  , fstream = require("../fstream.js")
+  , Reader = fstream.Reader
+  , inherits = require("inherits")
+  , mkdir = require("mkdirp")
+  , Reader = require("./reader.js")
+  , EOF = {EOF: true}
+  , CLOSE = {CLOSE: true}
+
+inherits(FileReader, Reader)
+
+function FileReader (props) {
+  // console.error("    FR create", props.path, props.size, new Error().stack)
+  var me = this
+  if (!(me instanceof FileReader)) throw new Error(
+    "FileReader must be called as constructor.")
+
+  // should already be established as a File type
+  // XXX Todo: preserve hardlinks by tracking dev+inode+nlink,
+  // with a HardLinkReader class.
+  if (!((props.type === "Link" && props.Link) ||
+        (props.type === "File" && props.File))) {
+    throw new Error("Non-file type "+ props.type)
+  }
+
+  me._buffer = []
+  me._bytesEmitted = 0
+  Reader.call(me, props)
+}
+
+FileReader.prototype._getStream = function () {
+  var me = this
+    , stream = me._stream = fs.createReadStream(me._path, me.props)
+
+  if (me.props.blksize) {
+    stream.bufferSize = me.props.blksize
+  }
+
+  stream.on("open", me.emit.bind(me, "open"))
+
+  stream.on("data", function (c) {
+    // console.error("\t\t%d %s", c.length, me.basename)
+    me._bytesEmitted += c.length
+    // no point saving empty chunks
+    if (!c.length) return
+    else if (me._paused || me._buffer.length) {
+      me._buffer.push(c)
+      me._read()
+    } else me.emit("data", c)
+  })
+
+  stream.on("end", function () {
+    if (me._paused || me._buffer.length) {
+      // console.error("FR Buffering End", me._path)
+      me._buffer.push(EOF)
+      me._read()
+    } else {
+      me.emit("end")
+    }
+
+    if (me._bytesEmitted !== me.props.size) {
+      me.error("Didn't get expected byte count\n"+
+               "expect: "+me.props.size + "\n" +
+               "actual: "+me._bytesEmitted)
+    }
+  })
+
+  stream.on("close", function () {
+    if (me._paused || me._buffer.length) {
+      // console.error("FR Buffering Close", me._path)
+      me._buffer.push(CLOSE)
+      me._read()
+    } else {
+      // console.error("FR close 1", me._path)
+      me.emit("close")
+    }
+  })
+
+  me._read()
+}
+
+FileReader.prototype._read = function () {
+  var me = this
+  // console.error("FR _read", me._path)
+  if (me._paused) {
+    // console.error("FR _read paused", me._path)
+    return
+  }
+
+  if (!me._stream) {
+    // console.error("FR _getStream calling", me._path)
+    return me._getStream()
+  }
+
+  // clear out the buffer, if there is one.
+  if (me._buffer.length) {
+    // console.error("FR _read has buffer", me._buffer.length, me._path)
+    var buf = me._buffer
+    for (var i = 0, l = buf.length; i < l; i ++) {
+      var c = buf[i]
+      if (c === EOF) {
+        // console.error("FR Read emitting buffered end", me._path)
+        me.emit("end")
+      } else if (c === CLOSE) {
+        // console.error("FR Read emitting buffered close", me._path)
+        me.emit("close")
+      } else {
+        // console.error("FR Read emitting buffered data", me._path)
+        me.emit("data", c)
+      }
+
+      if (me._paused) {
+        // console.error("FR Read Re-pausing at "+i, me._path)
+        me._buffer = buf.slice(i)
+        return
+      }
+    }
+    me._buffer.length = 0
+  }
+  // console.error("FR _read done")
+  // that's about all there is to it.
+}
+
+FileReader.prototype.pause = function (who) {
+  var me = this
+  // console.error("FR Pause", me._path)
+  if (me._paused) return
+  who = who || me
+  me._paused = true
+  if (me._stream) me._stream.pause()
+  me.emit("pause", who)
+}
+
+FileReader.prototype.resume = function (who) {
+  var me = this
+  // console.error("FR Resume", me._path)
+  if (!me._paused) return
+  who = who || me
+  me.emit("resume", who)
+  me._paused = false
+  if (me._stream) me._stream.resume()
+  me._read()
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/file-writer.js b/node_modules/tar.gz/node_modules/fstream/lib/file-writer.js
new file mode 100644
index 000000000..5e9902a63
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/file-writer.js
@@ -0,0 +1,104 @@
+module.exports = FileWriter
+
+var fs = require("graceful-fs")
+  , mkdir = require("mkdirp")
+  , Writer = require("./writer.js")
+  , inherits = require("inherits")
+  , EOF = {}
+
+inherits(FileWriter, Writer)
+
+function FileWriter (props) {
+  var me = this
+  if (!(me instanceof FileWriter)) throw new Error(
+    "FileWriter must be called as constructor.")
+
+  // should already be established as a File type
+  if (props.type !== "File" || !props.File) {
+    throw new Error("Non-file type "+ props.type)
+  }
+
+  me._buffer = []
+  me._bytesWritten = 0
+
+  Writer.call(this, props)
+}
+
+FileWriter.prototype._create = function () {
+  var me = this
+  if (me._stream) return
+
+  var so = {}
+  if (me.props.flags) so.flags = me.props.flags
+  so.mode = Writer.filemode
+  if (me._old && me._old.blksize) so.bufferSize = me._old.blksize
+
+  me._stream = fs.createWriteStream(me._path, so)
+
+  me._stream.on("open", function (fd) {
+    // console.error("FW open", me._buffer, me._path)
+    me.ready = true
+    me._buffer.forEach(function (c) {
+      if (c === EOF) me._stream.end()
+      else me._stream.write(c)
+    })
+    me.emit("ready")
+    // give this a kick just in case it needs it.
+    me.emit("drain")
+  })
+
+  me._stream.on("drain", function () { me.emit("drain") })
+
+  me._stream.on("close", function () {
+    // console.error("\n\nFW Stream Close", me._path, me.size)
+    me._finish()
+  })
+}
+
+FileWriter.prototype.write = function (c) {
+  var me = this
+
+  me._bytesWritten += c.length
+
+  if (!me.ready) {
+    if (!Buffer.isBuffer(c) && typeof c !== 'string')
+      throw new Error('invalid write data')
+    me._buffer.push(c)
+    return false
+  }
+
+  var ret = me._stream.write(c)
+  // console.error("\t-- fw wrote, _stream says", ret, me._stream._queue.length)
+
+  // allow 2 buffered writes, because otherwise there's just too
+  // much stop and go bs.
+  if (ret === false && me._stream._queue) {
+    return me._stream._queue.length <= 2;
+  } else {
+    return ret;
+  }
+}
+
+FileWriter.prototype.end = function (c) {
+  var me = this
+
+  if (c) me.write(c)
+
+  if (!me.ready) {
+    me._buffer.push(EOF)
+    return false
+  }
+
+  return me._stream.end()
+}
+
+FileWriter.prototype._finish = function () {
+  var me = this
+  if (typeof me.size === "number" && me._bytesWritten != me.size) {
+    me.error(
+      "Did not get expected byte count.\n" +
+      "expect: " + me.size + "\n" +
+      "actual: " + me._bytesWritten)
+  }
+  Writer.prototype._finish.call(me)
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/get-type.js b/node_modules/tar.gz/node_modules/fstream/lib/get-type.js
new file mode 100644
index 000000000..cd65c41d8
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/get-type.js
@@ -0,0 +1,32 @@
+module.exports = getType
+
+function getType (st) {
+  var types =
+      [ "Directory"
+      , "File"
+      , "SymbolicLink"
+      , "Link" // special for hardlinks from tarballs
+      , "BlockDevice"
+      , "CharacterDevice"
+      , "FIFO"
+      , "Socket" ]
+    , type
+
+  if (st.type && -1 !== types.indexOf(st.type)) {
+    st[st.type] = true
+    return st.type
+  }
+
+  for (var i = 0, l = types.length; i < l; i ++) {
+    type = types[i]
+    var is = st[type] || st["is" + type]
+    if (typeof is === "function") is = is.call(st)
+    if (is) {
+      st[type] = true
+      st.type = type
+      return type
+    }
+  }
+
+  return null
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/link-reader.js b/node_modules/tar.gz/node_modules/fstream/lib/link-reader.js
new file mode 100644
index 000000000..7e7ab6ce5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/link-reader.js
@@ -0,0 +1,54 @@
+// Basically just a wrapper around an fs.readlink
+//
+// XXX: Enhance this to support the Link type, by keeping
+// a lookup table of {<dev+inode>:<path>}, so that hardlinks
+// can be preserved in tarballs.
+
+module.exports = LinkReader
+
+var fs = require("graceful-fs")
+  , fstream = require("../fstream.js")
+  , inherits = require("inherits")
+  , mkdir = require("mkdirp")
+  , Reader = require("./reader.js")
+
+inherits(LinkReader, Reader)
+
+function LinkReader (props) {
+  var me = this
+  if (!(me instanceof LinkReader)) throw new Error(
+    "LinkReader must be called as constructor.")
+
+  if (!((props.type === "Link" && props.Link) ||
+        (props.type === "SymbolicLink" && props.SymbolicLink))) {
+    throw new Error("Non-link type "+ props.type)
+  }
+
+  Reader.call(me, props)
+}
+
+// When piping a LinkReader into a LinkWriter, we have to
+// already have the linkpath property set, so that has to
+// happen *before* the "ready" event, which means we need to
+// override the _stat method.
+LinkReader.prototype._stat = function (currentStat) {
+  var me = this
+  fs.readlink(me._path, function (er, linkpath) {
+    if (er) return me.error(er)
+    me.linkpath = me.props.linkpath = linkpath
+    me.emit("linkpath", linkpath)
+    Reader.prototype._stat.call(me, currentStat)
+  })
+}
+
+LinkReader.prototype._read = function () {
+  var me = this
+  if (me._paused) return
+  // basically just a no-op, since we got all the info we need
+  // from the _stat method
+  if (!me._ended) {
+    me.emit("end")
+    me.emit("close")
+    me._ended = true
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/link-writer.js b/node_modules/tar.gz/node_modules/fstream/lib/link-writer.js
new file mode 100644
index 000000000..5c8f1e701
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/link-writer.js
@@ -0,0 +1,95 @@
+
+module.exports = LinkWriter
+
+var fs = require("graceful-fs")
+  , Writer = require("./writer.js")
+  , inherits = require("inherits")
+  , path = require("path")
+  , rimraf = require("rimraf")
+
+inherits(LinkWriter, Writer)
+
+function LinkWriter (props) {
+  var me = this
+  if (!(me instanceof LinkWriter)) throw new Error(
+    "LinkWriter must be called as constructor.")
+
+  // should already be established as a Link type
+  if (!((props.type === "Link" && props.Link) ||
+        (props.type === "SymbolicLink" && props.SymbolicLink))) {
+    throw new Error("Non-link type "+ props.type)
+  }
+
+  if (props.linkpath === "") props.linkpath = "."
+  if (!props.linkpath) {
+    me.error("Need linkpath property to create " + props.type)
+  }
+
+  Writer.call(this, props)
+}
+
+LinkWriter.prototype._create = function () {
+  // console.error(" LW _create")
+  var me = this
+    , hard = me.type === "Link" || process.platform === "win32"
+    , link = hard ? "link" : "symlink"
+    , lp = hard ? path.resolve(me.dirname, me.linkpath) : me.linkpath
+
+  // can only change the link path by clobbering
+  // For hard links, let's just assume that's always the case, since
+  // there's no good way to read them if we don't already know.
+  if (hard) return clobber(me, lp, link)
+
+  fs.readlink(me._path, function (er, p) {
+    // only skip creation if it's exactly the same link
+    if (p && p === lp) return finish(me)
+    clobber(me, lp, link)
+  })
+}
+
+function clobber (me, lp, link) {
+  rimraf(me._path, function (er) {
+    if (er) return me.error(er)
+    create(me, lp, link)
+  })
+}
+
+function create (me, lp, link) {
+  fs[link](lp, me._path, function (er) {
+    // if this is a hard link, and we're in the process of writing out a
+    // directory, it's very possible that the thing we're linking to
+    // doesn't exist yet (especially if it was intended as a symlink),
+    // so swallow ENOENT errors here and just soldier in.
+    // Additionally, an EPERM or EACCES can happen on win32 if it's trying
+    // to make a link to a directory.  Again, just skip it.
+    // A better solution would be to have fs.symlink be supported on
+    // windows in some nice fashion.
+    if (er) {
+      if ((er.code === "ENOENT" ||
+           er.code === "EACCES" ||
+           er.code === "EPERM" ) && process.platform === "win32") {
+        me.ready = true
+        me.emit("ready")
+        me.emit("end")
+        me.emit("close")
+        me.end = me._finish = function () {}
+      } else return me.error(er)
+    }
+    finish(me)
+  })
+}
+
+function finish (me) {
+  me.ready = true
+  me.emit("ready")
+  if (me._ended && !me._finished) me._finish()
+}
+
+LinkWriter.prototype.end = function () {
+  // console.error("LW finish in end")
+  this._ended = true
+  if (this.ready) {
+    this._finished = true
+    this._finish()
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/proxy-reader.js b/node_modules/tar.gz/node_modules/fstream/lib/proxy-reader.js
new file mode 100644
index 000000000..a0ece34a2
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/proxy-reader.js
@@ -0,0 +1,93 @@
+// A reader for when we don't yet know what kind of thing
+// the thing is.
+
+module.exports = ProxyReader
+
+var Reader = require("./reader.js")
+  , getType = require("./get-type.js")
+  , inherits = require("inherits")
+  , fs = require("graceful-fs")
+
+inherits(ProxyReader, Reader)
+
+function ProxyReader (props) {
+  var me = this
+  if (!(me instanceof ProxyReader)) throw new Error(
+    "ProxyReader must be called as constructor.")
+
+  me.props = props
+  me._buffer = []
+  me.ready = false
+
+  Reader.call(me, props)
+}
+
+ProxyReader.prototype._stat = function () {
+  var me = this
+    , props = me.props
+    // stat the thing to see what the proxy should be.
+    , stat = props.follow ? "stat" : "lstat"
+
+  fs[stat](props.path, function (er, current) {
+    var type
+    if (er || !current) {
+      type = "File"
+    } else {
+      type = getType(current)
+    }
+
+    props[type] = true
+    props.type = me.type = type
+
+    me._old = current
+    me._addProxy(Reader(props, current))
+  })
+}
+
+ProxyReader.prototype._addProxy = function (proxy) {
+  var me = this
+  if (me._proxyTarget) {
+    return me.error("proxy already set")
+  }
+
+  me._proxyTarget = proxy
+  proxy._proxy = me
+
+  ; [ "error"
+    , "data"
+    , "end"
+    , "close"
+    , "linkpath"
+    , "entry"
+    , "entryEnd"
+    , "child"
+    , "childEnd"
+    , "warn"
+    , "stat"
+    ].forEach(function (ev) {
+      // console.error("~~ proxy event", ev, me.path)
+      proxy.on(ev, me.emit.bind(me, ev))
+    })
+
+  me.emit("proxy", proxy)
+
+  proxy.on("ready", function () {
+    // console.error("~~ proxy is ready!", me.path)
+    me.ready = true
+    me.emit("ready")
+  })
+
+  var calls = me._buffer
+  me._buffer.length = 0
+  calls.forEach(function (c) {
+    proxy[c[0]].apply(proxy, c[1])
+  })
+}
+
+ProxyReader.prototype.pause = function () {
+  return this._proxyTarget ? this._proxyTarget.pause() : false
+}
+
+ProxyReader.prototype.resume = function () {
+  return this._proxyTarget ? this._proxyTarget.resume() : false
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/proxy-writer.js b/node_modules/tar.gz/node_modules/fstream/lib/proxy-writer.js
new file mode 100644
index 000000000..b0476633a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/proxy-writer.js
@@ -0,0 +1,109 @@
+// A writer for when we don't know what kind of thing
+// the thing is.  That is, it's not explicitly set,
+// so we're going to make it whatever the thing already
+// is, or "File"
+//
+// Until then, collect all events.
+
+module.exports = ProxyWriter
+
+var Writer = require("./writer.js")
+  , getType = require("./get-type.js")
+  , inherits = require("inherits")
+  , collect = require("./collect.js")
+  , fs = require("fs")
+
+inherits(ProxyWriter, Writer)
+
+function ProxyWriter (props) {
+  var me = this
+  if (!(me instanceof ProxyWriter)) throw new Error(
+    "ProxyWriter must be called as constructor.")
+
+  me.props = props
+  me._needDrain = false
+
+  Writer.call(me, props)
+}
+
+ProxyWriter.prototype._stat = function () {
+  var me = this
+    , props = me.props
+    // stat the thing to see what the proxy should be.
+    , stat = props.follow ? "stat" : "lstat"
+
+  fs[stat](props.path, function (er, current) {
+    var type
+    if (er || !current) {
+      type = "File"
+    } else {
+      type = getType(current)
+    }
+
+    props[type] = true
+    props.type = me.type = type
+
+    me._old = current
+    me._addProxy(Writer(props, current))
+  })
+}
+
+ProxyWriter.prototype._addProxy = function (proxy) {
+  // console.error("~~ set proxy", this.path)
+  var me = this
+  if (me._proxy) {
+    return me.error("proxy already set")
+  }
+
+  me._proxy = proxy
+  ; [ "ready"
+    , "error"
+    , "close"
+    , "pipe"
+    , "drain"
+    , "warn"
+    ].forEach(function (ev) {
+      proxy.on(ev, me.emit.bind(me, ev))
+    })
+
+  me.emit("proxy", proxy)
+
+  var calls = me._buffer
+  calls.forEach(function (c) {
+    // console.error("~~ ~~ proxy buffered call", c[0], c[1])
+    proxy[c[0]].apply(proxy, c[1])
+  })
+  me._buffer.length = 0
+  if (me._needsDrain) me.emit("drain")
+}
+
+ProxyWriter.prototype.add = function (entry) {
+  // console.error("~~ proxy add")
+  collect(entry)
+
+  if (!this._proxy) {
+    this._buffer.push(["add", [entry]])
+    this._needDrain = true
+    return false
+  }
+  return this._proxy.add(entry)
+}
+
+ProxyWriter.prototype.write = function (c) {
+  // console.error("~~ proxy write")
+  if (!this._proxy) {
+    this._buffer.push(["write", [c]])
+    this._needDrain = true
+    return false
+  }
+  return this._proxy.write(c)
+}
+
+ProxyWriter.prototype.end = function (c) {
+  // console.error("~~ proxy end")
+  if (!this._proxy) {
+    this._buffer.push(["end", [c]])
+    return false
+  }
+  return this._proxy.end(c)
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/reader.js b/node_modules/tar.gz/node_modules/fstream/lib/reader.js
new file mode 100644
index 000000000..0edb794d3
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/reader.js
@@ -0,0 +1,262 @@
+
+module.exports = Reader
+
+var fs = require("graceful-fs")
+  , Stream = require("stream").Stream
+  , inherits = require("inherits")
+  , path = require("path")
+  , getType = require("./get-type.js")
+  , hardLinks = Reader.hardLinks = {}
+  , Abstract = require("./abstract.js")
+
+// Must do this *before* loading the child classes
+inherits(Reader, Abstract)
+
+var DirReader = require("./dir-reader.js")
+  , FileReader = require("./file-reader.js")
+  , LinkReader = require("./link-reader.js")
+  , SocketReader = require("./socket-reader.js")
+  , ProxyReader = require("./proxy-reader.js")
+
+function Reader (props, currentStat) {
+  var me = this
+  if (!(me instanceof Reader)) return new Reader(props, currentStat)
+
+  if (typeof props === "string") {
+    props = { path: props }
+  }
+
+  if (!props.path) {
+    me.error("Must provide a path", null, true)
+  }
+
+  // polymorphism.
+  // call fstream.Reader(dir) to get a DirReader object, etc.
+  // Note that, unlike in the Writer case, ProxyReader is going
+  // to be the *normal* state of affairs, since we rarely know
+  // the type of a file prior to reading it.
+
+
+  var type
+    , ClassType
+
+  if (props.type && typeof props.type === "function") {
+    type = props.type
+    ClassType = type
+  } else {
+    type = getType(props)
+    ClassType = Reader
+  }
+
+  if (currentStat && !type) {
+    type = getType(currentStat)
+    props[type] = true
+    props.type = type
+  }
+
+  switch (type) {
+    case "Directory":
+      ClassType = DirReader
+      break
+
+    case "Link":
+      // XXX hard links are just files.
+      // However, it would be good to keep track of files' dev+inode
+      // and nlink values, and create a HardLinkReader that emits
+      // a linkpath value of the original copy, so that the tar
+      // writer can preserve them.
+      // ClassType = HardLinkReader
+      // break
+
+    case "File":
+      ClassType = FileReader
+      break
+
+    case "SymbolicLink":
+      ClassType = LinkReader
+      break
+
+    case "Socket":
+      ClassType = SocketReader
+      break
+
+    case null:
+      ClassType = ProxyReader
+      break
+  }
+
+  if (!(me instanceof ClassType)) {
+    return new ClassType(props)
+  }
+
+  Abstract.call(me)
+
+  me.readable = true
+  me.writable = false
+
+  me.type = type
+  me.props = props
+  me.depth = props.depth = props.depth || 0
+  me.parent = props.parent || null
+  me.root = props.root || (props.parent && props.parent.root) || me
+
+  me._path = me.path = path.resolve(props.path)
+  if (process.platform === "win32") {
+    me.path = me._path = me.path.replace(/\?/g, "_")
+    if (me._path.length >= 260) {
+      // how DOES one create files on the moon?
+      // if the path has spaces in it, then UNC will fail.
+      me._swallowErrors = true
+      //if (me._path.indexOf(" ") === -1) {
+        me._path = "\\\\?\\" + me.path.replace(/\//g, "\\")
+      //}
+    }
+  }
+  me.basename = props.basename = path.basename(me.path)
+  me.dirname = props.dirname = path.dirname(me.path)
+
+  // these have served their purpose, and are now just noisy clutter
+  props.parent = props.root = null
+
+  // console.error("\n\n\n%s setting size to", props.path, props.size)
+  me.size = props.size
+  me.filter = typeof props.filter === "function" ? props.filter : null
+  if (props.sort === "alpha") props.sort = alphasort
+
+  // start the ball rolling.
+  // this will stat the thing, and then call me._read()
+  // to start reading whatever it is.
+  // console.error("calling stat", props.path, currentStat)
+  me._stat(currentStat)
+}
+
+function alphasort (a, b) {
+  return a === b ? 0
+       : a.toLowerCase() > b.toLowerCase() ? 1
+       : a.toLowerCase() < b.toLowerCase() ? -1
+       : a > b ? 1
+       : -1
+}
+
+Reader.prototype._stat = function (currentStat) {
+  var me = this
+    , props = me.props
+    , stat = props.follow ? "stat" : "lstat"
+  // console.error("Reader._stat", me._path, currentStat)
+  if (currentStat) process.nextTick(statCb.bind(null, null, currentStat))
+  else fs[stat](me._path, statCb)
+
+
+  function statCb (er, props_) {
+    // console.error("Reader._stat, statCb", me._path, props_, props_.nlink)
+    if (er) return me.error(er)
+
+    Object.keys(props_).forEach(function (k) {
+      props[k] = props_[k]
+    })
+
+    // if it's not the expected size, then abort here.
+    if (undefined !== me.size && props.size !== me.size) {
+      return me.error("incorrect size")
+    }
+    me.size = props.size
+
+    var type = getType(props)
+    var handleHardlinks = props.hardlinks !== false
+    
+    // special little thing for handling hardlinks.
+    if (handleHardlinks && type !== "Directory" && props.nlink && props.nlink > 1) {
+      var k = props.dev + ":" + props.ino
+      // console.error("Reader has nlink", me._path, k)
+      if (hardLinks[k] === me._path || !hardLinks[k]) hardLinks[k] = me._path
+      else {
+        // switch into hardlink mode.
+        type = me.type = me.props.type = "Link"
+        me.Link = me.props.Link = true
+        me.linkpath = me.props.linkpath = hardLinks[k]
+        // console.error("Hardlink detected, switching mode", me._path, me.linkpath)
+        // Setting __proto__ would arguably be the "correct"
+        // approach here, but that just seems too wrong.
+        me._stat = me._read = LinkReader.prototype._read
+      }
+    }
+
+    if (me.type && me.type !== type) {
+      me.error("Unexpected type: " + type)
+    }
+
+    // if the filter doesn't pass, then just skip over this one.
+    // still have to emit end so that dir-walking can move on.
+    if (me.filter) {
+      var who = me._proxy || me
+      // special handling for ProxyReaders
+      if (!me.filter.call(who, who, props)) {
+        if (!me._disowned) {
+          me.abort()
+          me.emit("end")
+          me.emit("close")
+        }
+        return
+      }
+    }
+
+    // last chance to abort or disown before the flow starts!
+    var events = ["_stat", "stat", "ready"]
+    var e = 0
+    ;(function go () {
+      if (me._aborted) {
+        me.emit("end")
+        me.emit("close")
+        return
+      }
+
+      if (me._paused && me.type !== "Directory") {
+        me.once("resume", go)
+        return
+      }
+
+      var ev = events[e ++]
+      if (!ev) {
+        return me._read()
+      }
+      me.emit(ev, props)
+      go()
+    })()
+  }
+}
+
+Reader.prototype.pipe = function (dest, opts) {
+  var me = this
+  if (typeof dest.add === "function") {
+    // piping to a multi-compatible, and we've got directory entries.
+    me.on("entry", function (entry) {
+      var ret = dest.add(entry)
+      if (false === ret) {
+        me.pause()
+      }
+    })
+  }
+
+  // console.error("R Pipe apply Stream Pipe")
+  return Stream.prototype.pipe.apply(this, arguments)
+}
+
+Reader.prototype.pause = function (who) {
+  this._paused = true
+  who = who || this
+  this.emit("pause", who)
+  if (this._stream) this._stream.pause(who)
+}
+
+Reader.prototype.resume = function (who) {
+  this._paused = false
+  who = who || this
+  this.emit("resume", who)
+  if (this._stream) this._stream.resume(who)
+  this._read()
+}
+
+Reader.prototype._read = function () {
+  this.error("Cannot read unknown type: "+this.type)
+}
+
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/socket-reader.js b/node_modules/tar.gz/node_modules/fstream/lib/socket-reader.js
new file mode 100644
index 000000000..e89c1731a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/socket-reader.js
@@ -0,0 +1,38 @@
+// Just get the stats, and then don't do anything.
+// You can't really "read" from a socket.  You "connect" to it.
+// Mostly, this is here so that reading a dir with a socket in it
+// doesn't blow up.
+
+module.exports = SocketReader
+
+var fs = require("graceful-fs")
+  , fstream = require("../fstream.js")
+  , inherits = require("inherits")
+  , mkdir = require("mkdirp")
+  , Reader = require("./reader.js")
+
+inherits(SocketReader, Reader)
+
+function SocketReader (props) {
+  var me = this
+  if (!(me instanceof SocketReader)) throw new Error(
+    "SocketReader must be called as constructor.")
+
+  if (!(props.type === "Socket" && props.Socket)) {
+    throw new Error("Non-socket type "+ props.type)
+  }
+
+  Reader.call(me, props)
+}
+
+SocketReader.prototype._read = function () {
+  var me = this
+  if (me._paused) return
+  // basically just a no-op, since we got all the info we have
+  // from the _stat method
+  if (!me._ended) {
+    me.emit("end")
+    me.emit("close")
+    me._ended = true
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/lib/writer.js b/node_modules/tar.gz/node_modules/fstream/lib/writer.js
new file mode 100644
index 000000000..5599fb222
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/lib/writer.js
@@ -0,0 +1,389 @@
+
+module.exports = Writer
+
+var fs = require("graceful-fs")
+  , inherits = require("inherits")
+  , rimraf = require("rimraf")
+  , mkdir = require("mkdirp")
+  , path = require("path")
+  , umask = process.platform === "win32" ? 0 : process.umask()
+  , getType = require("./get-type.js")
+  , Abstract = require("./abstract.js")
+
+// Must do this *before* loading the child classes
+inherits(Writer, Abstract)
+
+Writer.dirmode = 0777 & (~umask)
+Writer.filemode = 0666 & (~umask)
+
+var DirWriter = require("./dir-writer.js")
+  , LinkWriter = require("./link-writer.js")
+  , FileWriter = require("./file-writer.js")
+  , ProxyWriter = require("./proxy-writer.js")
+
+// props is the desired state.  current is optionally the current stat,
+// provided here so that subclasses can avoid statting the target
+// more than necessary.
+function Writer (props, current) {
+  var me = this
+
+  if (typeof props === "string") {
+    props = { path: props }
+  }
+
+  if (!props.path) me.error("Must provide a path", null, true)
+
+  // polymorphism.
+  // call fstream.Writer(dir) to get a DirWriter object, etc.
+  var type = getType(props)
+    , ClassType = Writer
+
+  switch (type) {
+    case "Directory":
+      ClassType = DirWriter
+      break
+    case "File":
+      ClassType = FileWriter
+      break
+    case "Link":
+    case "SymbolicLink":
+      ClassType = LinkWriter
+      break
+    case null:
+      // Don't know yet what type to create, so we wrap in a proxy.
+      ClassType = ProxyWriter
+      break
+  }
+
+  if (!(me instanceof ClassType)) return new ClassType(props)
+
+  // now get down to business.
+
+  Abstract.call(me)
+
+  // props is what we want to set.
+  // set some convenience properties as well.
+  me.type = props.type
+  me.props = props
+  me.depth = props.depth || 0
+  me.clobber = false === props.clobber ? props.clobber : true
+  me.parent = props.parent || null
+  me.root = props.root || (props.parent && props.parent.root) || me
+
+  me._path = me.path = path.resolve(props.path)
+  if (process.platform === "win32") {
+    me.path = me._path = me.path.replace(/\?/g, "_")
+    if (me._path.length >= 260) {
+      me._swallowErrors = true
+      me._path = "\\\\?\\" + me.path.replace(/\//g, "\\")
+    }
+  }
+  me.basename = path.basename(props.path)
+  me.dirname = path.dirname(props.path)
+  me.linkpath = props.linkpath || null
+
+  props.parent = props.root = null
+
+  // console.error("\n\n\n%s setting size to", props.path, props.size)
+  me.size = props.size
+
+  if (typeof props.mode === "string") {
+    props.mode = parseInt(props.mode, 8)
+  }
+
+  me.readable = false
+  me.writable = true
+
+  // buffer until ready, or while handling another entry
+  me._buffer = []
+  me.ready = false
+
+  me.filter = typeof props.filter === "function" ? props.filter: null
+
+  // start the ball rolling.
+  // this checks what's there already, and then calls
+  // me._create() to call the impl-specific creation stuff.
+  me._stat(current)
+}
+
+// Calling this means that it's something we can't create.
+// Just assert that it's already there, otherwise raise a warning.
+Writer.prototype._create = function () {
+  var me = this
+  fs[me.props.follow ? "stat" : "lstat"](me._path, function (er, current) {
+    if (er) {
+      return me.warn("Cannot create " + me._path + "\n" +
+                     "Unsupported type: "+me.type, "ENOTSUP")
+    }
+    me._finish()
+  })
+}
+
+Writer.prototype._stat = function (current) {
+  var me = this
+    , props = me.props
+    , stat = props.follow ? "stat" : "lstat"
+    , who = me._proxy || me
+
+  if (current) statCb(null, current)
+  else fs[stat](me._path, statCb)
+
+  function statCb (er, current) {
+    if (me.filter && !me.filter.call(who, who, current)) {
+      me._aborted = true
+      me.emit("end")
+      me.emit("close")
+      return
+    }
+
+    // if it's not there, great.  We'll just create it.
+    // if it is there, then we'll need to change whatever differs
+    if (er || !current) {
+      return create(me)
+    }
+
+    me._old = current
+    var currentType = getType(current)
+
+    // if it's a type change, then we need to clobber or error.
+    // if it's not a type change, then let the impl take care of it.
+    if (currentType !== me.type) {
+      return rimraf(me._path, function (er) {
+        if (er) return me.error(er)
+        me._old = null
+        create(me)
+      })
+    }
+
+    // otherwise, just handle in the app-specific way
+    // this creates a fs.WriteStream, or mkdir's, or whatever
+    create(me)
+  }
+}
+
+function create (me) {
+  // console.error("W create", me._path, Writer.dirmode)
+
+  // XXX Need to clobber non-dirs that are in the way,
+  // unless { clobber: false } in the props.
+  mkdir(path.dirname(me._path), Writer.dirmode, function (er, made) {
+    // console.error("W created", path.dirname(me._path), er)
+    if (er) return me.error(er)
+
+    // later on, we have to set the mode and owner for these
+    me._madeDir = made
+    return me._create()
+  })
+}
+
+function endChmod (me, want, current, path, cb) {
+    var wantMode = want.mode
+      , chmod = want.follow || me.type !== "SymbolicLink"
+              ? "chmod" : "lchmod"
+
+  if (!fs[chmod]) return cb()
+  if (typeof wantMode !== "number") return cb()
+
+  var curMode = current.mode & 0777
+  wantMode = wantMode & 0777
+  if (wantMode === curMode) return cb()
+
+  fs[chmod](path, wantMode, cb)
+}
+
+
+function endChown (me, want, current, path, cb) {
+  // Don't even try it unless root.  Too easy to EPERM.
+  if (process.platform === "win32") return cb()
+  if (!process.getuid || !process.getuid() === 0) return cb()
+  if (typeof want.uid !== "number" &&
+      typeof want.gid !== "number" ) return cb()
+
+  if (current.uid === want.uid &&
+      current.gid === want.gid) return cb()
+
+  var chown = (me.props.follow || me.type !== "SymbolicLink")
+            ? "chown" : "lchown"
+  if (!fs[chown]) return cb()
+
+  if (typeof want.uid !== "number") want.uid = current.uid
+  if (typeof want.gid !== "number") want.gid = current.gid
+
+  fs[chown](path, want.uid, want.gid, cb)
+}
+
+function endUtimes (me, want, current, path, cb) {
+  if (!fs.utimes || process.platform === "win32") return cb()
+
+  var utimes = (want.follow || me.type !== "SymbolicLink")
+             ? "utimes" : "lutimes"
+
+  if (utimes === "lutimes" && !fs[utimes]) {
+    utimes = "utimes"
+  }
+
+  if (!fs[utimes]) return cb()
+
+  var curA = current.atime
+    , curM = current.mtime
+    , meA = want.atime
+    , meM = want.mtime
+
+  if (meA === undefined) meA = curA
+  if (meM === undefined) meM = curM
+
+  if (!isDate(meA)) meA = new Date(meA)
+  if (!isDate(meM)) meA = new Date(meM)
+
+  if (meA.getTime() === curA.getTime() &&
+      meM.getTime() === curM.getTime()) return cb()
+
+  fs[utimes](path, meA, meM, cb)
+}
+
+
+// XXX This function is beastly.  Break it up!
+Writer.prototype._finish = function () {
+  var me = this
+
+  // console.error(" W Finish", me._path, me.size)
+
+  // set up all the things.
+  // At this point, we're already done writing whatever we've gotta write,
+  // adding files to the dir, etc.
+  var todo = 0
+  var errState = null
+  var done = false
+
+  if (me._old) {
+    // the times will almost *certainly* have changed.
+    // adds the utimes syscall, but remove another stat.
+    me._old.atime = new Date(0)
+    me._old.mtime = new Date(0)
+    // console.error(" W Finish Stale Stat", me._path, me.size)
+    setProps(me._old)
+  } else {
+    var stat = me.props.follow ? "stat" : "lstat"
+    // console.error(" W Finish Stating", me._path, me.size)
+    fs[stat](me._path, function (er, current) {
+      // console.error(" W Finish Stated", me._path, me.size, current)
+      if (er) {
+        // if we're in the process of writing out a
+        // directory, it's very possible that the thing we're linking to
+        // doesn't exist yet (especially if it was intended as a symlink),
+        // so swallow ENOENT errors here and just soldier on.
+        if (er.code === "ENOENT" &&
+            (me.type === "Link" || me.type === "SymbolicLink") &&
+            process.platform === "win32") {
+          me.ready = true
+          me.emit("ready")
+          me.emit("end")
+          me.emit("close")
+          me.end = me._finish = function () {}
+          return
+        } else return me.error(er)
+      }
+      setProps(me._old = current)
+    })
+  }
+
+  return
+
+  function setProps (current) {
+    todo += 3
+    endChmod(me, me.props, current, me._path, next("chmod"))
+    endChown(me, me.props, current, me._path, next("chown"))
+    endUtimes(me, me.props, current, me._path, next("utimes"))
+  }
+
+  function next (what) {
+    return function (er) {
+      // console.error("   W Finish", what, todo)
+      if (errState) return
+      if (er) {
+        er.fstream_finish_call = what
+        return me.error(errState = er)
+      }
+      if (--todo > 0) return
+      if (done) return
+      done = true
+
+      // we may still need to set the mode/etc. on some parent dirs
+      // that were created previously.  delay end/close until then.
+      if (!me._madeDir) return end()
+      else endMadeDir(me, me._path, end)
+
+      function end (er) {
+        if (er) {
+          er.fstream_finish_call = "setupMadeDir"
+          return me.error(er)
+        }
+        // all the props have been set, so we're completely done.
+        me.emit("end")
+        me.emit("close")
+      }
+    }
+  }
+}
+
+function endMadeDir (me, p, cb) {
+  var made = me._madeDir
+  // everything *between* made and path.dirname(me._path)
+  // needs to be set up.  Note that this may just be one dir.
+  var d = path.dirname(p)
+
+  endMadeDir_(me, d, function (er) {
+    if (er) return cb(er)
+    if (d === made) {
+      return cb()
+    }
+    endMadeDir(me, d, cb)
+  })
+}
+
+function endMadeDir_ (me, p, cb) {
+  var dirProps = {}
+  Object.keys(me.props).forEach(function (k) {
+    dirProps[k] = me.props[k]
+
+    // only make non-readable dirs if explicitly requested.
+    if (k === "mode" && me.type !== "Directory") {
+      dirProps[k] = dirProps[k] | 0111
+    }
+  })
+
+  var todo = 3
+  , errState = null
+  fs.stat(p, function (er, current) {
+    if (er) return cb(errState = er)
+    endChmod(me, dirProps, current, p, next)
+    endChown(me, dirProps, current, p, next)
+    endUtimes(me, dirProps, current, p, next)
+  })
+
+  function next (er) {
+    if (errState) return
+    if (er) return cb(errState = er)
+    if (-- todo === 0) return cb()
+  }
+}
+
+Writer.prototype.pipe = function () {
+  this.error("Can't pipe from writable stream")
+}
+
+Writer.prototype.add = function () {
+  this.error("Cannot add to non-Directory type")
+}
+
+Writer.prototype.write = function () {
+  return true
+}
+
+function objectToString (d) {
+  return Object.prototype.toString.call(d)
+}
+
+function isDate(d) {
+  return typeof d === 'object' && objectToString(d) === '[object Date]';
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/.npmignore b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/.npmignore
new file mode 100644
index 000000000..c2658d7d1
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/.npmignore
@@ -0,0 +1 @@
+node_modules/
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/LICENSE b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/LICENSE
new file mode 100644
index 000000000..0c44ae716
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) Isaac Z. Schlueter ("Author")
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/README.md b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/README.md
new file mode 100644
index 000000000..13a2e8605
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/README.md
@@ -0,0 +1,36 @@
+# graceful-fs
+
+graceful-fs functions as a drop-in replacement for the fs module,
+making various improvements.
+
+The improvements are meant to normalize behavior across different
+platforms and environments, and to make filesystem access more
+resilient to errors.
+
+## Improvements over [fs module](http://api.nodejs.org/fs.html)
+
+graceful-fs:
+
+* Queues up `open` and `readdir` calls, and retries them once
+  something closes if there is an EMFILE error from too many file
+  descriptors.
+* fixes `lchmod` for Node versions prior to 0.6.2.
+* implements `fs.lutimes` if possible. Otherwise it becomes a noop.
+* ignores `EINVAL` and `EPERM` errors in `chown`, `fchown` or
+  `lchown` if the user isn't root.
+* makes `lchmod` and `lchown` become noops, if not available.
+* retries reading a file if `read` results in EAGAIN error.
+
+On Windows, it retries renaming a file for up to one second if `EACCESS`
+or `EPERM` error occurs, likely because antivirus software has locked
+the directory.
+
+## USAGE
+
+```javascript
+// use just like fs
+var fs = require('graceful-fs')
+
+// now go and do stuff with it...
+fs.readFileSync('some-file-or-whatever')
+```
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/fs.js b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/fs.js
new file mode 100644
index 000000000..ae9fd6f61
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/fs.js
@@ -0,0 +1,11 @@
+// eeeeeevvvvviiiiiiillllll
+// more evil than monkey-patching the native builtin?
+// Not sure.
+
+var mod = require("module")
+var pre = '(function (exports, require, module, __filename, __dirname) { '
+var post = '});'
+var src = pre + process.binding('natives').fs + post
+var vm = require('vm')
+var fn = vm.runInThisContext(src)
+return fn(exports, require, module, __filename, __dirname)
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/graceful-fs.js b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/graceful-fs.js
new file mode 100644
index 000000000..77fc702d8
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/graceful-fs.js
@@ -0,0 +1,158 @@
+// Monkey-patching the fs module.
+// It's ugly, but there is simply no other way to do this.
+var fs = module.exports = require('./fs.js')
+
+var assert = require('assert')
+
+// fix up some busted stuff, mostly on windows and old nodes
+require('./polyfills.js')
+
+var util = require('util')
+
+function noop () {}
+
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs')
+else if (/\bgfs\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS: ' + m.split(/\n/).join('\nGFS: ')
+    console.error(m)
+  }
+
+if (/\bgfs\b/i.test(process.env.NODE_DEBUG || '')) {
+  process.on('exit', function() {
+    debug('fds', fds)
+    debug(queue)
+    assert.equal(queue.length, 0)
+  })
+}
+
+
+var originalOpen = fs.open
+fs.open = open
+
+function open(path, flags, mode, cb) {
+  if (typeof mode === "function") cb = mode, mode = null
+  if (typeof cb !== "function") cb = noop
+  new OpenReq(path, flags, mode, cb)
+}
+
+function OpenReq(path, flags, mode, cb) {
+  this.path = path
+  this.flags = flags
+  this.mode = mode
+  this.cb = cb
+  Req.call(this)
+}
+
+util.inherits(OpenReq, Req)
+
+OpenReq.prototype.process = function() {
+  originalOpen.call(fs, this.path, this.flags, this.mode, this.done)
+}
+
+var fds = {}
+OpenReq.prototype.done = function(er, fd) {
+  debug('open done', er, fd)
+  if (fd)
+    fds['fd' + fd] = this.path
+  Req.prototype.done.call(this, er, fd)
+}
+
+
+var originalReaddir = fs.readdir
+fs.readdir = readdir
+
+function readdir(path, cb) {
+  if (typeof cb !== "function") cb = noop
+  new ReaddirReq(path, cb)
+}
+
+function ReaddirReq(path, cb) {
+  this.path = path
+  this.cb = cb
+  Req.call(this)
+}
+
+util.inherits(ReaddirReq, Req)
+
+ReaddirReq.prototype.process = function() {
+  originalReaddir.call(fs, this.path, this.done)
+}
+
+ReaddirReq.prototype.done = function(er, files) {
+  if (files && files.sort)
+    files = files.sort()
+  Req.prototype.done.call(this, er, files)
+  onclose()
+}
+
+
+var originalClose = fs.close
+fs.close = close
+
+function close (fd, cb) {
+  debug('close', fd)
+  if (typeof cb !== "function") cb = noop
+  delete fds['fd' + fd]
+  originalClose.call(fs, fd, function(er) {
+    onclose()
+    cb(er)
+  })
+}
+
+
+var originalCloseSync = fs.closeSync
+fs.closeSync = closeSync
+
+function closeSync (fd) {
+  try {
+    return originalCloseSync(fd)
+  } finally {
+    onclose()
+  }
+}
+
+
+// Req class
+function Req () {
+  // start processing
+  this.done = this.done.bind(this)
+  this.failures = 0
+  this.process()
+}
+
+Req.prototype.done = function (er, result) {
+  var tryAgain = false
+  if (er) {
+    var code = er.code
+    var tryAgain = code === "EMFILE"
+    if (process.platform === "win32")
+      tryAgain = tryAgain || code === "OK"
+  }
+
+  if (tryAgain) {
+    this.failures ++
+    enqueue(this)
+  } else {
+    var cb = this.cb
+    cb(er, result)
+  }
+}
+
+var queue = []
+
+function enqueue(req) {
+  queue.push(req)
+  debug('enqueue %d %s', queue.length, req.constructor.name, req)
+}
+
+function onclose() {
+  var req = queue.shift()
+  if (req) {
+    debug('process', req.constructor.name, req)
+    req.process()
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/package.json b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/package.json
new file mode 100644
index 000000000..9df0a405a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/package.json
@@ -0,0 +1,51 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "name": "graceful-fs",
+  "description": "A drop-in replacement for fs, making various improvements.",
+  "version": "3.0.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-graceful-fs.git"
+  },
+  "main": "graceful-fs.js",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "keywords": [
+    "fs",
+    "module",
+    "reading",
+    "retry",
+    "retries",
+    "queue",
+    "error",
+    "errors",
+    "handling",
+    "EMFILE",
+    "EAGAIN",
+    "EINVAL",
+    "EPERM",
+    "EACCESS"
+  ],
+  "license": "BSD",
+  "readme": "# graceful-fs\n\ngraceful-fs functions as a drop-in replacement for the fs module,\nmaking various improvements.\n\nThe improvements are meant to normalize behavior across different\nplatforms and environments, and to make filesystem access more\nresilient to errors.\n\n## Improvements over [fs module](http://api.nodejs.org/fs.html)\n\ngraceful-fs:\n\n* Queues up `open` and `readdir` calls, and retries them once\n  something closes if there is an EMFILE error from too many file\n  descriptors.\n* fixes `lchmod` for Node versions prior to 0.6.2.\n* implements `fs.lutimes` if possible. Otherwise it becomes a noop.\n* ignores `EINVAL` and `EPERM` errors in `chown`, `fchown` or\n  `lchown` if the user isn't root.\n* makes `lchmod` and `lchown` become noops, if not available.\n* retries reading a file if `read` results in EAGAIN error.\n\nOn Windows, it retries renaming a file for up to one second if `EACCESS`\nor `EPERM` error occurs, likely because antivirus software has locked\nthe directory.\n\n## USAGE\n\n```javascript\n// use just like fs\nvar fs = require('graceful-fs')\n\n// now go and do stuff with it...\nfs.readFileSync('some-file-or-whatever')\n```\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/node-graceful-fs/issues"
+  },
+  "homepage": "https://github.com/isaacs/node-graceful-fs",
+  "_id": "graceful-fs@3.0.2",
+  "_shasum": "2cb5bf7f742bea8ad47c754caeee032b7e71a577",
+  "_from": "graceful-fs@~3.0.2",
+  "_resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.2.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/polyfills.js b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/polyfills.js
new file mode 100644
index 000000000..9d62af586
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/polyfills.js
@@ -0,0 +1,255 @@
+var fs = require('./fs.js')
+var constants = require('constants')
+
+var origCwd = process.cwd
+var cwd = null
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+var chdir = process.chdir
+process.chdir = function(d) {
+  cwd = null
+  chdir.call(process, d)
+}
+
+// (re-)implement some things that are known busted or missing.
+
+// lchmod, broken prior to 0.6.2
+// back-port the fix here.
+if (constants.hasOwnProperty('O_SYMLINK') &&
+    process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+  fs.lchmod = function (path, mode, callback) {
+    callback = callback || noop
+    fs.open( path
+           , constants.O_WRONLY | constants.O_SYMLINK
+           , mode
+           , function (err, fd) {
+      if (err) {
+        callback(err)
+        return
+      }
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      fs.fchmod(fd, mode, function (err) {
+        fs.close(fd, function(err2) {
+          callback(err || err2)
+        })
+      })
+    })
+  }
+
+  fs.lchmodSync = function (path, mode) {
+    var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+    // prefer to return the chmod error, if one occurs,
+    // but still try to close, and report closing errors if they occur.
+    var err, err2
+    try {
+      var ret = fs.fchmodSync(fd, mode)
+    } catch (er) {
+      err = er
+    }
+    try {
+      fs.closeSync(fd)
+    } catch (er) {
+      err2 = er
+    }
+    if (err || err2) throw (err || err2)
+    return ret
+  }
+}
+
+
+// lutimes implementation, or no-op
+if (!fs.lutimes) {
+  if (constants.hasOwnProperty("O_SYMLINK")) {
+    fs.lutimes = function (path, at, mt, cb) {
+      fs.open(path, constants.O_SYMLINK, function (er, fd) {
+        cb = cb || noop
+        if (er) return cb(er)
+        fs.futimes(fd, at, mt, function (er) {
+          fs.close(fd, function (er2) {
+            return cb(er || er2)
+          })
+        })
+      })
+    }
+
+    fs.lutimesSync = function (path, at, mt) {
+      var fd = fs.openSync(path, constants.O_SYMLINK)
+        , err
+        , err2
+        , ret
+
+      try {
+        var ret = fs.futimesSync(fd, at, mt)
+      } catch (er) {
+        err = er
+      }
+      try {
+        fs.closeSync(fd)
+      } catch (er) {
+        err2 = er
+      }
+      if (err || err2) throw (err || err2)
+      return ret
+    }
+
+  } else if (fs.utimensat && constants.hasOwnProperty("AT_SYMLINK_NOFOLLOW")) {
+    // maybe utimensat will be bound soonish?
+    fs.lutimes = function (path, at, mt, cb) {
+      fs.utimensat(path, at, mt, constants.AT_SYMLINK_NOFOLLOW, cb)
+    }
+
+    fs.lutimesSync = function (path, at, mt) {
+      return fs.utimensatSync(path, at, mt, constants.AT_SYMLINK_NOFOLLOW)
+    }
+
+  } else {
+    fs.lutimes = function (_a, _b, _c, cb) { process.nextTick(cb) }
+    fs.lutimesSync = function () {}
+  }
+}
+
+
+// https://github.com/isaacs/node-graceful-fs/issues/4
+// Chown should not fail on einval or eperm if non-root.
+// It should not fail on enosys ever, as this just indicates
+// that a fs doesn't support the intended operation.
+
+fs.chown = chownFix(fs.chown)
+fs.fchown = chownFix(fs.fchown)
+fs.lchown = chownFix(fs.lchown)
+
+fs.chmod = chownFix(fs.chmod)
+fs.fchmod = chownFix(fs.fchmod)
+fs.lchmod = chownFix(fs.lchmod)
+
+fs.chownSync = chownFixSync(fs.chownSync)
+fs.fchownSync = chownFixSync(fs.fchownSync)
+fs.lchownSync = chownFixSync(fs.lchownSync)
+
+fs.chmodSync = chownFix(fs.chmodSync)
+fs.fchmodSync = chownFix(fs.fchmodSync)
+fs.lchmodSync = chownFix(fs.lchmodSync)
+
+function chownFix (orig) {
+  if (!orig) return orig
+  return function (target, uid, gid, cb) {
+    return orig.call(fs, target, uid, gid, function (er, res) {
+      if (chownErOk(er)) er = null
+      cb(er, res)
+    })
+  }
+}
+
+function chownFixSync (orig) {
+  if (!orig) return orig
+  return function (target, uid, gid) {
+    try {
+      return orig.call(fs, target, uid, gid)
+    } catch (er) {
+      if (!chownErOk(er)) throw er
+    }
+  }
+}
+
+// ENOSYS means that the fs doesn't support the op. Just ignore
+// that, because it doesn't matter.
+//
+// if there's no getuid, or if getuid() is something other
+// than 0, and the error is EINVAL or EPERM, then just ignore
+// it.
+//
+// This specific case is a silent failure in cp, install, tar,
+// and most other unix tools that manage permissions.
+//
+// When running as root, or if other types of errors are
+// encountered, then it's strict.
+function chownErOk (er) {
+  if (!er)
+    return true
+
+  if (er.code === "ENOSYS")
+    return true
+
+  var nonroot = !process.getuid || process.getuid() !== 0
+  if (nonroot) {
+    if (er.code === "EINVAL" || er.code === "EPERM")
+      return true
+  }
+
+  return false
+}
+
+
+// if lchmod/lchown do not exist, then make them no-ops
+if (!fs.lchmod) {
+  fs.lchmod = function (path, mode, cb) {
+    process.nextTick(cb)
+  }
+  fs.lchmodSync = function () {}
+}
+if (!fs.lchown) {
+  fs.lchown = function (path, uid, gid, cb) {
+    process.nextTick(cb)
+  }
+  fs.lchownSync = function () {}
+}
+
+
+
+// on Windows, A/V software can lock the directory, causing this
+// to fail with an EACCES or EPERM if the directory contains newly
+// created files.  Try again on failure, for up to 1 second.
+if (process.platform === "win32") {
+  var rename_ = fs.rename
+  fs.rename = function rename (from, to, cb) {
+    var start = Date.now()
+    rename_(from, to, function CB (er) {
+      if (er
+          && (er.code === "EACCES" || er.code === "EPERM")
+          && Date.now() - start < 1000) {
+        return rename_(from, to, CB)
+      }
+      cb(er)
+    })
+  }
+}
+
+
+// if read() returns EAGAIN, then just try it again.
+var read = fs.read
+fs.read = function (fd, buffer, offset, length, position, callback_) {
+  var callback
+  if (callback_ && typeof callback_ === 'function') {
+    var eagCounter = 0
+    callback = function (er, _, __) {
+      if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+        eagCounter ++
+        return read.call(fs, fd, buffer, offset, length, position, callback)
+      }
+      callback_.apply(this, arguments)
+    }
+  }
+  return read.call(fs, fd, buffer, offset, length, position, callback)
+}
+
+var readSync = fs.readSync
+fs.readSync = function (fd, buffer, offset, length, position) {
+  var eagCounter = 0
+  while (true) {
+    try {
+      return readSync.call(fs, fd, buffer, offset, length, position)
+    } catch (er) {
+      if (er.code === 'EAGAIN' && eagCounter < 10) {
+        eagCounter ++
+        continue
+      }
+      throw er
+    }
+  }
+}
+
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/open.js b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/open.js
new file mode 100644
index 000000000..85732f236
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/open.js
@@ -0,0 +1,39 @@
+var test = require('tap').test
+var fs = require('../graceful-fs.js')
+
+test('graceful fs is monkeypatched fs', function (t) {
+  t.equal(fs, require('../fs.js'))
+  t.end()
+})
+
+test('open an existing file works', function (t) {
+  var fd = fs.openSync(__filename, 'r')
+  fs.closeSync(fd)
+  fs.open(__filename, 'r', function (er, fd) {
+    if (er) throw er
+    fs.close(fd, function (er) {
+      if (er) throw er
+      t.pass('works')
+      t.end()
+    })
+  })
+})
+
+test('open a non-existing file throws', function (t) {
+  var er
+  try {
+    var fd = fs.openSync('this file does not exist', 'r')
+  } catch (x) {
+    er = x
+  }
+  t.ok(er, 'should throw')
+  t.notOk(fd, 'should not get an fd')
+  t.equal(er.code, 'ENOENT')
+
+  fs.open('neither does this file', 'r', function (er, fd) {
+    t.ok(er, 'should throw')
+    t.notOk(fd, 'should not get an fd')
+    t.equal(er.code, 'ENOENT')
+    t.end()
+  })
+})
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/readdir-sort.js b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/readdir-sort.js
new file mode 100644
index 000000000..fe005aa7a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/graceful-fs/test/readdir-sort.js
@@ -0,0 +1,21 @@
+var test = require("tap").test
+var fs = require("../fs.js")
+
+var readdir = fs.readdir
+fs.readdir = function(path, cb) {
+  process.nextTick(function() {
+    cb(null, ["b", "z", "a"])
+  })
+}
+
+var g = require("../")
+
+test("readdir reorder", function (t) {
+  g.readdir("whatevers", function (er, files) {
+    if (er)
+      throw er
+    console.error(files)
+    t.same(files, [ "a", "b", "z" ])
+    t.end()
+  })
+})
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/LICENSE b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/LICENSE
new file mode 100644
index 000000000..dea3013d6
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/LICENSE
@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/README.md b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/README.md
new file mode 100644
index 000000000..b1c566585
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/README.md
@@ -0,0 +1,42 @@
+Browser-friendly inheritance fully compatible with standard node.js
+[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
+
+This package exports standard `inherits` from node.js `util` module in
+node environment, but also provides alternative browser-friendly
+implementation through [browser
+field](https://gist.github.com/shtylman/4339901). Alternative
+implementation is a literal copy of standard one located in standalone
+module to avoid requiring of `util`. It also has a shim for old
+browsers with no `Object.create` support.
+
+While keeping you sure you are using standard `inherits`
+implementation in node.js environment, it allows bundlers such as
+[browserify](https://github.com/substack/node-browserify) to not
+include full `util` package to your client code if all you need is
+just `inherits` function. It worth, because browser shim for `util`
+package is large and `inherits` is often the single function you need
+from it.
+
+It's recommended to use this package instead of
+`require('util').inherits` for any code that has chances to be used
+not only in node.js but in browser too.
+
+## usage
+
+```js
+var inherits = require('inherits');
+// then use exactly as the standard one
+```
+
+## note on version ~1.0
+
+Version ~1.0 had completely different motivation and is not compatible
+neither with 2.0 nor with standard node.js `inherits`.
+
+If you are using version ~1.0 and planning to switch to ~2.0, be
+careful:
+
+* new version uses `super_` instead of `super` for referencing
+  superclass
+* new version overwrites current prototype while old one preserves any
+  existing fields on it
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits.js b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits.js
new file mode 100644
index 000000000..29f5e24f5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits.js
@@ -0,0 +1 @@
+module.exports = require('util').inherits
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits_browser.js b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits_browser.js
new file mode 100644
index 000000000..c1e78a75e
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/inherits_browser.js
@@ -0,0 +1,23 @@
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/package.json b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/package.json
new file mode 100644
index 000000000..facd5fdf1
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "inherits",
+  "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
+  "version": "2.0.1",
+  "keywords": [
+    "inheritance",
+    "class",
+    "klass",
+    "oop",
+    "object-oriented",
+    "inherits",
+    "browser",
+    "browserify"
+  ],
+  "main": "./inherits.js",
+  "browser": "./inherits_browser.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/inherits"
+  },
+  "license": "ISC",
+  "scripts": {
+    "test": "node test"
+  },
+  "readme": "Browser-friendly inheritance fully compatible with standard node.js\n[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).\n\nThis package exports standard `inherits` from node.js `util` module in\nnode environment, but also provides alternative browser-friendly\nimplementation through [browser\nfield](https://gist.github.com/shtylman/4339901). Alternative\nimplementation is a literal copy of standard one located in standalone\nmodule to avoid requiring of `util`. It also has a shim for old\nbrowsers with no `Object.create` support.\n\nWhile keeping you sure you are using standard `inherits`\nimplementation in node.js environment, it allows bundlers such as\n[browserify](https://github.com/substack/node-browserify) to not\ninclude full `util` package to your client code if all you need is\njust `inherits` function. It worth, because browser shim for `util`\npackage is large and `inherits` is often the single function you need\nfrom it.\n\nIt's recommended to use this package instead of\n`require('util').inherits` for any code that has chances to be used\nnot only in node.js but in browser too.\n\n## usage\n\n```js\nvar inherits = require('inherits');\n// then use exactly as the standard one\n```\n\n## note on version ~1.0\n\nVersion ~1.0 had completely different motivation and is not compatible\nneither with 2.0 nor with standard node.js `inherits`.\n\nIf you are using version ~1.0 and planning to switch to ~2.0, be\ncareful:\n\n* new version uses `super_` instead of `super` for referencing\n  superclass\n* new version overwrites current prototype while old one preserves any\n  existing fields on it\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/inherits/issues"
+  },
+  "homepage": "https://github.com/isaacs/inherits",
+  "_id": "inherits@2.0.1",
+  "_shasum": "b17d08d326b4423e568eff719f91b0b1cbdf69f1",
+  "_from": "inherits@2",
+  "_resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/test.js b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/test.js
new file mode 100644
index 000000000..fc53012d3
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/node_modules/inherits/test.js
@@ -0,0 +1,25 @@
+var inherits = require('./inherits.js')
+var assert = require('assert')
+
+function test(c) {
+  assert(c.constructor === Child)
+  assert(c.constructor.super_ === Parent)
+  assert(Object.getPrototypeOf(c) === Child.prototype)
+  assert(Object.getPrototypeOf(Object.getPrototypeOf(c)) === Parent.prototype)
+  assert(c instanceof Child)
+  assert(c instanceof Parent)
+}
+
+function Child() {
+  Parent.call(this)
+  test(this)
+}
+
+function Parent() {}
+
+inherits(Child, Parent)
+
+var c = new Child
+test(c)
+
+console.log('ok')
diff --git a/node_modules/tar.gz/node_modules/fstream/package.json b/node_modules/tar.gz/node_modules/fstream/package.json
new file mode 100644
index 000000000..2d5d03565
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/fstream/package.json
@@ -0,0 +1,41 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "name": "fstream",
+  "description": "Advanced file system stream things",
+  "version": "0.1.31",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/fstream.git"
+  },
+  "main": "fstream.js",
+  "engines": {
+    "node": ">=0.6"
+  },
+  "dependencies": {
+    "graceful-fs": "~3.0.2",
+    "inherits": "~2.0.0",
+    "mkdirp": "0.5",
+    "rimraf": "2"
+  },
+  "devDependencies": {
+    "tap": ""
+  },
+  "scripts": {
+    "test": "tap examples/*.js"
+  },
+  "license": "BSD",
+  "readme": "Like FS streams, but with stat on them, and supporting directories and\nsymbolic links, as well as normal files.  Also, you can use this to set\nthe stats on a file, even if you don't change its contents, or to create\na symlink, etc.\n\nSo, for example, you can \"write\" a directory, and it'll call `mkdir`.  You\ncan specify a uid and gid, and it'll call `chown`.  You can specify a\n`mtime` and `atime`, and it'll call `utimes`.  You can call it a symlink\nand provide a `linkpath` and it'll call `symlink`.\n\nNote that it won't automatically resolve symbolic links.  So, if you\ncall `fstream.Reader('/some/symlink')` then you'll get an object\nthat stats and then ends immediately (since it has no data).  To follow\nsymbolic links, do this: `fstream.Reader({path:'/some/symlink', follow:\ntrue })`.\n\nThere are various checks to make sure that the bytes emitted are the\nsame as the intended size, if the size is set.\n\n## Examples\n\n```javascript\nfstream\n  .Writer({ path: \"path/to/file\"\n          , mode: 0755\n          , size: 6\n          })\n  .write(\"hello\\n\")\n  .end()\n```\n\nThis will create the directories if they're missing, and then write\n`hello\\n` into the file, chmod it to 0755, and assert that 6 bytes have\nbeen written when it's done.\n\n```javascript\nfstream\n  .Writer({ path: \"path/to/file\"\n          , mode: 0755\n          , size: 6\n          , flags: \"a\"\n          })\n  .write(\"hello\\n\")\n  .end()\n```\n\nYou can pass flags in, if you want to append to a file.\n\n```javascript\nfstream\n  .Writer({ path: \"path/to/symlink\"\n          , linkpath: \"./file\"\n          , SymbolicLink: true\n          , mode: \"0755\" // octal strings supported\n          })\n  .end()\n```\n\nIf isSymbolicLink is a function, it'll be called, and if it returns\ntrue, then it'll treat it as a symlink.  If it's not a function, then\nany truish value will make a symlink, or you can set `type:\n'SymbolicLink'`, which does the same thing.\n\nNote that the linkpath is relative to the symbolic link location, not\nthe parent dir or cwd.\n\n```javascript\nfstream\n  .Reader(\"path/to/dir\")\n  .pipe(fstream.Writer(\"path/to/other/dir\"))\n```\n\nThis will do like `cp -Rp path/to/dir path/to/other/dir`.  If the other\ndir exists and isn't a directory, then it'll emit an error.  It'll also\nset the uid, gid, mode, etc. to be identical.  In this way, it's more\nlike `rsync -a` than simply a copy.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/fstream/issues"
+  },
+  "homepage": "https://github.com/isaacs/fstream",
+  "_id": "fstream@0.1.31",
+  "_shasum": "7337f058fbbbbefa8c9f561a28cab0849202c988",
+  "_from": "fstream@0.1.x",
+  "_resolved": "https://registry.npmjs.org/fstream/-/fstream-0.1.31.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/tar/.npmignore b/node_modules/tar.gz/node_modules/tar/.npmignore
new file mode 100644
index 000000000..c167ad5b1
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/.npmignore
@@ -0,0 +1,5 @@
+.*.swp
+node_modules
+examples/extract/
+test/tmp/
+test/fixtures/
diff --git a/node_modules/tar.gz/node_modules/tar/.travis.yml b/node_modules/tar.gz/node_modules/tar/.travis.yml
new file mode 100644
index 000000000..2d26206d5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/.travis.yml
@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - 0.6
diff --git a/node_modules/tar.gz/node_modules/tar/LICENCE b/node_modules/tar.gz/node_modules/tar/LICENCE
new file mode 100644
index 000000000..74489e2e2
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/LICENCE
@@ -0,0 +1,25 @@
+Copyright (c) Isaac Z. Schlueter
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/tar.gz/node_modules/tar/README.md b/node_modules/tar.gz/node_modules/tar/README.md
new file mode 100644
index 000000000..424a2782b
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/README.md
@@ -0,0 +1,48 @@
+# node-tar
+
+Tar for Node.js.
+
+[![NPM](https://nodei.co/npm/tar.png)](https://nodei.co/npm/tar/)
+
+## API
+
+See `examples/` for usage examples.
+
+### var tar = require('tar')
+
+Returns an object with `.Pack`, `.Extract` and `.Parse` methods.
+
+### tar.Pack([properties])
+
+Returns a through stream. Use
+[fstream](https://npmjs.org/package/fstream) to write files into the
+pack stream and you will receive tar archive data from the pack
+stream.
+
+This only works with directories, it does not work with individual files.
+
+The optional `properties` object are used to set properties in the tar
+'Global Extended Header'.
+
+### tar.Extract([options])
+
+Returns a through stream. Write tar data to the stream and the files
+in the tarball will be extracted onto the filesystem.
+
+`options` can be:
+
+```js
+{
+  path: '/path/to/extract/tar/into',
+  strip: 0, // how many path segments to strip from the root when extracting
+}
+```
+
+`options` also get passed to the `fstream.Writer` instance that `tar`
+uses internally.
+
+### tar.Parse()
+
+Returns a writable stream. Write tar data to it and it will emit
+`entry` events for each entry parsed from the tarball. This is used by
+`tar.Extract`.
diff --git a/node_modules/tar.gz/node_modules/tar/examples/extracter.js b/node_modules/tar.gz/node_modules/tar/examples/extracter.js
new file mode 100644
index 000000000..e150abf25
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/examples/extracter.js
@@ -0,0 +1,11 @@
+var tar = require("../tar.js")
+  , fs = require("fs")
+
+fs.createReadStream(__dirname + "/../test/fixtures/c.tar")
+  .pipe(tar.Extract({ path: __dirname + "/extract" }))
+  .on("error", function (er) {
+    console.error("error here")
+  })
+  .on("end", function () {
+    console.error("done")
+  })
diff --git a/node_modules/tar.gz/node_modules/tar/examples/packer.js b/node_modules/tar.gz/node_modules/tar/examples/packer.js
new file mode 100644
index 000000000..ebe38926e
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/examples/packer.js
@@ -0,0 +1,10 @@
+var tar = require("../tar.js")
+  , fstream = require("fstream")
+  , fs = require("fs")
+
+var dir_destination = fs.createWriteStream('dir.tar')
+
+// This must be a "directory"
+fstream.Reader({ path: __dirname, type: "Directory" })
+  .pipe(tar.Pack({ noProprietary: true }))
+  .pipe(dir_destination)
\ No newline at end of file
diff --git a/node_modules/tar.gz/node_modules/tar/examples/reader.js b/node_modules/tar.gz/node_modules/tar/examples/reader.js
new file mode 100644
index 000000000..39f3f0888
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/examples/reader.js
@@ -0,0 +1,36 @@
+var tar = require("../tar.js")
+  , fs = require("fs")
+
+fs.createReadStream(__dirname + "/../test/fixtures/c.tar")
+  .pipe(tar.Parse())
+  .on("extendedHeader", function (e) {
+    console.error("extended pax header", e.props)
+    e.on("end", function () {
+      console.error("extended pax fields:", e.fields)
+    })
+  })
+  .on("ignoredEntry", function (e) {
+    console.error("ignoredEntry?!?", e.props)
+  })
+  .on("longLinkpath", function (e) {
+    console.error("longLinkpath entry", e.props)
+    e.on("end", function () {
+      console.error("value=%j", e.body.toString())
+    })
+  })
+  .on("longPath", function (e) {
+    console.error("longPath entry", e.props)
+    e.on("end", function () {
+      console.error("value=%j", e.body.toString())
+    })
+  })
+  .on("entry", function (e) {
+    console.error("entry", e.props)
+    e.on("data", function (c) {
+      console.error("  >>>" + c.toString().replace(/\n/g, "\\n"))
+    })
+    e.on("end", function () {
+      console.error("  <<<EOF")
+    })
+  })
+
diff --git a/node_modules/tar.gz/node_modules/tar/lib/buffer-entry.js b/node_modules/tar.gz/node_modules/tar/lib/buffer-entry.js
new file mode 100644
index 000000000..6c1da2373
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/buffer-entry.js
@@ -0,0 +1,30 @@
+// just like the Entry class, but it buffers the contents
+//
+// XXX It would be good to set a maximum BufferEntry filesize,
+// since it eats up memory.  In normal operation,
+// these are only for long filenames or link names, which are
+// rarely very big.
+
+module.exports = BufferEntry
+
+var inherits = require("inherits")
+  , Entry = require("./entry.js")
+
+function BufferEntry () {
+  Entry.apply(this, arguments)
+  this._buffer = new Buffer(this.props.size)
+  this._offset = 0
+  this.body = ""
+  this.on("end", function () {
+    this.body = this._buffer.toString().slice(0, -1)
+  })
+}
+
+inherits(BufferEntry, Entry)
+
+// collect the bytes as they come in.
+BufferEntry.prototype.write = function (c) {
+  c.copy(this._buffer, this._offset)
+  this._offset += c.length
+  Entry.prototype.write.call(this, c)
+}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/entry-writer.js b/node_modules/tar.gz/node_modules/tar/lib/entry-writer.js
new file mode 100644
index 000000000..8e09042d0
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/entry-writer.js
@@ -0,0 +1,169 @@
+module.exports = EntryWriter
+
+var tar = require("../tar.js")
+  , TarHeader = require("./header.js")
+  , Entry = require("./entry.js")
+  , inherits = require("inherits")
+  , BlockStream = require("block-stream")
+  , ExtendedHeaderWriter
+  , Stream = require("stream").Stream
+  , EOF = {}
+
+inherits(EntryWriter, Stream)
+
+function EntryWriter (props) {
+  var me = this
+
+  if (!(me instanceof EntryWriter)) {
+    return new EntryWriter(props)
+  }
+
+  Stream.apply(this)
+
+  me.writable = true
+  me.readable = true
+
+  me._stream = new BlockStream(512)
+
+  me._stream.on("data", function (c) {
+    me.emit("data", c)
+  })
+
+  me._stream.on("drain", function () {
+    me.emit("drain")
+  })
+
+  me._stream.on("end", function () {
+    me.emit("end")
+    me.emit("close")
+  })
+
+  me.props = props
+  if (props.type === "Directory") {
+    props.size = 0
+  }
+  props.ustar = "ustar\0"
+  props.ustarver = "00"
+  me.path = props.path
+
+  me._buffer = []
+  me._didHeader = false
+  me._meta = false
+
+  me.on("pipe", function () {
+    me._process()
+  })
+}
+
+EntryWriter.prototype.write = function (c) {
+  // console.error(".. ew write")
+  if (this._ended) return this.emit("error", new Error("write after end"))
+  this._buffer.push(c)
+  this._process()
+  this._needDrain = this._buffer.length > 0
+  return !this._needDrain
+}
+
+EntryWriter.prototype.end = function (c) {
+  // console.error(".. ew end")
+  if (c) this._buffer.push(c)
+  this._buffer.push(EOF)
+  this._ended = true
+  this._process()
+  this._needDrain = this._buffer.length > 0
+}
+
+EntryWriter.prototype.pause = function () {
+  // console.error(".. ew pause")
+  this._paused = true
+  this.emit("pause")
+}
+
+EntryWriter.prototype.resume = function () {
+  // console.error(".. ew resume")
+  this._paused = false
+  this.emit("resume")
+  this._process()
+}
+
+EntryWriter.prototype.add = function (entry) {
+  // console.error(".. ew add")
+  if (!this.parent) return this.emit("error", new Error("no parent"))
+
+  // make sure that the _header and such is emitted, and clear out
+  // the _currentEntry link on the parent.
+  if (!this._ended) this.end()
+
+  return this.parent.add(entry)
+}
+
+EntryWriter.prototype._header = function () {
+  // console.error(".. ew header")
+  if (this._didHeader) return
+  this._didHeader = true
+
+  var headerBlock = TarHeader.encode(this.props)
+
+  if (this.props.needExtended && !this._meta) {
+    var me = this
+
+    ExtendedHeaderWriter = ExtendedHeaderWriter ||
+      require("./extended-header-writer.js")
+
+    ExtendedHeaderWriter(this.props)
+      .on("data", function (c) {
+        me.emit("data", c)
+      })
+      .on("error", function (er) {
+        me.emit("error", er)
+      })
+      .end()
+  }
+
+  // console.error(".. .. ew headerBlock emitting")
+  this.emit("data", headerBlock)
+  this.emit("header")
+}
+
+EntryWriter.prototype._process = function () {
+  // console.error(".. .. ew process")
+  if (!this._didHeader && !this._meta) {
+    this._header()
+  }
+
+  if (this._paused || this._processing) {
+    // console.error(".. .. .. paused=%j, processing=%j", this._paused, this._processing)
+    return
+  }
+
+  this._processing = true
+
+  var buf = this._buffer
+  for (var i = 0; i < buf.length; i ++) {
+    // console.error(".. .. .. i=%d", i)
+
+    var c = buf[i]
+
+    if (c === EOF) this._stream.end()
+    else this._stream.write(c)
+
+    if (this._paused) {
+      // console.error(".. .. .. paused mid-emission")
+      this._processing = false
+      if (i < buf.length) {
+        this._needDrain = true
+        this._buffer = buf.slice(i + 1)
+      }
+      return
+    }
+  }
+
+  // console.error(".. .. .. emitted")
+  this._buffer.length = 0
+  this._processing = false
+
+  // console.error(".. .. .. emitting drain")
+  this.emit("drain")
+}
+
+EntryWriter.prototype.destroy = function () {}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/entry.js b/node_modules/tar.gz/node_modules/tar/lib/entry.js
new file mode 100644
index 000000000..4af5c4108
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/entry.js
@@ -0,0 +1,213 @@
+// A passthrough read/write stream that sets its properties
+// based on a header, extendedHeader, and globalHeader
+//
+// Can be either a file system object of some sort, or
+// a pax/ustar metadata entry.
+
+module.exports = Entry
+
+var TarHeader = require("./header.js")
+  , tar = require("../tar")
+  , assert = require("assert").ok
+  , Stream = require("stream").Stream
+  , inherits = require("inherits")
+  , fstream = require("fstream").Abstract
+
+function Entry (header, extended, global) {
+  Stream.call(this)
+  this.readable = true
+  this.writable = true
+
+  this._needDrain = false
+  this._paused = false
+  this._reading = false
+  this._ending = false
+  this._ended = false
+  this._remaining = 0
+  this._queue = []
+  this._index = 0
+  this._queueLen = 0
+
+  this._read = this._read.bind(this)
+
+  this.props = {}
+  this._header = header
+  this._extended = extended || {}
+
+  // globals can change throughout the course of
+  // a file parse operation.  Freeze it at its current state.
+  this._global = {}
+  var me = this
+  Object.keys(global || {}).forEach(function (g) {
+    me._global[g] = global[g]
+  })
+
+  this._setProps()
+}
+
+inherits(Entry, Stream)
+
+Entry.prototype.write = function (c) {
+  if (this._ending) this.error("write() after end()", null, true)
+  if (this._remaining === 0) {
+    this.error("invalid bytes past eof")
+  }
+
+  // often we'll get a bunch of \0 at the end of the last write,
+  // since chunks will always be 512 bytes when reading a tarball.
+  if (c.length > this._remaining) {
+    c = c.slice(0, this._remaining)
+  }
+  this._remaining -= c.length
+
+  // put it on the stack.
+  var ql = this._queueLen
+  this._queue.push(c)
+  this._queueLen ++
+
+  this._read()
+
+  // either paused, or buffered
+  if (this._paused || ql > 0) {
+    this._needDrain = true
+    return false
+  }
+
+  return true
+}
+
+Entry.prototype.end = function (c) {
+  if (c) this.write(c)
+  this._ending = true
+  this._read()
+}
+
+Entry.prototype.pause = function () {
+  this._paused = true
+  this.emit("pause")
+}
+
+Entry.prototype.resume = function () {
+  // console.error("    Tar Entry resume", this.path)
+  this.emit("resume")
+  this._paused = false
+  this._read()
+  return this._queueLen - this._index > 1
+}
+
+  // This is bound to the instance
+Entry.prototype._read = function () {
+  // console.error("    Tar Entry _read", this.path)
+
+  if (this._paused || this._reading || this._ended) return
+
+  // set this flag so that event handlers don't inadvertently
+  // get multiple _read() calls running.
+  this._reading = true
+
+  // have any data to emit?
+  while (this._index < this._queueLen && !this._paused) {
+    var chunk = this._queue[this._index ++]
+    this.emit("data", chunk)
+  }
+
+  // check if we're drained
+  if (this._index >= this._queueLen) {
+    this._queue.length = this._queueLen = this._index = 0
+    if (this._needDrain) {
+      this._needDrain = false
+      this.emit("drain")
+    }
+    if (this._ending) {
+      this._ended = true
+      this.emit("end")
+    }
+  }
+
+  // if the queue gets too big, then pluck off whatever we can.
+  // this should be fairly rare.
+  var mql = this._maxQueueLen
+  if (this._queueLen > mql && this._index > 0) {
+    mql = Math.min(this._index, mql)
+    this._index -= mql
+    this._queueLen -= mql
+    this._queue = this._queue.slice(mql)
+  }
+
+  this._reading = false
+}
+
+Entry.prototype._setProps = function () {
+  // props = extended->global->header->{}
+  var header = this._header
+    , extended = this._extended
+    , global = this._global
+    , props = this.props
+
+  // first get the values from the normal header.
+  var fields = tar.fields
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , val = header[field]
+    if (typeof val !== "undefined") props[field] = val
+  }
+
+  // next, the global header for this file.
+  // numeric values, etc, will have already been parsed.
+  ;[global, extended].forEach(function (p) {
+    Object.keys(p).forEach(function (f) {
+      if (typeof p[f] !== "undefined") props[f] = p[f]
+    })
+  })
+
+  // no nulls allowed in path or linkpath
+  ;["path", "linkpath"].forEach(function (p) {
+    if (props.hasOwnProperty(p)) {
+      props[p] = props[p].split("\0")[0]
+    }
+  })
+
+
+  // set date fields to be a proper date
+  ;["mtime", "ctime", "atime"].forEach(function (p) {
+    if (props.hasOwnProperty(p)) {
+      props[p] = new Date(props[p] * 1000)
+    }
+  })
+
+  // set the type so that we know what kind of file to create
+  var type
+  switch (tar.types[props.type]) {
+    case "OldFile":
+    case "ContiguousFile":
+      type = "File"
+      break
+
+    case "GNUDumpDir":
+      type = "Directory"
+      break
+
+    case undefined:
+      type = "Unknown"
+      break
+
+    case "Link":
+    case "SymbolicLink":
+    case "CharacterDevice":
+    case "BlockDevice":
+    case "Directory":
+    case "FIFO":
+    default:
+      type = tar.types[props.type]
+  }
+
+  this.type = type
+  this.path = props.path
+  this.size = props.size
+
+  // size is special, since it signals when the file needs to end.
+  this._remaining = props.size
+}
+
+Entry.prototype.warn = fstream.warn
+Entry.prototype.error = fstream.error
diff --git a/node_modules/tar.gz/node_modules/tar/lib/extended-header-writer.js b/node_modules/tar.gz/node_modules/tar/lib/extended-header-writer.js
new file mode 100644
index 000000000..1728c4583
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/extended-header-writer.js
@@ -0,0 +1,191 @@
+
+module.exports = ExtendedHeaderWriter
+
+var inherits = require("inherits")
+  , EntryWriter = require("./entry-writer.js")
+
+inherits(ExtendedHeaderWriter, EntryWriter)
+
+var tar = require("../tar.js")
+  , path = require("path")
+  , TarHeader = require("./header.js")
+
+// props is the props of the thing we need to write an
+// extended header for.
+// Don't be shy with it.  Just encode everything.
+function ExtendedHeaderWriter (props) {
+  // console.error(">> ehw ctor")
+  var me = this
+
+  if (!(me instanceof ExtendedHeaderWriter)) {
+    return new ExtendedHeaderWriter(props)
+  }
+
+  me.fields = props
+
+  var p =
+    { path : ("PaxHeader" + path.join("/", props.path || ""))
+             .replace(/\\/g, "/").substr(0, 100)
+    , mode : props.mode || 0666
+    , uid : props.uid || 0
+    , gid : props.gid || 0
+    , size : 0 // will be set later
+    , mtime : props.mtime || Date.now() / 1000
+    , type : "x"
+    , linkpath : ""
+    , ustar : "ustar\0"
+    , ustarver : "00"
+    , uname : props.uname || ""
+    , gname : props.gname || ""
+    , devmaj : props.devmaj || 0
+    , devmin : props.devmin || 0
+    }
+
+
+  EntryWriter.call(me, p)
+  // console.error(">> ehw props", me.props)
+  me.props = p
+
+  me._meta = true
+}
+
+ExtendedHeaderWriter.prototype.end = function () {
+  // console.error(">> ehw end")
+  var me = this
+
+  if (me._ended) return
+  me._ended = true
+
+  me._encodeFields()
+
+  if (me.props.size === 0) {
+    // nothing to write!
+    me._ready = true
+    me._stream.end()
+    return
+  }
+
+  me._stream.write(TarHeader.encode(me.props))
+  me.body.forEach(function (l) {
+    me._stream.write(l)
+  })
+  me._ready = true
+
+  // console.error(">> ehw _process calling end()", me.props)
+  this._stream.end()
+}
+
+ExtendedHeaderWriter.prototype._encodeFields = function () {
+  // console.error(">> ehw _encodeFields")
+  this.body = []
+  if (this.fields.prefix) {
+    this.fields.path = this.fields.prefix + "/" + this.fields.path
+    this.fields.prefix = ""
+  }
+  encodeFields(this.fields, "", this.body, this.fields.noProprietary)
+  var me = this
+  this.body.forEach(function (l) {
+    me.props.size += l.length
+  })
+}
+
+function encodeFields (fields, prefix, body, nop) {
+  // console.error(">> >> ehw encodeFields")
+  // "%d %s=%s\n", <length>, <keyword>, <value>
+  // The length is a decimal number, and includes itself and the \n
+  // Numeric values are decimal strings.
+
+  Object.keys(fields).forEach(function (k) {
+    var val = fields[k]
+      , numeric = tar.numeric[k]
+
+    if (prefix) k = prefix + "." + k
+
+    // already including NODETAR.type, don't need File=true also
+    if (k === fields.type && val === true) return
+
+    switch (k) {
+      // don't include anything that's always handled just fine
+      // in the normal header, or only meaningful in the context
+      // of nodetar
+      case "mode":
+      case "cksum":
+      case "ustar":
+      case "ustarver":
+      case "prefix":
+      case "basename":
+      case "dirname":
+      case "needExtended":
+      case "block":
+      case "filter":
+        return
+
+      case "rdev":
+        if (val === 0) return
+        break
+
+      case "nlink":
+      case "dev": // Truly a hero among men, Creator of Star!
+      case "ino": // Speak his name with reverent awe!  It is:
+        k = "SCHILY." + k
+        break
+
+      default: break
+    }
+
+    if (val && typeof val === "object" &&
+        !Buffer.isBuffer(val)) encodeFields(val, k, body, nop)
+    else if (val === null || val === undefined) return
+    else body.push.apply(body, encodeField(k, val, nop))
+  })
+
+  return body
+}
+
+function encodeField (k, v, nop) {
+  // lowercase keys must be valid, otherwise prefix with
+  // "NODETAR."
+  if (k.charAt(0) === k.charAt(0).toLowerCase()) {
+    var m = k.split(".")[0]
+    if (!tar.knownExtended[m]) k = "NODETAR." + k
+  }
+
+  // no proprietary
+  if (nop && k.charAt(0) !== k.charAt(0).toLowerCase()) {
+    return []
+  }
+
+  if (typeof val === "number") val = val.toString(10)
+
+  var s = new Buffer(" " + k + "=" + v + "\n")
+    , digits = Math.floor(Math.log(s.length) / Math.log(10)) + 1
+
+  // console.error("1 s=%j digits=%j s.length=%d", s.toString(), digits, s.length)
+
+  // if adding that many digits will make it go over that length,
+  // then add one to it. For example, if the string is:
+  // " foo=bar\n"
+  // then that's 9 characters.  With the "9", that bumps the length
+  // up to 10.  However, this is invalid:
+  // "10 foo=bar\n"
+  // but, since that's actually 11 characters, since 10 adds another
+  // character to the length, and the length includes the number
+  // itself.  In that case, just bump it up again.
+  if (s.length + digits >= Math.pow(10, digits)) digits += 1
+  // console.error("2 s=%j digits=%j s.length=%d", s.toString(), digits, s.length)
+
+  var len = digits + s.length
+  // console.error("3 s=%j digits=%j s.length=%d len=%d", s.toString(), digits, s.length, len)
+  var lenBuf = new Buffer("" + len)
+  if (lenBuf.length + s.length !== len) {
+    throw new Error("Bad length calculation\n"+
+                    "len="+len+"\n"+
+                    "lenBuf="+JSON.stringify(lenBuf.toString())+"\n"+
+                    "lenBuf.length="+lenBuf.length+"\n"+
+                    "digits="+digits+"\n"+
+                    "s="+JSON.stringify(s.toString())+"\n"+
+                    "s.length="+s.length)
+  }
+
+  return [lenBuf, s]
+}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/extended-header.js b/node_modules/tar.gz/node_modules/tar/lib/extended-header.js
new file mode 100644
index 000000000..74f432cee
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/extended-header.js
@@ -0,0 +1,140 @@
+// An Entry consisting of:
+//
+// "%d %s=%s\n", <length>, <keyword>, <value>
+//
+// The length is a decimal number, and includes itself and the \n
+// \0 does not terminate anything.  Only the length terminates the string.
+// Numeric values are decimal strings.
+
+module.exports = ExtendedHeader
+
+var Entry = require("./entry.js")
+  , inherits = require("inherits")
+  , tar = require("../tar.js")
+  , numeric = tar.numeric
+  , keyTrans = { "SCHILY.dev": "dev"
+               , "SCHILY.ino": "ino"
+               , "SCHILY.nlink": "nlink" }
+
+function ExtendedHeader () {
+  Entry.apply(this, arguments)
+  this.on("data", this._parse)
+  this.fields = {}
+  this._position = 0
+  this._fieldPos = 0
+  this._state = SIZE
+  this._sizeBuf = []
+  this._keyBuf = []
+  this._valBuf = []
+  this._size = -1
+  this._key = ""
+}
+
+inherits(ExtendedHeader, Entry)
+ExtendedHeader.prototype._parse = parse
+
+var s = 0
+  , states = ExtendedHeader.states = {}
+  , SIZE = states.SIZE = s++
+  , KEY  = states.KEY  = s++
+  , VAL  = states.VAL  = s++
+  , ERR  = states.ERR  = s++
+
+Object.keys(states).forEach(function (s) {
+  states[states[s]] = states[s]
+})
+
+states[s] = null
+
+// char code values for comparison
+var _0 = "0".charCodeAt(0)
+  , _9 = "9".charCodeAt(0)
+  , point = ".".charCodeAt(0)
+  , a = "a".charCodeAt(0)
+  , Z = "Z".charCodeAt(0)
+  , a = "a".charCodeAt(0)
+  , z = "z".charCodeAt(0)
+  , space = " ".charCodeAt(0)
+  , eq = "=".charCodeAt(0)
+  , cr = "\n".charCodeAt(0)
+
+function parse (c) {
+  if (this._state === ERR) return
+
+  for ( var i = 0, l = c.length
+      ; i < l
+      ; this._position++, this._fieldPos++, i++) {
+    // console.error("top of loop, size="+this._size)
+
+    var b = c[i]
+
+    if (this._size >= 0 && this._fieldPos > this._size) {
+      error(this, "field exceeds length="+this._size)
+      return
+    }
+
+    switch (this._state) {
+      case ERR: return
+
+      case SIZE:
+        // console.error("parsing size, b=%d, rest=%j", b, c.slice(i).toString())
+        if (b === space) {
+          this._state = KEY
+          // this._fieldPos = this._sizeBuf.length
+          this._size = parseInt(new Buffer(this._sizeBuf).toString(), 10)
+          this._sizeBuf.length = 0
+          continue
+        }
+        if (b < _0 || b > _9) {
+          error(this, "expected [" + _0 + ".." + _9 + "], got " + b)
+          return
+        }
+        this._sizeBuf.push(b)
+        continue
+
+      case KEY:
+        // can be any char except =, not > size.
+        if (b === eq) {
+          this._state = VAL
+          this._key = new Buffer(this._keyBuf).toString()
+          if (keyTrans[this._key]) this._key = keyTrans[this._key]
+          this._keyBuf.length = 0
+          continue
+        }
+        this._keyBuf.push(b)
+        continue
+
+      case VAL:
+        // field must end with cr
+        if (this._fieldPos === this._size - 1) {
+          // console.error("finished with "+this._key)
+          if (b !== cr) {
+            error(this, "expected \\n at end of field")
+            return
+          }
+          var val = new Buffer(this._valBuf).toString()
+          if (numeric[this._key]) {
+            val = parseFloat(val)
+          }
+          this.fields[this._key] = val
+
+          this._valBuf.length = 0
+          this._state = SIZE
+          this._size = -1
+          this._fieldPos = -1
+          continue
+        }
+        this._valBuf.push(b)
+        continue
+    }
+  }
+}
+
+function error (me, msg) {
+  msg = "invalid header: " + msg
+      + "\nposition=" + me._position
+      + "\nfield position=" + me._fieldPos
+
+  me.error(msg)
+  me.state = ERR
+}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/extract.js b/node_modules/tar.gz/node_modules/tar/lib/extract.js
new file mode 100644
index 000000000..c34a81e21
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/extract.js
@@ -0,0 +1,78 @@
+// give it a tarball and a path, and it'll dump the contents
+
+module.exports = Extract
+
+var tar = require("../tar.js")
+  , fstream = require("fstream")
+  , inherits = require("inherits")
+  , path = require("path")
+
+function Extract (opts) {
+  if (!(this instanceof Extract)) return new Extract(opts)
+  tar.Parse.apply(this)
+
+  // have to dump into a directory
+  opts.type = "Directory"
+  opts.Directory = true
+
+  if (typeof opts !== "object") {
+    opts = { path: opts }
+  }
+
+  // better to drop in cwd? seems more standard.
+  opts.path = opts.path || path.resolve("node-tar-extract")
+  opts.type = "Directory"
+  opts.Directory = true
+
+  // similar to --strip or --strip-components
+  opts.strip = +opts.strip
+  if (!opts.strip || opts.strip <= 0) opts.strip = 0
+
+  this._fst = fstream.Writer(opts)
+
+  this.pause()
+  var me = this
+
+  // Hardlinks in tarballs are relative to the root
+  // of the tarball.  So, they need to be resolved against
+  // the target directory in order to be created properly.
+  me.on("entry", function (entry) {
+    // if there's a "strip" argument, then strip off that many
+    // path components.
+    if (opts.strip) {
+      var p = entry.path.split("/").slice(opts.strip).join("/")
+      entry.path = entry.props.path = p
+      if (entry.linkpath) {
+        var lp = entry.linkpath.split("/").slice(opts.strip).join("/")
+        entry.linkpath = entry.props.linkpath = lp
+      }
+    }
+    if (entry.type !== "Link") return
+    entry.linkpath = entry.props.linkpath =
+      path.join(opts.path, path.join("/", entry.props.linkpath))
+  })
+
+  this._fst.on("ready", function () {
+    me.pipe(me._fst, { end: false })
+    me.resume()
+  })
+
+  // this._fst.on("end", function () {
+  //   console.error("\nEEEE Extract End", me._fst.path)
+  // })
+
+  this._fst.on("close", function () {
+    // console.error("\nEEEE Extract End", me._fst.path)
+    me.emit("end")
+    me.emit("close")
+  })
+}
+
+inherits(Extract, tar.Parse)
+
+Extract.prototype._streamEnd = function () {
+  var me = this
+  if (!me._ended) me.error("unexpected eof")
+  me._fst.end()
+  // my .end() is coming later.
+}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/global-header-writer.js b/node_modules/tar.gz/node_modules/tar/lib/global-header-writer.js
new file mode 100644
index 000000000..0bfc7b80a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/global-header-writer.js
@@ -0,0 +1,14 @@
+module.exports = GlobalHeaderWriter
+
+var ExtendedHeaderWriter = require("./extended-header-writer.js")
+  , inherits = require("inherits")
+
+inherits(GlobalHeaderWriter, ExtendedHeaderWriter)
+
+function GlobalHeaderWriter (props) {
+  if (!(this instanceof GlobalHeaderWriter)) {
+    return new GlobalHeaderWriter(props)
+  }
+  ExtendedHeaderWriter.call(this, props)
+  this.props.type = "g"
+}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/header.js b/node_modules/tar.gz/node_modules/tar/lib/header.js
new file mode 100644
index 000000000..05b237c0c
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/header.js
@@ -0,0 +1,385 @@
+// parse a 512-byte header block to a data object, or vice-versa
+// If the data won't fit nicely in a simple header, then generate
+// the appropriate extended header file, and return that.
+
+module.exports = TarHeader
+
+var tar = require("../tar.js")
+  , fields = tar.fields
+  , fieldOffs = tar.fieldOffs
+  , fieldEnds = tar.fieldEnds
+  , fieldSize = tar.fieldSize
+  , numeric = tar.numeric
+  , assert = require("assert").ok
+  , space = " ".charCodeAt(0)
+  , slash = "/".charCodeAt(0)
+  , bslash = process.platform === "win32" ? "\\".charCodeAt(0) : null
+
+function TarHeader (block) {
+  if (!(this instanceof TarHeader)) return new TarHeader(block)
+  if (block) this.decode(block)
+}
+
+TarHeader.prototype =
+  { decode : decode
+  , encode: encode
+  , calcSum: calcSum
+  , checkSum: checkSum
+  }
+
+TarHeader.parseNumeric = parseNumeric
+TarHeader.encode = encode
+TarHeader.decode = decode
+
+// note that this will only do the normal ustar header, not any kind
+// of extended posix header file.  If something doesn't fit comfortably,
+// then it will set obj.needExtended = true, and set the block to
+// the closest approximation.
+function encode (obj) {
+  if (!obj && !(this instanceof TarHeader)) throw new Error(
+    "encode must be called on a TarHeader, or supplied an object")
+
+  obj = obj || this
+  var block = obj.block = new Buffer(512)
+
+  // if the object has a "prefix", then that's actually an extension of
+  // the path field.
+  if (obj.prefix) {
+    // console.error("%% header encoding, got a prefix", obj.prefix)
+    obj.path = obj.prefix + "/" + obj.path
+    // console.error("%% header encoding, prefixed path", obj.path)
+    obj.prefix = ""
+  }
+
+  obj.needExtended = false
+
+  if (obj.mode) {
+    if (typeof obj.mode === "string") obj.mode = parseInt(obj.mode, 8)
+    obj.mode = obj.mode & 0777
+  }
+
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , off = fieldOffs[f]
+      , end = fieldEnds[f]
+      , ret
+
+    switch (field) {
+      case "cksum":
+        // special, done below, after all the others
+        break
+
+      case "prefix":
+        // special, this is an extension of the "path" field.
+        // console.error("%% header encoding, skip prefix later")
+        break
+
+      case "type":
+        // convert from long name to a single char.
+        var type = obj.type || "0"
+        if (type.length > 1) {
+          type = tar.types[obj.type]
+          if (!type) type = "0"
+        }
+        writeText(block, off, end, type)
+        break
+
+      case "path":
+        // uses the "prefix" field if > 100 bytes, but <= 255
+        var pathLen = Buffer.byteLength(obj.path)
+          , pathFSize = fieldSize[fields.path]
+          , prefFSize = fieldSize[fields.prefix]
+
+        // paths between 100 and 255 should use the prefix field.
+        // longer than 255
+        if (pathLen > pathFSize &&
+            pathLen <= pathFSize + prefFSize) {
+          // need to find a slash somewhere in the middle so that
+          // path and prefix both fit in their respective fields
+          var searchStart = pathLen - 1 - pathFSize
+            , searchEnd = prefFSize
+            , found = false
+            , pathBuf = new Buffer(obj.path)
+
+          for ( var s = searchStart
+              ; (s <= searchEnd)
+              ; s ++ ) {
+            if (pathBuf[s] === slash || pathBuf[s] === bslash) {
+              found = s
+              break
+            }
+          }
+
+          if (found !== false) {
+            prefix = pathBuf.slice(0, found).toString("utf8")
+            path = pathBuf.slice(found + 1).toString("utf8")
+
+            ret = writeText(block, off, end, path)
+            off = fieldOffs[fields.prefix]
+            end = fieldEnds[fields.prefix]
+            // console.error("%% header writing prefix", off, end, prefix)
+            ret = writeText(block, off, end, prefix) || ret
+            break
+          }
+        }
+
+        // paths less than 100 chars don't need a prefix
+        // and paths longer than 255 need an extended header and will fail
+        // on old implementations no matter what we do here.
+        // Null out the prefix, and fallthrough to default.
+        // console.error("%% header writing no prefix")
+        var poff = fieldOffs[fields.prefix]
+          , pend = fieldEnds[fields.prefix]
+        writeText(block, poff, pend, "")
+        // fallthrough
+
+      // all other fields are numeric or text
+      default:
+        ret = numeric[field]
+            ? writeNumeric(block, off, end, obj[field])
+            : writeText(block, off, end, obj[field] || "")
+        break
+    }
+    obj.needExtended = obj.needExtended || ret
+  }
+
+  var off = fieldOffs[fields.cksum]
+    , end = fieldEnds[fields.cksum]
+
+  writeNumeric(block, off, end, calcSum.call(this, block))
+
+  return block
+}
+
+// if it's a negative number, or greater than will fit,
+// then use write256.
+var MAXNUM = { 12: 077777777777
+             , 11: 07777777777
+             , 8 : 07777777
+             , 7 : 0777777 }
+function writeNumeric (block, off, end, num) {
+  var writeLen = end - off
+    , maxNum = MAXNUM[writeLen] || 0
+
+  num = num || 0
+  // console.error("  numeric", num)
+
+  if (num instanceof Date ||
+      Object.prototype.toString.call(num) === "[object Date]") {
+    num = num.getTime() / 1000
+  }
+
+  if (num > maxNum || num < 0) {
+    write256(block, off, end, num)
+    // need an extended header if negative or too big.
+    return true
+  }
+
+  // god, tar is so annoying
+  // if the string is small enough, you should put a space
+  // between the octal string and the \0, but if it doesn't
+  // fit, then don't.
+  var numStr = Math.floor(num).toString(8)
+  if (num < MAXNUM[writeLen - 1]) numStr += " "
+
+  // pad with "0" chars
+  if (numStr.length < writeLen) {
+    numStr = (new Array(writeLen - numStr.length).join("0")) + numStr
+  }
+
+  if (numStr.length !== writeLen - 1) {
+    throw new Error("invalid length: " + JSON.stringify(numStr) + "\n" +
+                    "expected: "+writeLen)
+  }
+  block.write(numStr, off, writeLen, "utf8")
+  block[end - 1] = 0
+}
+
+function write256 (block, off, end, num) {
+  var buf = block.slice(off, end)
+  var positive = num >= 0
+  buf[0] = positive ? 0x80 : 0xFF
+
+  // get the number as a base-256 tuple
+  if (!positive) num *= -1
+  var tuple = []
+  do {
+    var n = num % 256
+    tuple.push(n)
+    num = (num - n) / 256
+  } while (num)
+
+  var bytes = tuple.length
+
+  var fill = buf.length - bytes
+  for (var i = 1; i < fill; i ++) {
+    buf[i] = positive ? 0 : 0xFF
+  }
+
+  // tuple is a base256 number, with [0] as the *least* significant byte
+  // if it's negative, then we need to flip all the bits once we hit the
+  // first non-zero bit.  The 2's-complement is (0x100 - n), and the 1's-
+  // complement is (0xFF - n).
+  var zero = true
+  for (i = bytes; i > 0; i --) {
+    var byte = tuple[bytes - i]
+    if (positive) buf[fill + i] = byte
+    else if (zero && byte === 0) buf[fill + i] = 0
+    else if (zero) {
+      zero = false
+      buf[fill + i] = 0x100 - byte
+    } else buf[fill + i] = 0xFF - byte
+  }
+}
+
+function writeText (block, off, end, str) {
+  // strings are written as utf8, then padded with \0
+  var strLen = Buffer.byteLength(str)
+    , writeLen = Math.min(strLen, end - off)
+    // non-ascii fields need extended headers
+    // long fields get truncated
+    , needExtended = strLen !== str.length || strLen > writeLen
+
+  // write the string, and null-pad
+  if (writeLen > 0) block.write(str, off, writeLen, "utf8")
+  for (var i = off + writeLen; i < end; i ++) block[i] = 0
+
+  return needExtended
+}
+
+function calcSum (block) {
+  block = block || this.block
+  assert(Buffer.isBuffer(block) && block.length === 512)
+
+  if (!block) throw new Error("Need block to checksum")
+
+  // now figure out what it would be if the cksum was "        "
+  var sum = 0
+    , start = fieldOffs[fields.cksum]
+    , end = fieldEnds[fields.cksum]
+
+  for (var i = 0; i < fieldOffs[fields.cksum]; i ++) {
+    sum += block[i]
+  }
+
+  for (var i = start; i < end; i ++) {
+    sum += space
+  }
+
+  for (var i = end; i < 512; i ++) {
+    sum += block[i]
+  }
+
+  return sum
+}
+
+
+function checkSum (block) {
+  var sum = calcSum.call(this, block)
+  block = block || this.block
+
+  var cksum = block.slice(fieldOffs[fields.cksum], fieldEnds[fields.cksum])
+  cksum = parseNumeric(cksum)
+
+  return cksum === sum
+}
+
+function decode (block) {
+  block = block || this.block
+  assert(Buffer.isBuffer(block) && block.length === 512)
+
+  this.block = block
+  this.cksumValid = this.checkSum()
+
+  var prefix = null
+
+  // slice off each field.
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , val = block.slice(fieldOffs[f], fieldEnds[f])
+
+    switch (field) {
+      case "ustar":
+        // if not ustar, then everything after that is just padding.
+        if (val.toString() !== "ustar\0") {
+          this.ustar = false
+          return
+        } else {
+          // console.error("ustar:", val, val.toString())
+          this.ustar = val.toString()
+        }
+        break
+
+      // prefix is special, since it might signal the xstar header
+      case "prefix":
+        var atime = parseNumeric(val.slice(131, 131 + 12))
+          , ctime = parseNumeric(val.slice(131 + 12, 131 + 12 + 12))
+        if ((val[130] === 0 || val[130] === space) &&
+            typeof atime === "number" &&
+            typeof ctime === "number" &&
+            val[131 + 12] === space &&
+            val[131 + 12 + 12] === space) {
+          this.atime = atime
+          this.ctime = ctime
+          val = val.slice(0, 130)
+        }
+        prefix = val.toString("utf8").replace(/\0+$/, "")
+        // console.error("%% header reading prefix", prefix)
+        break
+
+      // all other fields are null-padding text
+      // or a number.
+      default:
+        if (numeric[field]) {
+          this[field] = parseNumeric(val)
+        } else {
+          this[field] = val.toString("utf8").replace(/\0+$/, "")
+        }
+        break
+    }
+  }
+
+  // if we got a prefix, then prepend it to the path.
+  if (prefix) {
+    this.path = prefix + "/" + this.path
+    // console.error("%% header got a prefix", this.path)
+  }
+}
+
+function parse256 (buf) {
+  // first byte MUST be either 80 or FF
+  // 80 for positive, FF for 2's comp
+  var positive
+  if (buf[0] === 0x80) positive = true
+  else if (buf[0] === 0xFF) positive = false
+  else return null
+
+  // build up a base-256 tuple from the least sig to the highest
+  var zero = false
+    , tuple = []
+  for (var i = buf.length - 1; i > 0; i --) {
+    var byte = buf[i]
+    if (positive) tuple.push(byte)
+    else if (zero && byte === 0) tuple.push(0)
+    else if (zero) {
+      zero = false
+      tuple.push(0x100 - byte)
+    } else tuple.push(0xFF - byte)
+  }
+
+  for (var sum = 0, i = 0, l = tuple.length; i < l; i ++) {
+    sum += tuple[i] * Math.pow(256, i)
+  }
+
+  return positive ? sum : -1 * sum
+}
+
+function parseNumeric (f) {
+  if (f[0] & 0x80) return parse256(f)
+
+  var str = f.toString("utf8").split("\0")[0].trim()
+    , res = parseInt(str, 8)
+
+  return isNaN(res) ? null : res
+}
+
diff --git a/node_modules/tar.gz/node_modules/tar/lib/pack.js b/node_modules/tar.gz/node_modules/tar/lib/pack.js
new file mode 100644
index 000000000..3ff14dd69
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/pack.js
@@ -0,0 +1,231 @@
+// pipe in an fstream, and it'll make a tarball.
+// key-value pair argument is global extended header props.
+
+module.exports = Pack
+
+var EntryWriter = require("./entry-writer.js")
+  , Stream = require("stream").Stream
+  , path = require("path")
+  , inherits = require("inherits")
+  , GlobalHeaderWriter = require("./global-header-writer.js")
+  , collect = require("fstream").collect
+  , eof = new Buffer(512)
+
+for (var i = 0; i < 512; i ++) eof[i] = 0
+
+inherits(Pack, Stream)
+
+function Pack (props) {
+  // console.error("-- p ctor")
+  var me = this
+  if (!(me instanceof Pack)) return new Pack(props)
+
+  if (props) me._noProprietary = props.noProprietary
+  else me._noProprietary = false
+
+  me._global = props
+
+  me.readable = true
+  me.writable = true
+  me._buffer = []
+  // console.error("-- -- set current to null in ctor")
+  me._currentEntry = null
+  me._processing = false
+
+  me._pipeRoot = null
+  me.on("pipe", function (src) {
+    if (src.root === me._pipeRoot) return
+    me._pipeRoot = src
+    src.on("end", function () {
+      me._pipeRoot = null
+    })
+    me.add(src)
+  })
+}
+
+Pack.prototype.addGlobal = function (props) {
+  // console.error("-- p addGlobal")
+  if (this._didGlobal) return
+  this._didGlobal = true
+
+  var me = this
+  GlobalHeaderWriter(props)
+    .on("data", function (c) {
+      me.emit("data", c)
+    })
+    .end()
+}
+
+Pack.prototype.add = function (stream) {
+  if (this._global && !this._didGlobal) this.addGlobal(this._global)
+
+  if (this._ended) return this.emit("error", new Error("add after end"))
+
+  collect(stream)
+  this._buffer.push(stream)
+  this._process()
+  this._needDrain = this._buffer.length > 0
+  return !this._needDrain
+}
+
+Pack.prototype.pause = function () {
+  this._paused = true
+  if (this._currentEntry) this._currentEntry.pause()
+  this.emit("pause")
+}
+
+Pack.prototype.resume = function () {
+  this._paused = false
+  if (this._currentEntry) this._currentEntry.resume()
+  this.emit("resume")
+  this._process()
+}
+
+Pack.prototype.end = function () {
+  this._ended = true
+  this._buffer.push(eof)
+  this._process()
+}
+
+Pack.prototype._process = function () {
+  var me = this
+  if (me._paused || me._processing) {
+    return
+  }
+
+  var entry = me._buffer.shift()
+
+  if (!entry) {
+    if (me._needDrain) {
+      me.emit("drain")
+    }
+    return
+  }
+
+  if (entry.ready === false) {
+    // console.error("-- entry is not ready", entry)
+    me._buffer.unshift(entry)
+    entry.on("ready", function () {
+      // console.error("-- -- ready!", entry)
+      me._process()
+    })
+    return
+  }
+
+  me._processing = true
+
+  if (entry === eof) {
+    // need 2 ending null blocks.
+    me.emit("data", eof)
+    me.emit("data", eof)
+    me.emit("end")
+    me.emit("close")
+    return
+  }
+
+  // Change the path to be relative to the root dir that was
+  // added to the tarball.
+  //
+  // XXX This should be more like how -C works, so you can
+  // explicitly set a root dir, and also explicitly set a pathname
+  // in the tarball to use.  That way we can skip a lot of extra
+  // work when resolving symlinks for bundled dependencies in npm.
+
+  var root = path.dirname((entry.root || entry).path)
+  var wprops = {}
+
+  Object.keys(entry.props || {}).forEach(function (k) {
+    wprops[k] = entry.props[k]
+  })
+
+  if (me._noProprietary) wprops.noProprietary = true
+
+  wprops.path = path.relative(root, entry.path || '')
+
+  // actually not a matter of opinion or taste.
+  if (process.platform === "win32") {
+    wprops.path = wprops.path.replace(/\\/g, "/")
+  }
+
+  if (!wprops.type)
+    wprops.type = 'Directory'
+
+  switch (wprops.type) {
+    // sockets not supported
+    case "Socket":
+      return
+
+    case "Directory":
+      wprops.path += "/"
+      wprops.size = 0
+      break
+
+    case "Link":
+      var lp = path.resolve(path.dirname(entry.path), entry.linkpath)
+      wprops.linkpath = path.relative(root, lp) || "."
+      wprops.size = 0
+      break
+
+    case "SymbolicLink":
+      var lp = path.resolve(path.dirname(entry.path), entry.linkpath)
+      wprops.linkpath = path.relative(path.dirname(entry.path), lp) || "."
+      wprops.size = 0
+      break
+  }
+
+  // console.error("-- new writer", wprops)
+  // if (!wprops.type) {
+  //   // console.error("-- no type?", entry.constructor.name, entry)
+  // }
+
+  // console.error("-- -- set current to new writer", wprops.path)
+  var writer = me._currentEntry = EntryWriter(wprops)
+
+  writer.parent = me
+
+  // writer.on("end", function () {
+  //   // console.error("-- -- writer end", writer.path)
+  // })
+
+  writer.on("data", function (c) {
+    me.emit("data", c)
+  })
+
+  writer.on("header", function () {
+    Buffer.prototype.toJSON = function () {
+      return this.toString().split(/\0/).join(".")
+    }
+    // console.error("-- -- writer header %j", writer.props)
+    if (writer.props.size === 0) nextEntry()
+  })
+  writer.on("close", nextEntry)
+
+  var ended = false
+  function nextEntry () {
+    if (ended) return
+    ended = true
+
+    // console.error("-- -- writer close", writer.path)
+    // console.error("-- -- set current to null", wprops.path)
+    me._currentEntry = null
+    me._processing = false
+    me._process()
+  }
+
+  writer.on("error", function (er) {
+    // console.error("-- -- writer error", writer.path)
+    me.emit("error", er)
+  })
+
+  // if it's the root, then there's no need to add its entries,
+  // or data, since they'll be added directly.
+  if (entry === me._pipeRoot) {
+    // console.error("-- is the root, don't auto-add")
+    writer.add = null
+  }
+
+  entry.pipe(writer)
+}
+
+Pack.prototype.destroy = function () {}
+Pack.prototype.write = function () {}
diff --git a/node_modules/tar.gz/node_modules/tar/lib/parse.js b/node_modules/tar.gz/node_modules/tar/lib/parse.js
new file mode 100644
index 000000000..009a85f41
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/lib/parse.js
@@ -0,0 +1,271 @@
+
+// A writable stream.
+// It emits "entry" events, which provide a readable stream that has
+// header info attached.
+
+module.exports = Parse.create = Parse
+
+var stream = require("stream")
+  , Stream = stream.Stream
+  , BlockStream = require("block-stream")
+  , tar = require("../tar.js")
+  , TarHeader = require("./header.js")
+  , Entry = require("./entry.js")
+  , BufferEntry = require("./buffer-entry.js")
+  , ExtendedHeader = require("./extended-header.js")
+  , assert = require("assert").ok
+  , inherits = require("inherits")
+  , fstream = require("fstream")
+
+// reading a tar is a lot like reading a directory
+// However, we're actually not going to run the ctor,
+// since it does a stat and various other stuff.
+// This inheritance gives us the pause/resume/pipe
+// behavior that is desired.
+inherits(Parse, fstream.Reader)
+
+function Parse () {
+  var me = this
+  if (!(me instanceof Parse)) return new Parse()
+
+  // doesn't apply fstream.Reader ctor?
+  // no, becasue we don't want to stat/etc, we just
+  // want to get the entry/add logic from .pipe()
+  Stream.apply(me)
+
+  me.writable = true
+  me.readable = true
+  me._stream = new BlockStream(512)
+  me.position = 0
+  me._ended = false
+
+  me._stream.on("error", function (e) {
+    me.emit("error", e)
+  })
+
+  me._stream.on("data", function (c) {
+    me._process(c)
+  })
+
+  me._stream.on("end", function () {
+    me._streamEnd()
+  })
+
+  me._stream.on("drain", function () {
+    me.emit("drain")
+  })
+}
+
+// overridden in Extract class, since it needs to
+// wait for its DirWriter part to finish before
+// emitting "end"
+Parse.prototype._streamEnd = function () {
+  var me = this
+  if (!me._ended) me.error("unexpected eof")
+  me.emit("end")
+}
+
+// a tar reader is actually a filter, not just a readable stream.
+// So, you should pipe a tarball stream into it, and it needs these
+// write/end methods to do that.
+Parse.prototype.write = function (c) {
+  if (this._ended) {
+    // gnutar puts a LOT of nulls at the end.
+    // you can keep writing these things forever.
+    // Just ignore them.
+    for (var i = 0, l = c.length; i > l; i ++) {
+      if (c[i] !== 0) return this.error("write() after end()")
+    }
+    return
+  }
+  return this._stream.write(c)
+}
+
+Parse.prototype.end = function (c) {
+  this._ended = true
+  return this._stream.end(c)
+}
+
+// don't need to do anything, since we're just
+// proxying the data up from the _stream.
+// Just need to override the parent's "Not Implemented"
+// error-thrower.
+Parse.prototype._read = function () {}
+
+Parse.prototype._process = function (c) {
+  assert(c && c.length === 512, "block size should be 512")
+
+  // one of three cases.
+  // 1. A new header
+  // 2. A part of a file/extended header
+  // 3. One of two or more EOF null blocks
+
+  if (this._entry) {
+    var entry = this._entry
+    entry.write(c)
+    if (entry._remaining === 0) {
+      entry.end()
+      this._entry = null
+    }
+  } else {
+    // either zeroes or a header
+    var zero = true
+    for (var i = 0; i < 512 && zero; i ++) {
+      zero = c[i] === 0
+    }
+
+    // eof is *at least* 2 blocks of nulls, and then the end of the
+    // file.  you can put blocks of nulls between entries anywhere,
+    // so appending one tarball to another is technically valid.
+    // ending without the eof null blocks is not allowed, however.
+    if (zero) {
+      if (this._eofStarted)
+        this._ended = true
+      this._eofStarted = true
+    } else {
+      this._eofStarted = false
+      this._startEntry(c)
+    }
+  }
+
+  this.position += 512
+}
+
+// take a header chunk, start the right kind of entry.
+Parse.prototype._startEntry = function (c) {
+  var header = new TarHeader(c)
+    , self = this
+    , entry
+    , ev
+    , EntryType
+    , onend
+    , meta = false
+
+  if (null === header.size || !header.cksumValid) {
+    var e = new Error("invalid tar file")
+    e.header = header
+    e.tar_file_offset = this.position
+    e.tar_block = this.position / 512
+    this.emit("error", e)
+  }
+
+  switch (tar.types[header.type]) {
+    case "File":
+    case "OldFile":
+    case "Link":
+    case "SymbolicLink":
+    case "CharacterDevice":
+    case "BlockDevice":
+    case "Directory":
+    case "FIFO":
+    case "ContiguousFile":
+    case "GNUDumpDir":
+      // start a file.
+      // pass in any extended headers
+      // These ones consumers are typically most interested in.
+      EntryType = Entry
+      ev = "entry"
+      break
+
+    case "GlobalExtendedHeader":
+      // extended headers that apply to the rest of the tarball
+      EntryType = ExtendedHeader
+      onend = function () {
+        self._global = self._global || {}
+        Object.keys(entry.fields).forEach(function (k) {
+          self._global[k] = entry.fields[k]
+        })
+      }
+      ev = "globalExtendedHeader"
+      meta = true
+      break
+
+    case "ExtendedHeader":
+    case "OldExtendedHeader":
+      // extended headers that apply to the next entry
+      EntryType = ExtendedHeader
+      onend = function () {
+        self._extended = entry.fields
+      }
+      ev = "extendedHeader"
+      meta = true
+      break
+
+    case "NextFileHasLongLinkpath":
+      // set linkpath=<contents> in extended header
+      EntryType = BufferEntry
+      onend = function () {
+        self._extended = self._extended || {}
+        self._extended.linkpath = entry.body
+      }
+      ev = "longLinkpath"
+      meta = true
+      break
+
+    case "NextFileHasLongPath":
+    case "OldGnuLongPath":
+      // set path=<contents> in file-extended header
+      EntryType = BufferEntry
+      onend = function () {
+        self._extended = self._extended || {}
+        self._extended.path = entry.body
+      }
+      ev = "longPath"
+      meta = true
+      break
+
+    default:
+      // all the rest we skip, but still set the _entry
+      // member, so that we can skip over their data appropriately.
+      // emit an event to say that this is an ignored entry type?
+      EntryType = Entry
+      ev = "ignoredEntry"
+      break
+  }
+
+  var global, extended
+  if (meta) {
+    global = extended = null
+  } else {
+    var global = this._global
+    var extended = this._extended
+
+    // extendedHeader only applies to one entry, so once we start
+    // an entry, it's over.
+    this._extended = null
+  }
+  entry = new EntryType(header, extended, global)
+  entry.meta = meta
+
+  // only proxy data events of normal files.
+  if (!meta) {
+    entry.on("data", function (c) {
+      me.emit("data", c)
+    })
+  }
+
+  if (onend) entry.on("end", onend)
+
+  this._entry = entry
+  var me = this
+
+  entry.on("pause", function () {
+    me.pause()
+  })
+
+  entry.on("resume", function () {
+    me.resume()
+  })
+
+  if (this.listeners("*").length) {
+    this.emit("*", ev, entry)
+  }
+
+  this.emit(ev, entry)
+
+  // Zero-byte entry.  End immediately.
+  if (entry.props.size === 0) {
+    entry.end()
+    this._entry = null
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/LICENCE b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/LICENCE
new file mode 100644
index 000000000..74489e2e2
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/LICENCE
@@ -0,0 +1,25 @@
+Copyright (c) Isaac Z. Schlueter
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/README.md b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/README.md
new file mode 100644
index 000000000..c16e9c468
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/README.md
@@ -0,0 +1,14 @@
+# block-stream
+
+A stream of blocks.
+
+Write data into it, and it'll output data in buffer blocks the size you
+specify, padding with zeroes if necessary.
+
+```javascript
+var block = new BlockStream(512)
+fs.createReadStream("some-file").pipe(block)
+block.pipe(fs.createWriteStream("block-file"))
+```
+
+When `.end()` or `.flush()` is called, it'll pad the block with zeroes.
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream-pause.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream-pause.js
new file mode 100644
index 000000000..9328844aa
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream-pause.js
@@ -0,0 +1,70 @@
+var BlockStream = require("../block-stream.js")
+
+var blockSizes = [16, 25, 1024]
+  , writeSizes = [4, 8, 15, 16, 17, 64, 100]
+  , writeCounts = [1, 10, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize, {nopad: true })
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      f.pause()
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+        f.resume()
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = writeSize * writeCount * 2
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream.js
new file mode 100644
index 000000000..1141f3a84
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/block-stream.js
@@ -0,0 +1,68 @@
+var BlockStream = require("../block-stream.js")
+
+var blockSizes = [16, 25, 1024]
+  , writeSizes = [4, 8, 15, 16, 17, 64, 100]
+  , writeCounts = [1, 10, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize, {nopad: true })
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = writeSize * writeCount * 2
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper-pause.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper-pause.js
new file mode 100644
index 000000000..93e4068ee
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper-pause.js
@@ -0,0 +1,70 @@
+var BlockStream = require("dropper")
+
+var blockSizes = [16, 25, 1024]
+  , writeSizes = [4, 8, 15, 16, 17, 64, 100]
+  , writeCounts = [1, 10, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize, {nopad: true })
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      f.pause()
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+        f.resume()
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = writeSize * writeCount * 2
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper.js
new file mode 100644
index 000000000..55fa13305
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/bench/dropper.js
@@ -0,0 +1,68 @@
+var BlockStream = require("dropper")
+
+var blockSizes = [16, 25, 1024]
+  , writeSizes = [4, 8, 15, 16, 17, 64, 100]
+  , writeCounts = [1, 10, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize, {nopad: true })
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = writeSize * writeCount * 2
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/block-stream.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/block-stream.js
new file mode 100644
index 000000000..008de035c
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/block-stream.js
@@ -0,0 +1,209 @@
+// write data to it, and it'll emit data in 512 byte blocks.
+// if you .end() or .flush(), it'll emit whatever it's got,
+// padded with nulls to 512 bytes.
+
+module.exports = BlockStream
+
+var Stream = require("stream").Stream
+  , inherits = require("inherits")
+  , assert = require("assert").ok
+  , debug = process.env.DEBUG ? console.error : function () {}
+
+function BlockStream (size, opt) {
+  this.writable = this.readable = true
+  this._opt = opt || {}
+  this._chunkSize = size || 512
+  this._offset = 0
+  this._buffer = []
+  this._bufferLength = 0
+  if (this._opt.nopad) this._zeroes = false
+  else {
+    this._zeroes = new Buffer(this._chunkSize)
+    for (var i = 0; i < this._chunkSize; i ++) {
+      this._zeroes[i] = 0
+    }
+  }
+}
+
+inherits(BlockStream, Stream)
+
+BlockStream.prototype.write = function (c) {
+  // debug("   BS write", c)
+  if (this._ended) throw new Error("BlockStream: write after end")
+  if (c && !Buffer.isBuffer(c)) c = new Buffer(c + "")
+  if (c.length) {
+    this._buffer.push(c)
+    this._bufferLength += c.length
+  }
+  // debug("pushed onto buffer", this._bufferLength)
+  if (this._bufferLength >= this._chunkSize) {
+    if (this._paused) {
+      // debug("   BS paused, return false, need drain")
+      this._needDrain = true
+      return false
+    }
+    this._emitChunk()
+  }
+  return true
+}
+
+BlockStream.prototype.pause = function () {
+  // debug("   BS pausing")
+  this._paused = true
+}
+
+BlockStream.prototype.resume = function () {
+  // debug("   BS resume")
+  this._paused = false
+  return this._emitChunk()
+}
+
+BlockStream.prototype.end = function (chunk) {
+  // debug("end", chunk)
+  if (typeof chunk === "function") cb = chunk, chunk = null
+  if (chunk) this.write(chunk)
+  this._ended = true
+  this.flush()
+}
+
+BlockStream.prototype.flush = function () {
+  this._emitChunk(true)
+}
+
+BlockStream.prototype._emitChunk = function (flush) {
+  // debug("emitChunk flush=%j emitting=%j paused=%j", flush, this._emitting, this._paused)
+
+  // emit a <chunkSize> chunk
+  if (flush && this._zeroes) {
+    // debug("    BS push zeroes", this._bufferLength)
+    // push a chunk of zeroes
+    var padBytes = (this._bufferLength % this._chunkSize)
+    if (padBytes !== 0) padBytes = this._chunkSize - padBytes
+    if (padBytes > 0) {
+      // debug("padBytes", padBytes, this._zeroes.slice(0, padBytes))
+      this._buffer.push(this._zeroes.slice(0, padBytes))
+      this._bufferLength += padBytes
+      // debug(this._buffer[this._buffer.length - 1].length, this._bufferLength)
+    }
+  }
+
+  if (this._emitting || this._paused) return
+  this._emitting = true
+
+  // debug("    BS entering loops")
+  var bufferIndex = 0
+  while (this._bufferLength >= this._chunkSize &&
+         (flush || !this._paused)) {
+    // debug("     BS data emission loop", this._bufferLength)
+
+    var out
+      , outOffset = 0
+      , outHas = this._chunkSize
+
+    while (outHas > 0 && (flush || !this._paused) ) {
+      // debug("    BS data inner emit loop", this._bufferLength)
+      var cur = this._buffer[bufferIndex]
+        , curHas = cur.length - this._offset
+      // debug("cur=", cur)
+      // debug("curHas=%j", curHas)
+      // If it's not big enough to fill the whole thing, then we'll need
+      // to copy multiple buffers into one.  However, if it is big enough,
+      // then just slice out the part we want, to save unnecessary copying.
+      // Also, need to copy if we've already done some copying, since buffers
+      // can't be joined like cons strings.
+      if (out || curHas < outHas) {
+        out = out || new Buffer(this._chunkSize)
+        cur.copy(out, outOffset,
+                 this._offset, this._offset + Math.min(curHas, outHas))
+      } else if (cur.length === outHas && this._offset === 0) {
+        // shortcut -- cur is exactly long enough, and no offset.
+        out = cur
+      } else {
+        // slice out the piece of cur that we need.
+        out = cur.slice(this._offset, this._offset + outHas)
+      }
+
+      if (curHas > outHas) {
+        // means that the current buffer couldn't be completely output
+        // update this._offset to reflect how much WAS written
+        this._offset += outHas
+        outHas = 0
+      } else {
+        // output the entire current chunk.
+        // toss it away
+        outHas -= curHas
+        outOffset += curHas
+        bufferIndex ++
+        this._offset = 0
+      }
+    }
+
+    this._bufferLength -= this._chunkSize
+    assert(out.length === this._chunkSize)
+    // debug("emitting data", out)
+    // debug("   BS emitting, paused=%j", this._paused, this._bufferLength)
+    this.emit("data", out)
+    out = null
+  }
+  // debug("    BS out of loops", this._bufferLength)
+
+  // whatever is left, it's not enough to fill up a block, or we're paused
+  this._buffer = this._buffer.slice(bufferIndex)
+  if (this._paused) {
+    // debug("    BS paused, leaving", this._bufferLength)
+    this._needsDrain = true
+    this._emitting = false
+    return
+  }
+
+  // if flushing, and not using null-padding, then need to emit the last
+  // chunk(s) sitting in the queue.  We know that it's not enough to
+  // fill up a whole block, because otherwise it would have been emitted
+  // above, but there may be some offset.
+  var l = this._buffer.length
+  if (flush && !this._zeroes && l) {
+    if (l === 1) {
+      if (this._offset) {
+        this.emit("data", this._buffer[0].slice(this._offset))
+      } else {
+        this.emit("data", this._buffer[0])
+      }
+    } else {
+      var outHas = this._bufferLength
+        , out = new Buffer(outHas)
+        , outOffset = 0
+      for (var i = 0; i < l; i ++) {
+        var cur = this._buffer[i]
+          , curHas = cur.length - this._offset
+        cur.copy(out, outOffset, this._offset)
+        this._offset = 0
+        outOffset += curHas
+        this._bufferLength -= curHas
+      }
+      this.emit("data", out)
+    }
+    // truncate
+    this._buffer.length = 0
+    this._bufferLength = 0
+    this._offset = 0
+  }
+
+  // now either drained or ended
+  // debug("either draining, or ended", this._bufferLength, this._ended)
+  // means that we've flushed out all that we can so far.
+  if (this._needDrain) {
+    // debug("emitting drain", this._bufferLength)
+    this._needDrain = false
+    this.emit("drain")
+  }
+
+  if ((this._bufferLength === 0) && this._ended && !this._endEmitted) {
+    // debug("emitting end", this._bufferLength)
+    this._endEmitted = true
+    this.emit("end")
+  }
+
+  this._emitting = false
+
+  // debug("    BS no longer emitting", flush, this._paused, this._emitting, this._bufferLength, this._chunkSize)
+}
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/package.json b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/package.json
new file mode 100644
index 000000000..b92954ea3
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/package.json
@@ -0,0 +1,38 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "name": "block-stream",
+  "description": "a stream of blocks",
+  "version": "0.0.7",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/block-stream.git"
+  },
+  "engines": {
+    "node": "0.4 || >=0.5.8"
+  },
+  "main": "block-stream.js",
+  "dependencies": {
+    "inherits": "~2.0.0"
+  },
+  "devDependencies": {
+    "tap": "0.x"
+  },
+  "scripts": {
+    "test": "tap test/"
+  },
+  "license": "BSD",
+  "readme": "# block-stream\n\nA stream of blocks.\n\nWrite data into it, and it'll output data in buffer blocks the size you\nspecify, padding with zeroes if necessary.\n\n```javascript\nvar block = new BlockStream(512)\nfs.createReadStream(\"some-file\").pipe(block)\nblock.pipe(fs.createWriteStream(\"block-file\"))\n```\n\nWhen `.end()` or `.flush()` is called, it'll pad the block with zeroes.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/block-stream/issues"
+  },
+  "homepage": "https://github.com/isaacs/block-stream",
+  "_id": "block-stream@0.0.7",
+  "_shasum": "9088ab5ae1e861f4d81b176b4a8046080703deed",
+  "_from": "block-stream@*",
+  "_resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.7.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/basic.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/basic.js
new file mode 100644
index 000000000..b4b930511
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/basic.js
@@ -0,0 +1,27 @@
+var tap = require("tap")
+  , BlockStream = require("../block-stream.js")
+
+tap.test("basic test", function (t) {
+  var b = new BlockStream(16)
+  var fs = require("fs")
+  var fstr = fs.createReadStream(__filename, {encoding: "utf8"})
+  fstr.pipe(b)
+
+  var stat
+  t.doesNotThrow(function () {
+    stat = fs.statSync(__filename)
+  }, "stat should not throw")
+
+  var totalBytes = 0
+  b.on("data", function (c) {
+    t.equal(c.length, 16, "chunks should be 16 bytes long")
+    t.type(c, Buffer, "chunks should be buffer objects")
+    totalBytes += c.length
+  })
+  b.on("end", function () {
+    var expectedBytes = stat.size + (16 - stat.size % 16)
+    t.equal(totalBytes, expectedBytes, "Should be multiple of 16")
+    t.end()
+  })
+
+})
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad-thorough.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad-thorough.js
new file mode 100644
index 000000000..7a8de88b5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad-thorough.js
@@ -0,0 +1,68 @@
+var BlockStream = require("../block-stream.js")
+
+var blockSizes = [16]//, 25]//, 1024]
+  , writeSizes = [4, 15, 16, 17, 64 ]//, 64, 100]
+  , writeCounts = [1, 10]//, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize, {nopad: true })
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = writeSize * writeCount * 2
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad.js
new file mode 100644
index 000000000..6d38429fb
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/nopad.js
@@ -0,0 +1,57 @@
+var BlockStream = require("../")
+var tap = require("tap")
+
+
+tap.test("don't pad, small writes", function (t) {
+  var f = new BlockStream(16, { nopad: true })
+  t.plan(1)
+
+  f.on("data", function (c) {
+    t.equal(c.toString(), "abc", "should get 'abc'")
+  })
+
+  f.on("end", function () { t.end() })
+
+  f.write(new Buffer("a"))
+  f.write(new Buffer("b"))
+  f.write(new Buffer("c"))
+  f.end()
+})
+
+tap.test("don't pad, exact write", function (t) {
+  var f = new BlockStream(16, { nopad: true })
+  t.plan(1)
+
+  var first = true
+  f.on("data", function (c) {
+    if (first) {
+      first = false
+      t.equal(c.toString(), "abcdefghijklmnop", "first chunk")
+    } else {
+      t.fail("should only get one")
+    }
+  })
+
+  f.on("end", function () { t.end() })
+
+  f.end(new Buffer("abcdefghijklmnop"))
+})
+
+tap.test("don't pad, big write", function (t) {
+  var f = new BlockStream(16, { nopad: true })
+  t.plan(2)
+
+  var first = true
+  f.on("data", function (c) {
+    if (first) {
+      first = false
+      t.equal(c.toString(), "abcdefghijklmnop", "first chunk")
+    } else {
+      t.equal(c.toString(), "q")
+    }
+  })
+
+  f.on("end", function () { t.end() })
+
+  f.end(new Buffer("abcdefghijklmnopq"))
+})
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/pause-resume.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/pause-resume.js
new file mode 100644
index 000000000..64d0d091d
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/pause-resume.js
@@ -0,0 +1,73 @@
+var BlockStream = require("../block-stream.js")
+
+var blockSizes = [16]
+  , writeSizes = [15, 16, 17]
+  , writeCounts = [1, 10]//, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize)
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+    var paused = false
+
+    f.on("data", function (c) {
+      timeouts ++
+      t.notOk(paused, "should not be paused when emitting data")
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      paused = true
+      f.pause()
+      process.nextTick(function () {
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+        paused = false
+        f.resume()
+        timeouts --
+      })
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = expectChunks * blockSize
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 200)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/thorough.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/thorough.js
new file mode 100644
index 000000000..1cc9ea08a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/thorough.js
@@ -0,0 +1,68 @@
+var BlockStream = require("../block-stream.js")
+
+var blockSizes = [16]//, 25]//, 1024]
+  , writeSizes = [4, 15, 16, 17, 64 ]//, 64, 100]
+  , writeCounts = [1, 10]//, 100]
+  , tap = require("tap")
+
+writeCounts.forEach(function (writeCount) {
+blockSizes.forEach(function (blockSize) {
+writeSizes.forEach(function (writeSize) {
+  tap.test("writeSize=" + writeSize +
+           " blockSize="+blockSize +
+           " writeCount="+writeCount, function (t) {
+    var f = new BlockStream(blockSize)
+
+    var actualChunks = 0
+    var actualBytes = 0
+    var timeouts = 0
+
+    f.on("data", function (c) {
+      timeouts ++
+
+      actualChunks ++
+      actualBytes += c.length
+
+      // make sure that no data gets corrupted, and basic sanity
+      var before = c.toString()
+      // simulate a slow write operation
+      setTimeout(function () {
+        timeouts --
+
+        var after = c.toString()
+        t.equal(after, before, "should not change data")
+
+        // now corrupt it, to find leaks.
+        for (var i = 0; i < c.length; i ++) {
+          c[i] = "x".charCodeAt(0)
+        }
+      }, 100)
+    })
+
+    f.on("end", function () {
+      // round up to the nearest block size
+      var expectChunks = Math.ceil(writeSize * writeCount  * 2 / blockSize)
+      var expectBytes = expectChunks * blockSize
+      t.equal(actualBytes, expectBytes,
+              "bytes=" + expectBytes + " writeSize=" + writeSize)
+      t.equal(actualChunks, expectChunks,
+              "chunks=" + expectChunks + " writeSize=" + writeSize)
+
+      // wait for all the timeout checks to finish, then end the test
+      setTimeout(function WAIT () {
+        if (timeouts > 0) return setTimeout(WAIT)
+        t.end()
+      }, 100)
+    })
+
+    for (var i = 0; i < writeCount; i ++) {
+      var a = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) a[j] = "a".charCodeAt(0)
+      var b = new Buffer(writeSize);
+      for (var j = 0; j < writeSize; j ++) b[j] = "b".charCodeAt(0)
+      f.write(a)
+      f.write(b)
+    }
+    f.end()
+  })
+}) }) })
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/two-stream.js b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/two-stream.js
new file mode 100644
index 000000000..c6db79a43
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/block-stream/test/two-stream.js
@@ -0,0 +1,59 @@
+var log = console.log,
+    assert = require( 'assert' ),
+    BlockStream = require("../block-stream.js"),
+    isize = 0, tsize = 0, fsize = 0, psize = 0, i = 0,
+    filter = null, paper = null, stack = null,
+
+// a source data buffer
+tsize = 1 * 1024; // <- 1K
+stack = new Buffer( tsize );
+for ( ; i < tsize; i++) stack[i] = "x".charCodeAt(0);
+
+isize = 1 * 1024; // <- initial packet size with 4K no bug!
+fsize = 2 * 1024 ; // <- first block-stream size 
+psize = Math.ceil( isize / 6 ); // <- second block-stream size
+
+fexpected = Math.ceil( tsize / fsize ); // <- packets expected for first 
+pexpected = Math.ceil( tsize / psize ); // <- packets expected for second
+
+
+filter = new BlockStream( fsize, { nopad : true } );
+paper = new BlockStream( psize, { nopad : true } );
+
+
+var fcounter = 0;
+filter.on( 'data', function (c) {
+  // verify that they're not null-padded
+  for (var i = 0; i < c.length; i ++) {
+    assert.strictEqual(c[i], "x".charCodeAt(0))
+  }
+    ++fcounter;
+} );
+
+var pcounter = 0;
+paper.on( 'data', function (c) {
+  // verify that they're not null-padded
+  for (var i = 0; i < c.length; i ++) {
+    assert.strictEqual(c[i], "x".charCodeAt(0))
+  }
+    ++pcounter;
+} );
+
+filter.pipe( paper );
+
+filter.on( 'end', function () {
+  log("fcounter: %s === %s", fcounter, fexpected)
+    assert.strictEqual( fcounter, fexpected );
+} );
+
+paper.on( 'end', function () {
+  log("pcounter: %s === %s", pcounter, pexpected);
+    assert.strictEqual( pcounter, pexpected );
+} );
+
+
+for ( i = 0, j = isize; j <= tsize; j += isize ) {
+    filter.write( stack.slice( j - isize, j ) );
+}
+
+filter.end();
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/LICENSE b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/LICENSE
new file mode 100644
index 000000000..dea3013d6
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/LICENSE
@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/README.md b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/README.md
new file mode 100644
index 000000000..b1c566585
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/README.md
@@ -0,0 +1,42 @@
+Browser-friendly inheritance fully compatible with standard node.js
+[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
+
+This package exports standard `inherits` from node.js `util` module in
+node environment, but also provides alternative browser-friendly
+implementation through [browser
+field](https://gist.github.com/shtylman/4339901). Alternative
+implementation is a literal copy of standard one located in standalone
+module to avoid requiring of `util`. It also has a shim for old
+browsers with no `Object.create` support.
+
+While keeping you sure you are using standard `inherits`
+implementation in node.js environment, it allows bundlers such as
+[browserify](https://github.com/substack/node-browserify) to not
+include full `util` package to your client code if all you need is
+just `inherits` function. It worth, because browser shim for `util`
+package is large and `inherits` is often the single function you need
+from it.
+
+It's recommended to use this package instead of
+`require('util').inherits` for any code that has chances to be used
+not only in node.js but in browser too.
+
+## usage
+
+```js
+var inherits = require('inherits');
+// then use exactly as the standard one
+```
+
+## note on version ~1.0
+
+Version ~1.0 had completely different motivation and is not compatible
+neither with 2.0 nor with standard node.js `inherits`.
+
+If you are using version ~1.0 and planning to switch to ~2.0, be
+careful:
+
+* new version uses `super_` instead of `super` for referencing
+  superclass
+* new version overwrites current prototype while old one preserves any
+  existing fields on it
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits.js b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits.js
new file mode 100644
index 000000000..29f5e24f5
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits.js
@@ -0,0 +1 @@
+module.exports = require('util').inherits
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits_browser.js b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits_browser.js
new file mode 100644
index 000000000..c1e78a75e
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/inherits_browser.js
@@ -0,0 +1,23 @@
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/package.json b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/package.json
new file mode 100644
index 000000000..facd5fdf1
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "inherits",
+  "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
+  "version": "2.0.1",
+  "keywords": [
+    "inheritance",
+    "class",
+    "klass",
+    "oop",
+    "object-oriented",
+    "inherits",
+    "browser",
+    "browserify"
+  ],
+  "main": "./inherits.js",
+  "browser": "./inherits_browser.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/inherits"
+  },
+  "license": "ISC",
+  "scripts": {
+    "test": "node test"
+  },
+  "readme": "Browser-friendly inheritance fully compatible with standard node.js\n[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).\n\nThis package exports standard `inherits` from node.js `util` module in\nnode environment, but also provides alternative browser-friendly\nimplementation through [browser\nfield](https://gist.github.com/shtylman/4339901). Alternative\nimplementation is a literal copy of standard one located in standalone\nmodule to avoid requiring of `util`. It also has a shim for old\nbrowsers with no `Object.create` support.\n\nWhile keeping you sure you are using standard `inherits`\nimplementation in node.js environment, it allows bundlers such as\n[browserify](https://github.com/substack/node-browserify) to not\ninclude full `util` package to your client code if all you need is\njust `inherits` function. It worth, because browser shim for `util`\npackage is large and `inherits` is often the single function you need\nfrom it.\n\nIt's recommended to use this package instead of\n`require('util').inherits` for any code that has chances to be used\nnot only in node.js but in browser too.\n\n## usage\n\n```js\nvar inherits = require('inherits');\n// then use exactly as the standard one\n```\n\n## note on version ~1.0\n\nVersion ~1.0 had completely different motivation and is not compatible\nneither with 2.0 nor with standard node.js `inherits`.\n\nIf you are using version ~1.0 and planning to switch to ~2.0, be\ncareful:\n\n* new version uses `super_` instead of `super` for referencing\n  superclass\n* new version overwrites current prototype while old one preserves any\n  existing fields on it\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/inherits/issues"
+  },
+  "homepage": "https://github.com/isaacs/inherits",
+  "_id": "inherits@2.0.1",
+  "_shasum": "b17d08d326b4423e568eff719f91b0b1cbdf69f1",
+  "_from": "inherits@2",
+  "_resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/tar/node_modules/inherits/test.js b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/test.js
new file mode 100644
index 000000000..fc53012d3
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/node_modules/inherits/test.js
@@ -0,0 +1,25 @@
+var inherits = require('./inherits.js')
+var assert = require('assert')
+
+function test(c) {
+  assert(c.constructor === Child)
+  assert(c.constructor.super_ === Parent)
+  assert(Object.getPrototypeOf(c) === Child.prototype)
+  assert(Object.getPrototypeOf(Object.getPrototypeOf(c)) === Parent.prototype)
+  assert(c instanceof Child)
+  assert(c instanceof Parent)
+}
+
+function Child() {
+  Parent.call(this)
+  test(this)
+}
+
+function Parent() {}
+
+inherits(Child, Parent)
+
+var c = new Child
+test(c)
+
+console.log('ok')
diff --git a/node_modules/tar.gz/node_modules/tar/package.json b/node_modules/tar.gz/node_modules/tar/package.json
new file mode 100644
index 000000000..7fc4dc5b7
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/package.json
@@ -0,0 +1,38 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "name": "tar",
+  "description": "tar for node",
+  "version": "0.1.20",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-tar.git"
+  },
+  "main": "tar.js",
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "dependencies": {
+    "block-stream": "*",
+    "fstream": "~0.1.28",
+    "inherits": "2"
+  },
+  "devDependencies": {
+    "tap": "0.x",
+    "rimraf": "1.x"
+  },
+  "license": "BSD",
+  "readme": "# node-tar\n\nTar for Node.js.\n\n[![NPM](https://nodei.co/npm/tar.png)](https://nodei.co/npm/tar/)\n\n## API\n\nSee `examples/` for usage examples.\n\n### var tar = require('tar')\n\nReturns an object with `.Pack`, `.Extract` and `.Parse` methods.\n\n### tar.Pack([properties])\n\nReturns a through stream. Use\n[fstream](https://npmjs.org/package/fstream) to write files into the\npack stream and you will receive tar archive data from the pack\nstream.\n\nThis only works with directories, it does not work with individual files.\n\nThe optional `properties` object are used to set properties in the tar\n'Global Extended Header'.\n\n### tar.Extract([options])\n\nReturns a through stream. Write tar data to the stream and the files\nin the tarball will be extracted onto the filesystem.\n\n`options` can be:\n\n```js\n{\n  path: '/path/to/extract/tar/into',\n  strip: 0, // how many path segments to strip from the root when extracting\n}\n```\n\n`options` also get passed to the `fstream.Writer` instance that `tar`\nuses internally.\n\n### tar.Parse()\n\nReturns a writable stream. Write tar data to it and it will emit\n`entry` events for each entry parsed from the tarball. This is used by\n`tar.Extract`.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/node-tar/issues"
+  },
+  "homepage": "https://github.com/isaacs/node-tar",
+  "_id": "tar@0.1.20",
+  "_shasum": "42940bae5b5f22c74483699126f9f3f27449cb13",
+  "_from": "tar@0.1.x",
+  "_resolved": "https://registry.npmjs.org/tar/-/tar-0.1.20.tgz"
+}
diff --git a/node_modules/tar.gz/node_modules/tar/tar.js b/node_modules/tar.gz/node_modules/tar/tar.js
new file mode 100644
index 000000000..a81298b9a
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/tar.js
@@ -0,0 +1,173 @@
+// field paths that every tar file must have.
+// header is padded to 512 bytes.
+var f = 0
+  , fields = {}
+  , path = fields.path = f++
+  , mode = fields.mode = f++
+  , uid = fields.uid = f++
+  , gid = fields.gid = f++
+  , size = fields.size = f++
+  , mtime = fields.mtime = f++
+  , cksum = fields.cksum = f++
+  , type = fields.type = f++
+  , linkpath = fields.linkpath = f++
+  , headerSize = 512
+  , blockSize = 512
+  , fieldSize = []
+
+fieldSize[path] = 100
+fieldSize[mode] = 8
+fieldSize[uid] = 8
+fieldSize[gid] = 8
+fieldSize[size] = 12
+fieldSize[mtime] = 12
+fieldSize[cksum] = 8
+fieldSize[type] = 1
+fieldSize[linkpath] = 100
+
+// "ustar\0" may introduce another bunch of headers.
+// these are optional, and will be nulled out if not present.
+
+var ustar = fields.ustar = f++
+  , ustarver = fields.ustarver = f++
+  , uname = fields.uname = f++
+  , gname = fields.gname = f++
+  , devmaj = fields.devmaj = f++
+  , devmin = fields.devmin = f++
+  , prefix = fields.prefix = f++
+  , fill = fields.fill = f++
+
+// terminate fields.
+fields[f] = null
+
+fieldSize[ustar] = 6
+fieldSize[ustarver] = 2
+fieldSize[uname] = 32
+fieldSize[gname] = 32
+fieldSize[devmaj] = 8
+fieldSize[devmin] = 8
+fieldSize[prefix] = 155
+fieldSize[fill] = 12
+
+// nb: prefix field may in fact be 130 bytes of prefix,
+// a null char, 12 bytes for atime, 12 bytes for ctime.
+//
+// To recognize this format:
+// 1. prefix[130] === ' ' or '\0'
+// 2. atime and ctime are octal numeric values
+// 3. atime and ctime have ' ' in their last byte
+
+var fieldEnds = {}
+  , fieldOffs = {}
+  , fe = 0
+for (var i = 0; i < f; i ++) {
+  fieldOffs[i] = fe
+  fieldEnds[i] = (fe += fieldSize[i])
+}
+
+// build a translation table of field paths.
+Object.keys(fields).forEach(function (f) {
+  if (fields[f] !== null) fields[fields[f]] = f
+})
+
+// different values of the 'type' field
+// paths match the values of Stats.isX() functions, where appropriate
+var types =
+  { 0: "File"
+  , "\0": "OldFile" // like 0
+  , "": "OldFile"
+  , 1: "Link"
+  , 2: "SymbolicLink"
+  , 3: "CharacterDevice"
+  , 4: "BlockDevice"
+  , 5: "Directory"
+  , 6: "FIFO"
+  , 7: "ContiguousFile" // like 0
+  // posix headers
+  , g: "GlobalExtendedHeader" // k=v for the rest of the archive
+  , x: "ExtendedHeader" // k=v for the next file
+  // vendor-specific stuff
+  , A: "SolarisACL" // skip
+  , D: "GNUDumpDir" // like 5, but with data, which should be skipped
+  , I: "Inode" // metadata only, skip
+  , K: "NextFileHasLongLinkpath" // data = link path of next file
+  , L: "NextFileHasLongPath" // data = path of next file
+  , M: "ContinuationFile" // skip
+  , N: "OldGnuLongPath" // like L
+  , S: "SparseFile" // skip
+  , V: "TapeVolumeHeader" // skip
+  , X: "OldExtendedHeader" // like x
+  }
+
+Object.keys(types).forEach(function (t) {
+  types[types[t]] = types[types[t]] || t
+})
+
+// values for the mode field
+var modes =
+  { suid: 04000 // set uid on extraction
+  , sgid: 02000 // set gid on extraction
+  , svtx: 01000 // set restricted deletion flag on dirs on extraction
+  , uread:  0400
+  , uwrite: 0200
+  , uexec:  0100
+  , gread:  040
+  , gwrite: 020
+  , gexec:  010
+  , oread:  4
+  , owrite: 2
+  , oexec:  1
+  , all: 07777
+  }
+
+var numeric =
+  { mode: true
+  , uid: true
+  , gid: true
+  , size: true
+  , mtime: true
+  , devmaj: true
+  , devmin: true
+  , cksum: true
+  , atime: true
+  , ctime: true
+  , dev: true
+  , ino: true
+  , nlink: true
+  }
+
+Object.keys(modes).forEach(function (t) {
+  modes[modes[t]] = modes[modes[t]] || t
+})
+
+var knownExtended =
+  { atime: true
+  , charset: true
+  , comment: true
+  , ctime: true
+  , gid: true
+  , gname: true
+  , linkpath: true
+  , mtime: true
+  , path: true
+  , realtime: true
+  , security: true
+  , size: true
+  , uid: true
+  , uname: true }
+
+
+exports.fields = fields
+exports.fieldSize = fieldSize
+exports.fieldOffs = fieldOffs
+exports.fieldEnds = fieldEnds
+exports.types = types
+exports.modes = modes
+exports.numeric = numeric
+exports.headerSize = headerSize
+exports.blockSize = blockSize
+exports.knownExtended = knownExtended
+
+exports.Pack = require("./lib/pack.js")
+exports.Parse = require("./lib/parse.js")
+exports.Extract = require("./lib/extract.js")
diff --git a/node_modules/tar.gz/node_modules/tar/test/00-setup-fixtures.js b/node_modules/tar.gz/node_modules/tar/test/00-setup-fixtures.js
new file mode 100644
index 000000000..1524ff7af
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/00-setup-fixtures.js
@@ -0,0 +1,53 @@
+// the fixtures have some weird stuff that is painful
+// to include directly in the repo for various reasons.
+//
+// So, unpack the fixtures with the system tar first.
+//
+// This means, of course, that it'll only work if you
+// already have a tar implementation, and some of them
+// will not properly unpack the fixtures anyway.
+//
+// But, since usually those tests will fail on Windows
+// and other systems with less capable filesystems anyway,
+// at least this way we don't cause inconveniences by
+// merely cloning the repo or installing the package.
+
+var tap = require("tap")
+, child_process = require("child_process")
+, rimraf = require("rimraf")
+, test = tap.test
+, path = require("path")
+
+test("clean fixtures", function (t) {
+  rimraf(path.resolve(__dirname, "fixtures"), function (er) {
+    t.ifError(er, "rimraf ./fixtures/")
+    t.end()
+  })
+})
+
+test("clean tmp", function (t) {
+  rimraf(path.resolve(__dirname, "tmp"), function (er) {
+    t.ifError(er, "rimraf ./tmp/")
+    t.end()
+  })
+})
+
+test("extract fixtures", function (t) {
+  var c = child_process.spawn("tar"
+                             ,["xzvf", "fixtures.tgz"]
+                             ,{ cwd: __dirname })
+
+  c.stdout.on("data", errwrite)
+  c.stderr.on("data", errwrite)
+  function errwrite (chunk) {
+    process.stderr.write(chunk)
+  }
+
+  c.on("exit", function (code) {
+    t.equal(code, 0, "extract fixtures should exit with 0")
+    if (code) {
+      t.comment("Note, all tests from here on out will fail because of this.")
+    }
+    t.end()
+  })
+})
diff --git a/node_modules/tar.gz/node_modules/tar/test/extract.js b/node_modules/tar.gz/node_modules/tar/test/extract.js
new file mode 100644
index 000000000..a68144be9
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/extract.js
@@ -0,0 +1,367 @@
+// Set the umask, so that it works the same everywhere.
+process.umask(parseInt('22', 8))
+
+var tap = require("tap")
+  , tar = require("../tar.js")
+  , fs = require("fs")
+  , path = require("path")
+  , file = path.resolve(__dirname, "fixtures/c.tar")
+  , target = path.resolve(__dirname, "tmp/extract-test")
+  , index = 0
+  , fstream = require("fstream")
+
+  , ee = 0
+  , expectEntries =
+[ { path: 'c.txt',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 513,
+    linkpath: '',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: 'cc.txt',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 513,
+    linkpath: '',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: 'r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 100,
+    linkpath: '',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: 'Ω.txt',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 2,
+    linkpath: '',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: 'Ω.txt',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 2,
+    linkpath: '',
+    nlink: 1,
+    dev: 234881026,
+    ino: 51693379 },
+  { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 200,
+    linkpath: '',
+    nlink: 1,
+    dev: 234881026,
+    ino: 51681874 },
+  { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 201,
+    linkpath: '',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: '200LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL',
+    mode: '777',
+    type: '2',
+    depth: undefined,
+    size: 0,
+    linkpath: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    nlink: undefined,
+    dev: undefined,
+    ino: undefined },
+  { path: '200-hard',
+    mode: '644',
+    type: '0',
+    depth: undefined,
+    size: 200,
+    linkpath: '',
+    nlink: 2,
+    dev: 234881026,
+    ino: 51681874 },
+  { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '644',
+    type: '1',
+    depth: undefined,
+    size: 0,
+    linkpath: path.resolve(target, '200-hard'),
+    nlink: 2,
+    dev: 234881026,
+    ino: 51681874 } ]
+
+  , ef = 0
+  , expectFiles =
+[ { path: '',
+    mode: '40755',
+    type: 'Directory',
+    depth: 0,
+    linkpath: undefined },
+  { path: '/200-hard',
+    mode: '100644',
+    type: 'File',
+    depth: 1,
+    size: 200,
+    linkpath: undefined,
+    nlink: 2 },
+  { path: '/200LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL',
+    mode: '120755',
+    type: 'SymbolicLink',
+    depth: 1,
+    size: 200,
+    linkpath: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    nlink: 1 },
+  { path: '/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '100644',
+    type: 'Link',
+    depth: 1,
+    size: 200,
+    linkpath: path.join(target, '200-hard'),
+    nlink: 2 },
+  { path: '/c.txt',
+    mode: '100644',
+    type: 'File',
+    depth: 1,
+    size: 513,
+    linkpath: undefined,
+    nlink: 1 },
+  { path: '/cc.txt',
+    mode: '100644',
+    type: 'File',
+    depth: 1,
+    size: 513,
+    linkpath: undefined,
+    nlink: 1 },
+  { path: '/r',
+    mode: '40755',
+    type: 'Directory',
+    depth: 1,
+    linkpath: undefined },
+  { path: '/r/e',
+    mode: '40755',
+    type: 'Directory',
+    depth: 2,
+    linkpath: undefined },
+  { path: '/r/e/a',
+    mode: '40755',
+    type: 'Directory',
+    depth: 3,
+    linkpath: undefined },
+  { path: '/r/e/a/l',
+    mode: '40755',
+    type: 'Directory',
+    depth: 4,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l',
+    mode: '40755',
+    type: 'Directory',
+    depth: 5,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y',
+    mode: '40755',
+    type: 'Directory',
+    depth: 6,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-',
+    mode: '40755',
+    type: 'Directory',
+    depth: 7,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d',
+    mode: '40755',
+    type: 'Directory',
+    depth: 8,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e',
+    mode: '40755',
+    type: 'Directory',
+    depth: 9,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e',
+    mode: '40755',
+    type: 'Directory',
+    depth: 10,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p',
+    mode: '40755',
+    type: 'Directory',
+    depth: 11,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-',
+    mode: '40755',
+    type: 'Directory',
+    depth: 12,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f',
+    mode: '40755',
+    type: 'Directory',
+    depth: 13,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o',
+    mode: '40755',
+    type: 'Directory',
+    depth: 14,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l',
+    mode: '40755',
+    type: 'Directory',
+    depth: 15,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d',
+    mode: '40755',
+    type: 'Directory',
+    depth: 16,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e',
+    mode: '40755',
+    type: 'Directory',
+    depth: 17,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r',
+    mode: '40755',
+    type: 'Directory',
+    depth: 18,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-',
+    mode: '40755',
+    type: 'Directory',
+    depth: 19,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p',
+    mode: '40755',
+    type: 'Directory',
+    depth: 20,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a',
+    mode: '40755',
+    type: 'Directory',
+    depth: 21,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t',
+    mode: '40755',
+    type: 'Directory',
+    depth: 22,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h',
+    mode: '40755',
+    type: 'Directory',
+    depth: 23,
+    linkpath: undefined },
+  { path: '/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+    mode: '100644',
+    type: 'File',
+    depth: 24,
+    size: 100,
+    linkpath: undefined,
+    nlink: 1 },
+  { path: '/Ω.txt',
+    mode: '100644',
+    type: 'File',
+    depth: 1,
+    size: 2,
+    linkpath: undefined,
+    nlink: 1 } ]
+
+
+
+// The extract class basically just pipes the input
+// to a Reader, and then to a fstream.DirWriter
+
+// So, this is as much a test of fstream.Reader and fstream.Writer
+// as it is of tar.Extract, but it sort of makes sense.
+
+tap.test("preclean", function (t) {
+  require("rimraf").sync(__dirname + "/tmp/extract-test")
+  t.pass("cleaned!")
+  t.end()
+})
+
+tap.test("extract test", function (t) {
+  var extract = tar.Extract(target)
+  var inp = fs.createReadStream(file)
+
+  // give it a weird buffer size to try to break in odd places
+  inp.bufferSize = 1234
+
+  inp.pipe(extract)
+
+  extract.on("end", function () {
+    t.equal(ee, expectEntries.length, "should see "+ee+" entries")
+
+    // should get no more entries after end
+    extract.removeAllListeners("entry")
+    extract.on("entry", function (e) {
+      t.fail("Should not get entries after end!")
+    })
+
+    next()
+  })
+
+  extract.on("entry", function (entry) {
+    var found =
+      { path: entry.path
+      , mode: entry.props.mode.toString(8)
+      , type: entry.props.type
+      , depth: entry.props.depth
+      , size: entry.props.size
+      , linkpath: entry.props.linkpath
+      , nlink: entry.props.nlink
+      , dev: entry.props.dev
+      , ino: entry.props.ino
+      }
+
+    var wanted = expectEntries[ee ++]
+
+    t.equivalent(found, wanted, "tar entry " + ee + " " + wanted.path)
+  })
+
+  function next () {
+    var r = fstream.Reader({ path: target
+                           , type: "Directory"
+                           // this is just to encourage consistency
+                           , sort: "alpha" })
+
+    r.on("ready", function () {
+      foundEntry(r)
+    })
+
+    r.on("end", finish)
+
+    function foundEntry (entry) {
+      var p = entry.path.substr(target.length)
+      var found =
+        { path: p
+        , mode: entry.props.mode.toString(8)
+        , type: entry.props.type
+        , depth: entry.props.depth
+        , size: entry.props.size
+        , linkpath: entry.props.linkpath
+        , nlink: entry.props.nlink
+        }
+
+      var wanted = expectFiles[ef ++]
+
+      t.has(found, wanted, "unpacked file " + ef + " " + wanted.path)
+
+      entry.on("entry", foundEntry)
+    }
+
+    function finish () {
+      t.equal(ef, expectFiles.length, "should have "+ef+" items")
+      t.end()
+    }
+  }
+})
diff --git a/node_modules/tar.gz/node_modules/tar/test/fixtures.tgz b/node_modules/tar.gz/node_modules/tar/test/fixtures.tgz
new file mode 100644
index 000000000..4501bcf22
Binary files /dev/null and b/node_modules/tar.gz/node_modules/tar/test/fixtures.tgz differ
diff --git a/node_modules/tar.gz/node_modules/tar/test/header.js b/node_modules/tar.gz/node_modules/tar/test/header.js
new file mode 100644
index 000000000..8ea6f7950
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/header.js
@@ -0,0 +1,183 @@
+var tap = require("tap")
+var TarHeader = require("../lib/header.js")
+var tar = require("../tar.js")
+var fs = require("fs")
+
+
+var headers =
+  { "a.txt file header":
+    [ "612e747874000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030303036343420003035373736312000303030303234200030303030303030303430312031313635313336303333332030313234353100203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000757374617200303069736161637300000000000000000000000000000000000000000000000000007374616666000000000000000000000000000000000000000000000000000000303030303030200030303030303020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true
+      , path: 'a.txt'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 257
+      , mtime: 1319493851
+      , cksum: 5417
+      , type: '0'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' }
+    ]
+
+  , "omega pax": // the extended header from omega tar.
+    [ "5061784865616465722fcea92e74787400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030303036343420003035373736312000303030303234200030303030303030303137302031313534333731303631312030313530353100207800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000757374617200303069736161637300000000000000000000000000000000000000000000000000007374616666000000000000000000000000000000000000000000000000000000303030303030200030303030303020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true
+      , path: 'PaxHeader/Ω.txt'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 120
+      , mtime: 1301254537
+      , cksum: 6697
+      , type: 'x'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' } ]
+
+  , "omega file header":
+    [ "cea92e7478740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030303036343420003035373736312000303030303234200030303030303030303030322031313534333731303631312030313330373200203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000757374617200303069736161637300000000000000000000000000000000000000000000000000007374616666000000000000000000000000000000000000000000000000000000303030303030200030303030303020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true
+      , path: 'Ω.txt'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 2
+      , mtime: 1301254537
+      , cksum: 5690
+      , type: '0'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' } ]
+
+  , "foo.js file header":
+    [ "666f6f2e6a730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030303036343420003035373736312000303030303234200030303030303030303030342031313534333637303734312030313236313700203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000757374617200303069736161637300000000000000000000000000000000000000000000000000007374616666000000000000000000000000000000000000000000000000000000303030303030200030303030303020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true
+      , path: 'foo.js'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 4
+      , mtime: 1301246433
+      , cksum: 5519
+      , type: '0'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' }
+    ]
+
+  , "b.txt file header":
+    [ "622e747874000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030303036343420003035373736312000303030303234200030303030303030313030302031313635313336303637372030313234363100203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000757374617200303069736161637300000000000000000000000000000000000000000000000000007374616666000000000000000000000000000000000000000000000000000000303030303030200030303030303020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true
+      , path: 'b.txt'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 512
+      , mtime: 1319494079
+      , cksum: 5425
+      , type: '0'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' }
+    ]
+
+  , "deep nested file":
+    [ "636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363636363633030303634342000303537373631200030303030323420003030303030303030313434203131363532313531353333203034333331340020300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000075737461720030306973616163730000000000000000000000000000000000000000000000000000737461666600000000000000000000000000000000000000000000000000000030303030303020003030303030302000722f652f612f6c2f6c2f792f2d2f642f652f652f702f2d2f662f6f2f6c2f642f652f722f2d2f702f612f742f680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    , { cksumValid: true,
+        path: 'r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'
+      , mode: 420
+      , uid: 24561
+      , gid: 20
+      , size: 100
+      , mtime: 1319687003
+      , cksum: 18124
+      , type: '0'
+      , linkpath: ''
+      , ustar: 'ustar\0'
+      , ustarver: '00'
+      , uname: 'isaacs'
+      , gname: 'staff'
+      , devmaj: 0
+      , devmin: 0
+      , fill: '' }
+    ]
+  }
+
+tap.test("parsing", function (t) {
+  Object.keys(headers).forEach(function (name) {
+    var h = headers[name]
+      , header = new Buffer(h[0], "hex")
+      , expect = h[1]
+      , parsed = new TarHeader(header)
+
+    // console.error(parsed)
+    t.has(parsed, expect, "parse " + name)
+  })
+  t.end()
+})
+
+tap.test("encoding", function (t) {
+  Object.keys(headers).forEach(function (name) {
+    var h = headers[name]
+      , expect = new Buffer(h[0], "hex")
+      , encoded = TarHeader.encode(h[1])
+
+    // might have slightly different bytes, since the standard
+    // isn't very strict, but should have the same semantics
+    // checkSum will be different, but cksumValid will be true
+
+    var th = new TarHeader(encoded)
+    delete h[1].block
+    delete h[1].needExtended
+    delete h[1].cksum
+    t.has(th, h[1], "fields "+name)
+  })
+  t.end()
+})
+
+// test these manually.  they're a bit rare to find in the wild
+tap.test("parseNumeric tests", function (t) {
+  var parseNumeric = TarHeader.parseNumeric
+    , numbers =
+      { "303737373737373700": 2097151
+      , "30373737373737373737373700": 8589934591
+      , "303030303036343400": 420
+      , "800000ffffffffffff": 281474976710655
+      , "ffffff000000000001": -281474976710654
+      , "ffffff000000000000": -281474976710655
+      , "800000000000200000": 2097152
+      , "8000000000001544c5": 1393861
+      , "ffffffffffff1544c5": -15383354 }
+  Object.keys(numbers).forEach(function (n) {
+    var b = new Buffer(n, "hex")
+    t.equal(parseNumeric(b), numbers[n], n + " === " + numbers[n])
+  })
+  t.end()
+})
diff --git a/node_modules/tar.gz/node_modules/tar/test/pack-no-proprietary.js b/node_modules/tar.gz/node_modules/tar/test/pack-no-proprietary.js
new file mode 100644
index 000000000..5bf0e540f
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/pack-no-proprietary.js
@@ -0,0 +1,854 @@
+// This is exactly like test/pack.js, except that it's excluding
+// any proprietary headers.
+//
+// This loses some information about the filesystem, but creates
+// tarballs that are supported by more versions of tar, especially
+// old non-spec-compliant copies of gnutar.
+
+// the symlink file is excluded from git, because it makes
+// windows freak the hell out.
+var fs = require("fs")
+  , path = require("path")
+  , symlink = path.resolve(__dirname, "fixtures/symlink")
+try { fs.unlinkSync(symlink) } catch (e) {}
+fs.symlinkSync("./hardlink-1", symlink)
+process.on("exit", function () {
+  fs.unlinkSync(symlink)
+})
+
+var tap = require("tap")
+  , tar = require("../tar.js")
+  , pkg = require("../package.json")
+  , Pack = tar.Pack
+  , fstream = require("fstream")
+  , Reader = fstream.Reader
+  , Writer = fstream.Writer
+  , input = path.resolve(__dirname, "fixtures/")
+  , target = path.resolve(__dirname, "tmp/pack.tar")
+  , uid = process.getuid ? process.getuid() : 0
+  , gid = process.getgid ? process.getgid() : 0
+
+  , entries =
+
+    // the global header and root fixtures/ dir are going to get
+    // a different date each time, so omit that bit.
+    // Also, dev/ino values differ across machines, so that's not
+    // included.
+    [ [ 'entry',
+      { path: 'fixtures/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/200cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: 'fixtures/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        uid: uid,
+        gid: gid,
+        size: 200 } ]
+
+    , [ 'entry',
+      { path: 'fixtures/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 200,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/a.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 257,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/b.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 512,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/c.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 513,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/cc.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 513,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/foo.js',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 4,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/hardlink-1',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 200,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/hardlink-2',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '1',
+        linkpath: 'fixtures/hardlink-1',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/omega.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/omega.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/star.4.html',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 54081,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/packtest/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: 'fixtures/packtest/Ω.txt',
+        uid: uid,
+        gid: gid,
+        size: 2 } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 100,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/symlink',
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '2',
+        linkpath: 'hardlink-1',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: "fixtures/Ω.txt"
+      , uid: uid
+      , gid: gid
+      , size: 2 } ]
+
+    , [ 'entry',
+      { path: 'fixtures/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+    ]
+
+
+// first, make sure that the hardlinks are actually hardlinks, or this
+// won't work.  Git has a way of replacing them with a copy.
+var hard1 = path.resolve(__dirname, "fixtures/hardlink-1")
+  , hard2 = path.resolve(__dirname, "fixtures/hardlink-2")
+  , fs = require("fs")
+
+try { fs.unlinkSync(hard2) } catch (e) {}
+fs.linkSync(hard1, hard2)
+
+tap.test("with global header", { timeout: 10000 }, function (t) {
+  runTest(t, true)
+})
+
+tap.test("without global header", { timeout: 10000 }, function (t) {
+  runTest(t, false)
+})
+
+function alphasort (a, b) {
+  return a === b ? 0
+       : a.toLowerCase() > b.toLowerCase() ? 1
+       : a.toLowerCase() < b.toLowerCase() ? -1
+       : a > b ? 1
+       : -1
+}
+
+
+function runTest (t, doGH) {
+  var reader = Reader({ path: input
+                      , filter: function () {
+                          return !this.path.match(/\.(tar|hex)$/)
+                        }
+                      , sort: alphasort
+                      })
+
+  var props = doGH ? pkg : {}
+  props.noProprietary = true
+  var pack = Pack(props)
+  var writer = Writer(target)
+
+  // global header should be skipped regardless, since it has no content.
+  var entry = 0
+
+  t.ok(reader, "reader ok")
+  t.ok(pack, "pack ok")
+  t.ok(writer, "writer ok")
+
+  pack.pipe(writer)
+
+  var parse = tar.Parse()
+  t.ok(parse, "parser should be ok")
+
+  pack.on("data", function (c) {
+    // console.error("PACK DATA")
+    if (c.length !== 512) {
+      // this one is too noisy, only assert if it'll be relevant
+      t.equal(c.length, 512, "parser should emit data in 512byte blocks")
+    }
+    parse.write(c)
+  })
+
+  pack.on("end", function () {
+    // console.error("PACK END")
+    t.pass("parser ends")
+    parse.end()
+  })
+
+  pack.on("error", function (er) {
+    t.fail("pack error", er)
+  })
+
+  parse.on("error", function (er) {
+    t.fail("parse error", er)
+  })
+
+  writer.on("error", function (er) {
+    t.fail("writer error", er)
+  })
+
+  reader.on("error", function (er) {
+    t.fail("reader error", er)
+  })
+
+  parse.on("*", function (ev, e) {
+    var wanted = entries[entry++]
+    if (!wanted) {
+      t.fail("unexpected event: "+ev)
+      return
+    }
+    t.equal(ev, wanted[0], "event type should be "+wanted[0])
+
+    if (ev !== wanted[0] || e.path !== wanted[1].path) {
+      console.error(wanted)
+      console.error([ev, e.props])
+      e.on("end", function () {
+        console.error(e.fields)
+        throw "break"
+      })
+    }
+
+    t.has(e.props, wanted[1], "properties "+wanted[1].path)
+    if (wanted[2]) {
+      e.on("end", function () {
+        if (!e.fields) {
+          t.ok(e.fields, "should get fields")
+        } else {
+          t.has(e.fields, wanted[2], "should get expected fields")
+        }
+      })
+    }
+  })
+
+  reader.pipe(pack)
+
+  writer.on("close", function () {
+    t.equal(entry, entries.length, "should get all expected entries")
+    t.pass("it finished")
+    t.end()
+  })
+
+}
diff --git a/node_modules/tar.gz/node_modules/tar/test/pack.js b/node_modules/tar.gz/node_modules/tar/test/pack.js
new file mode 100644
index 000000000..0f5099458
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/pack.js
@@ -0,0 +1,897 @@
+
+// the symlink file is excluded from git, because it makes
+// windows freak the hell out.
+var fs = require("fs")
+  , path = require("path")
+  , symlink = path.resolve(__dirname, "fixtures/symlink")
+try { fs.unlinkSync(symlink) } catch (e) {}
+fs.symlinkSync("./hardlink-1", symlink)
+process.on("exit", function () {
+  fs.unlinkSync(symlink)
+})
+
+
+var tap = require("tap")
+  , tar = require("../tar.js")
+  , pkg = require("../package.json")
+  , Pack = tar.Pack
+  , fstream = require("fstream")
+  , Reader = fstream.Reader
+  , Writer = fstream.Writer
+  , input = path.resolve(__dirname, "fixtures/")
+  , target = path.resolve(__dirname, "tmp/pack.tar")
+  , uid = process.getuid ? process.getuid() : 0
+  , gid = process.getgid ? process.getgid() : 0
+
+  , entries =
+
+    // the global header and root fixtures/ dir are going to get
+    // a different date each time, so omit that bit.
+    // Also, dev/ino values differ across machines, so that's not
+    // included.
+    [ [ 'globalExtendedHeader',
+      { path: 'PaxHeader/',
+        mode: 438,
+        uid: 0,
+        gid: 0,
+        type: 'g',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { "NODETAR.author": pkg.author,
+        "NODETAR.name": pkg.name,
+        "NODETAR.description": pkg.description,
+        "NODETAR.version": pkg.version,
+        "NODETAR.repository.type": pkg.repository.type,
+        "NODETAR.repository.url": pkg.repository.url,
+        "NODETAR.main": pkg.main,
+        "NODETAR.scripts.test": pkg.scripts.test } ]
+
+    , [ 'entry',
+      { path: 'fixtures/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/200cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: 'fixtures/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        'NODETAR.depth': '1',
+        'NODETAR.type': 'File',
+        nlink: 1,
+        uid: uid,
+        gid: gid,
+        size: 200,
+        'NODETAR.blksize': '4096',
+        'NODETAR.blocks': '8' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 200,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '',
+        'NODETAR.depth': '1',
+        'NODETAR.type': 'File',
+        nlink: 1,
+        'NODETAR.blksize': '4096',
+        'NODETAR.blocks': '8' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/a.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 257,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/b.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 512,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/c.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 513,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/cc.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 513,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/foo.js',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 4,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/hardlink-1',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 200,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/hardlink-2',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '1',
+        linkpath: 'fixtures/hardlink-1',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/omega.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/omega.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/star.4.html',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 54081,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/packtest/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: 'fixtures/packtest/Ω.txt',
+        'NODETAR.depth': '2',
+        'NODETAR.type': 'File',
+        nlink: 1,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        'NODETAR.blksize': '4096',
+        'NODETAR.blocks': '8' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/packtest/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '',
+        'NODETAR.depth': '2',
+        'NODETAR.type': 'File',
+        nlink: 1,
+        'NODETAR.blksize': '4096',
+        'NODETAR.blocks': '8' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/',
+        mode: 493,
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '5',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 100,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'entry',
+      { path: 'fixtures/symlink',
+        uid: uid,
+        gid: gid,
+        size: 0,
+        type: '2',
+        linkpath: 'hardlink-1',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' } ]
+
+    , [ 'extendedHeader',
+      { path: 'PaxHeader/fixtures/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        type: 'x',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '' },
+      { path: "fixtures/Ω.txt"
+      , "NODETAR.depth": "1"
+      , "NODETAR.type": "File"
+      , nlink: 1
+      , uid: uid
+      , gid: gid
+      , size: 2
+      , "NODETAR.blksize": "4096"
+      , "NODETAR.blocks": "8" } ]
+
+    , [ 'entry',
+      { path: 'fixtures/Ω.txt',
+        mode: 420,
+        uid: uid,
+        gid: gid,
+        size: 2,
+        type: '0',
+        linkpath: '',
+        ustar: 'ustar\u0000',
+        ustarver: '00',
+        uname: '',
+        gname: '',
+        devmaj: 0,
+        devmin: 0,
+        fill: '',
+        'NODETAR.depth': '1',
+        'NODETAR.type': 'File',
+        nlink: 1,
+        'NODETAR.blksize': '4096',
+        'NODETAR.blocks': '8' } ]
+    ]
+
+
+// first, make sure that the hardlinks are actually hardlinks, or this
+// won't work.  Git has a way of replacing them with a copy.
+var hard1 = path.resolve(__dirname, "fixtures/hardlink-1")
+  , hard2 = path.resolve(__dirname, "fixtures/hardlink-2")
+  , fs = require("fs")
+
+try { fs.unlinkSync(hard2) } catch (e) {}
+fs.linkSync(hard1, hard2)
+
+tap.test("with global header", { timeout: 10000 }, function (t) {
+  runTest(t, true)
+})
+
+tap.test("without global header", { timeout: 10000 }, function (t) {
+  runTest(t, false)
+})
+
+function alphasort (a, b) {
+  return a === b ? 0
+       : a.toLowerCase() > b.toLowerCase() ? 1
+       : a.toLowerCase() < b.toLowerCase() ? -1
+       : a > b ? 1
+       : -1
+}
+
+
+function runTest (t, doGH) {
+  var reader = Reader({ path: input
+                      , filter: function () {
+                          return !this.path.match(/\.(tar|hex)$/)
+                        }
+                      , sort: alphasort
+                      })
+
+  var pack = Pack(doGH ? pkg : null)
+  var writer = Writer(target)
+
+  // skip the global header if we're not doing that.
+  var entry = doGH ? 0 : 1
+
+  t.ok(reader, "reader ok")
+  t.ok(pack, "pack ok")
+  t.ok(writer, "writer ok")
+
+  pack.pipe(writer)
+
+  var parse = tar.Parse()
+  t.ok(parse, "parser should be ok")
+
+  pack.on("data", function (c) {
+    // console.error("PACK DATA")
+    if (c.length !== 512) {
+      // this one is too noisy, only assert if it'll be relevant
+      t.equal(c.length, 512, "parser should emit data in 512byte blocks")
+    }
+    parse.write(c)
+  })
+
+  pack.on("end", function () {
+    // console.error("PACK END")
+    t.pass("parser ends")
+    parse.end()
+  })
+
+  pack.on("error", function (er) {
+    t.fail("pack error", er)
+  })
+
+  parse.on("error", function (er) {
+    t.fail("parse error", er)
+  })
+
+  writer.on("error", function (er) {
+    t.fail("writer error", er)
+  })
+
+  reader.on("error", function (er) {
+    t.fail("reader error", er)
+  })
+
+  parse.on("*", function (ev, e) {
+    var wanted = entries[entry++]
+    if (!wanted) {
+      t.fail("unexpected event: "+ev)
+      return
+    }
+    t.equal(ev, wanted[0], "event type should be "+wanted[0])
+
+    // if (ev !== wanted[0] || e.path !== wanted[1].path) {
+    //   console.error(wanted)
+    //   console.error([ev, e.props])
+    //   throw "break"
+    // }
+
+    t.has(e.props, wanted[1], "properties "+wanted[1].path)
+    if (wanted[2]) {
+      e.on("end", function () {
+        if (!e.fields) {
+          t.ok(e.fields, "should get fields")
+        } else {
+          t.has(e.fields, wanted[2], "should get expected fields")
+        }
+      })
+    }
+  })
+
+  reader.pipe(pack)
+
+  writer.on("close", function () {
+    t.equal(entry, entries.length, "should get all expected entries")
+    t.pass("it finished")
+    t.end()
+  })
+
+}
diff --git a/node_modules/tar.gz/node_modules/tar/test/parse.js b/node_modules/tar.gz/node_modules/tar/test/parse.js
new file mode 100644
index 000000000..f765a5012
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/parse.js
@@ -0,0 +1,359 @@
+var tap = require("tap")
+  , tar = require("../tar.js")
+  , fs = require("fs")
+  , path = require("path")
+  , file = path.resolve(__dirname, "fixtures/c.tar")
+  , index = 0
+
+  , expect =
+[ [ 'entry',
+    { path: 'c.txt',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 513,
+      mtime: new Date('Wed, 26 Oct 2011 01:10:58 GMT'),
+      cksum: 5422,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    undefined ],
+  [ 'entry',
+    { path: 'cc.txt',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 513,
+      mtime: new Date('Wed, 26 Oct 2011 01:11:02 GMT'),
+      cksum: 5525,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    undefined ],
+  [ 'entry',
+    { path: 'r/e/a/l/l/y/-/d/e/e/p/-/f/o/l/d/e/r/-/p/a/t/h/cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 100,
+      mtime: new Date('Thu, 27 Oct 2011 03:43:23 GMT'),
+      cksum: 18124,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    undefined ],
+  [ 'entry',
+    { path: 'Ω.txt',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 2,
+      mtime: new Date('Thu, 27 Oct 2011 17:51:49 GMT'),
+      cksum: 5695,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    undefined ],
+  [ 'extendedHeader',
+    { path: 'PaxHeader/Ω.txt',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 120,
+      mtime: new Date('Thu, 27 Oct 2011 17:51:49 GMT'),
+      cksum: 6702,
+      type: 'x',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    { path: 'Ω.txt',
+      ctime: 1319737909,
+      atime: 1319739061,
+      dev: 234881026,
+      ino: 51693379,
+      nlink: 1 } ],
+  [ 'entry',
+    { path: 'Ω.txt',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 2,
+      mtime: new Date('Thu, 27 Oct 2011 17:51:49 GMT'),
+      cksum: 5695,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '',
+      ctime: new Date('Thu, 27 Oct 2011 17:51:49 GMT'),
+      atime: new Date('Thu, 27 Oct 2011 18:11:01 GMT'),
+      dev: 234881026,
+      ino: 51693379,
+      nlink: 1 },
+    undefined ],
+  [ 'extendedHeader',
+    { path: 'PaxHeader/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 353,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 14488,
+      type: 'x',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      ctime: 1319686868,
+      atime: 1319741254,
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 1 } ],
+  [ 'entry',
+    { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 200,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 14570,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '',
+      ctime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      atime: new Date('Thu, 27 Oct 2011 18:47:34 GMT'),
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 1 },
+    undefined ],
+  [ 'longPath',
+    { path: '././@LongLink',
+      mode: 0,
+      uid: 0,
+      gid: 0,
+      size: 201,
+      mtime: new Date('Thu, 01 Jan 1970 00:00:00 GMT'),
+      cksum: 4976,
+      type: 'L',
+      linkpath: '',
+      ustar: false },
+    '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc' ],
+  [ 'entry',
+    { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 1000,
+      gid: 1000,
+      size: 201,
+      mtime: new Date('Thu, 27 Oct 2011 22:21:50 GMT'),
+      cksum: 14086,
+      type: '0',
+      linkpath: '',
+      ustar: false },
+    undefined ],
+  [ 'longLinkpath',
+    { path: '././@LongLink',
+      mode: 0,
+      uid: 0,
+      gid: 0,
+      size: 201,
+      mtime: new Date('Thu, 01 Jan 1970 00:00:00 GMT'),
+      cksum: 4975,
+      type: 'K',
+      linkpath: '',
+      ustar: false },
+    '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc' ],
+  [ 'longPath',
+    { path: '././@LongLink',
+      mode: 0,
+      uid: 0,
+      gid: 0,
+      size: 201,
+      mtime: new Date('Thu, 01 Jan 1970 00:00:00 GMT'),
+      cksum: 4976,
+      type: 'L',
+      linkpath: '',
+      ustar: false },
+    '200LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL' ],
+  [ 'entry',
+    { path: '200LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL',
+      mode: 511,
+      uid: 1000,
+      gid: 1000,
+      size: 0,
+      mtime: new Date('Fri, 28 Oct 2011 23:05:17 GMT'),
+      cksum: 21603,
+      type: '2',
+      linkpath: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      ustar: false },
+    undefined ],
+  [ 'extendedHeader',
+    { path: 'PaxHeader/200-hard',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 143,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 6533,
+      type: 'x',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    { ctime: 1320617144,
+      atime: 1320617232,
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 2 } ],
+  [ 'entry',
+    { path: '200-hard',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 200,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 5526,
+      type: '0',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '',
+      ctime: new Date('Sun, 06 Nov 2011 22:05:44 GMT'),
+      atime: new Date('Sun, 06 Nov 2011 22:07:12 GMT'),
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 2 },
+    undefined ],
+  [ 'extendedHeader',
+    { path: 'PaxHeader/200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 353,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 14488,
+      type: 'x',
+      linkpath: '',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '' },
+    { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      ctime: 1320617144,
+      atime: 1320617406,
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 2 } ],
+  [ 'entry',
+    { path: '200ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+      mode: 420,
+      uid: 24561,
+      gid: 20,
+      size: 0,
+      mtime: new Date('Thu, 27 Oct 2011 03:41:08 GMT'),
+      cksum: 15173,
+      type: '1',
+      linkpath: '200-hard',
+      ustar: 'ustar\0',
+      ustarver: '00',
+      uname: 'isaacs',
+      gname: 'staff',
+      devmaj: 0,
+      devmin: 0,
+      fill: '',
+      ctime: new Date('Sun, 06 Nov 2011 22:05:44 GMT'),
+      atime: new Date('Sun, 06 Nov 2011 22:10:06 GMT'),
+      'LIBARCHIVE.creationtime': '1319686852',
+      dev: 234881026,
+      ino: 51681874,
+      nlink: 2 },
+    undefined ] ]
+
+
+tap.test("parser test", function (t) {
+  var parser = tar.Parse()
+
+  parser.on("end", function () {
+    t.equal(index, expect.length, "saw all expected events")
+    t.end()
+  })
+
+  fs.createReadStream(file)
+    .pipe(parser)
+    .on("*", function (ev, entry) {
+      var wanted = expect[index]
+      if (!wanted) {
+        return t.fail("Unexpected event: " + ev)
+      }
+      var result = [ev, entry.props]
+      entry.on("end", function () {
+        result.push(entry.fields || entry.body)
+
+        t.equal(ev, wanted[0], index + " event type")
+        t.equivalent(entry.props, wanted[1], wanted[1].path + " entry properties")
+        if (wanted[2]) {
+          t.equivalent(result[2], wanted[2], "metadata values")
+        }
+        index ++
+      })
+    })
+})
diff --git a/node_modules/tar.gz/node_modules/tar/test/zz-cleanup.js b/node_modules/tar.gz/node_modules/tar/test/zz-cleanup.js
new file mode 100644
index 000000000..a00ff7faa
--- /dev/null
+++ b/node_modules/tar.gz/node_modules/tar/test/zz-cleanup.js
@@ -0,0 +1,20 @@
+// clean up the fixtures
+
+var tap = require("tap")
+, rimraf = require("rimraf")
+, test = tap.test
+, path = require("path")
+
+test("clean fixtures", function (t) {
+  rimraf(path.resolve(__dirname, "fixtures"), function (er) {
+    t.ifError(er, "rimraf ./fixtures/")
+    t.end()
+  })
+})
+
+test("clean tmp", function (t) {
+  rimraf(path.resolve(__dirname, "tmp"), function (er) {
+    t.ifError(er, "rimraf ./tmp/")
+    t.end()
+  })
+})
diff --git a/node_modules/tar.gz/package.json b/node_modules/tar.gz/package.json
new file mode 100644
index 000000000..acdbcc1f9
--- /dev/null
+++ b/node_modules/tar.gz/package.json
@@ -0,0 +1,64 @@
+{
+    "name": "tar.gz",
+    "version": "0.1.1",
+    "description": "Native gzip compression and decompression utility for Node.js.",
+    "keywords": [
+        "compression",
+        "decompression",
+        "compress",
+        "decompress",
+        "tar",
+        "tape archive",
+        "tape",
+        "archive",
+        "gzip",
+        "gz"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "http://github.com/cranic/node-tar.gz.git"
+    },
+    "author": {
+        "name": "Cranic Tecnologia",
+        "email": "contato@cranic.com.br"
+    },
+    "contributors": [
+        {
+            "name": "Alan Hoffmeister",
+            "email": "alan@cranic.com.br"
+        }
+    ],
+    "dependencies": {
+        "fstream": "0.1.x",
+        "tar": "0.1.x",
+        "commander": "1.1.x"
+    },
+    "devDependencies": {
+        "coffee-script" : "1.4.x",
+        "walk" : "2.2.x",
+        "wrench" : "1.4.x",
+        "vows" : "0.7.x"
+    },
+    "main": "./lib/targz",
+    "engines": {
+        "node": ">=0.6.0"
+    },
+    "maint.me" : true,
+    "scripts": { 
+        "prepublish": "cake build"
+    },
+    "bin" : {
+        "targz": "./bin/targz"
+    },
+    "bugs": {
+        "url": "http://github.com/cranic/node-tar.gz/issues"
+    },
+    "license" : "MIT <http://opensource.org/licenses/MIT>",
+    "readme" : "# **node-tar.gz**\nNative gzip compression and decompression utility for Node.js.\n\n### **Installation**\n\nFor simple installation:\n\n    npm install tar.gz\n\nIf you want to use the `targz` command line:\n\n    npm intall -g tar.gz\n\n### **Usage**\n\nAt the moment this package can only compress a folder and everything that\nis inside it. To compress something is easy:\n\n    var targz = require('tar.gz');\n    var compress = new targz().compress('/path/to/compress', '/path/to/store.tar.gz', function(err){\n        if(err)\n            console.log(err);\n\n        console.log('The compression has ended!');\n    });\n\nWith the same easy you can extract a gziped file:\n\n    var targz = require('tar.gz');\n    var compress = new targz().extract('/path/to/stored.tar.gz', '/path/to/extract', function(err){\n        if(err)\n            console.log(err);\n\n        console.log('The extraction has ended!');\n    });\n\nYou can pass some configuration parameters to the constructor before compress:\n\n    var targz = require('tar.gz');\n\n    var level = 6 //the compression level from 0-9, default: 6\n    var memLevel = 6 //the memory allocation level from 1-9, default: 6\n    var proprietary = true //to include or not proprietary headers, default: true\n\n    var compress = new targz(level, memLevel, proprietary).compress(...)\n\n### **Command line**\n\n    $ targz -h\n\n      Usage: targz [options]\n\n      Options:\n\n        -h, --help           output usage information\n        -V, --version        output the version number\n        -c, --compress       Compress folder to archive\n        -x, --extract        Extract archive to folder\n        -l, --level [n]      Compression level from 0-9. Default 6.\n        -m, --memory [n]     Memory allocation level from 1-9. Default 6.\n        -n, --noproprietary  Remove proprietary headers.\n\n      Examples:\n\n        Default compression\n        $ targz -c /folder/to/compres /path/to/archive.tar.gz\n\n        Extracting some archive\n        $ targz -x /path/to/archive.tar.gz /destination/folder\n\n        Maximum compression\n        $ targz -l 9 -m 9 -c /folder/to/compres /path/to/archive.tar.gz\n\n\n### **TODO**\n\n * Vows.js tests\n * Single file compression\n * Add more todos...\n\n\n### **License (MIT)**\n\nCopyright (C) 2012 Cranic Tecnologia e Informática LTDA\n\nPermission is hereby granted, free of charge, to any person obtaining \na copy of this software and associated documentation files \n(the \"Software\"), to deal in the Software without restriction, \nincluding without limitation the rights to use, copy, modify, merge, \npublish, distribute, sublicense, and/or sell copies of the Software, \nand to permit persons to whom the Software is furnished to do so, \nsubject to the following conditions:\n\nThe above copyright notice and this permission notice shall be \nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS \nOR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF \nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. \nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY \nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, \nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE \nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+    "readmeFilename" : "README.md",
+    "homepage" : "https://github.com/cranic/node-tar.gz",
+    "_id" : "tar.gz@0.1.1",
+    "_shasum" : "e914ce23b2fdc627575fbdb3485a5b228ed59947",
+    "_from" : "tar.gz@~0.1.1",
+    "_resolved" : "https://registry.npmjs.org/tar.gz/-/tar.gz-0.1.1.tgz"
+}
diff --git a/node_modules/tar.gz/src/targz.coffee b/node_modules/tar.gz/src/targz.coffee
new file mode 100644
index 000000000..decd308c0
--- /dev/null
+++ b/node_modules/tar.gz/src/targz.coffee
@@ -0,0 +1,80 @@
+# node-tar.gz main class
+#
+# @version 0.0.1
+# @author Alan Hoffmeister <alan@cranic.com.br>
+# @date 2012-12-06 10:22 AM GTM - 3:00
+
+fstream = require 'fstream'
+tar = require 'tar'
+zlib = require 'zlib'
+fs = require 'fs'
+
+class TarGz
+
+    # The construcor, you can change the compresion levels
+    #
+    # @public
+    # @param level Integer The compression level from 0-9. Default 6.
+    # @param memLevel Integer The memory allocation level from 1-9. Default 6.
+    # @return Object the main class methods.
+    constructor : (@level = 6, @memLevel = 6, @proprietary = true) ->
+        @
+
+    # The compress method
+    #
+    # @public
+    # @param source String The path from a folder to be compressed
+    # @param destination String The path for the file to be extracted. Its
+    # a good idea to end with .tar.gz
+    # @param callback Function A function that will be called when the compression
+    # ended and will have the error object
+    # @return Object the main class methods.
+    compress : (source, destination, callback) ->
+        self = @
+
+        fs.stat source, (err, stat) ->
+            type = 'Directory' #if stat.isDirectory()
+            #type = 'File' if stat.isFile()
+            # Single file support need to be implemented.
+
+            process.nextTick ->
+                gzip = zlib.createGzip
+                    level : self.level
+                    memLevel : self.memLevel
+
+                #if type == 'File'
+                #    reader = fs.createReadStream(source)
+
+                if type == 'Directory'
+                    reader =  fstream.Reader
+                        path : source
+                        type : type
+
+                props = noProprietary : false if self.proprietary == true
+                props = noProprietary : true if self.proprietary == false
+
+                reader.pipe(tar.Pack(props)).pipe(gzip).pipe fstream.Writer(destination).on 'close', ->
+                    callback null if typeof callback == 'function'
+        @
+
+    # The extraction method
+    #
+    # @public
+    # @param source String The path from an .tar.gz to be extracted
+    # @param destination String The path from a folder where the itens will be extracted
+    # @param callback Function A function that will be called when the extraction
+    # ended and will have the error object
+    # @return Object the main class methods.
+    extract : (source, destination, callback) ->
+        self = @
+
+        process.nextTick ->
+            fstream.Reader(
+                path : source
+                type : 'File'
+            ).pipe(zlib.createGunzip()).pipe(tar.Extract({path: destination})).on 'end', ->
+                callback null if typeof callback == 'function'  
+
+        @
+
+module.exports = TarGz
\ No newline at end of file
diff --git a/node_modules/tar.gz/test/compress/test.txt b/node_modules/tar.gz/test/compress/test.txt
new file mode 100644
index 000000000..e203bb98e
--- /dev/null
+++ b/node_modules/tar.gz/test/compress/test.txt
@@ -0,0 +1,47 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras non massa et augue
+molestie lacinia. Ut purus sem, bibendum at blandit vitae, bibendum sed turpis.
+Fusce eros libero, fringilla non dapibus in, cursus elementum ipsum. Fusce
+ultrices magna ac quam iaculis faucibus. Quisque bibendum posuere mi sed
+dignissim. Etiam dictum eros et turpis lobortis nec accumsan eros laoreet. Proin
+arcu turpis, faucibus eu posuere pulvinar, cursus vel odio. Lorem ipsum dolor
+sit amet, consectetur adipiscing elit.
+
+Donec auctor blandit nisl, sit amet
+cursus ipsum commodo ut. Curabitur egestas odio at dui luctus non aliquam ante
+luctus. Nam nisl enim, convallis eget consectetur ut, gravida in dolor. Morbi eu
+est at nibh sodales rutrum et at elit. Aenean augue velit, sodales sit amet
+vulputate eu, ultrices quis sapien. Ut aliquam eros ac diam laoreet auctor.
+Integer malesuada, massa vitae tempus dictum, dolor sem lacinia lacus, a
+sollicitudin velit tellus in lacus. Nullam nec risus vitae odio blandit gravida.
+Sed eleifend posuere dictum.
+
+Ut ac tellus enim, suscipit mollis libero.
+Nullam eleifend imperdiet erat, sit amet lobortis nisl facilisis eget. Donec at
+mauris eget turpis facilisis feugiat nec rhoncus quam. Donec nec nisi elit.
+Pellentesque sodales tristique aliquet. In tincidunt, eros in sollicitudin
+varius, enim lectus viverra mauris, vel accumsan dolor lectus id dolor. Donec
+non tortor sed magna molestie rhoncus. Vestibulum rhoncus, velit sed cursus
+imperdiet, tortor justo suscipit nisl, id mattis augue tellus ut libero.
+Phasellus lacinia tempor accumsan. Duis euismod porta urna a sagittis.
+Pellentesque ullamcorper vehicula metus, non lacinia ipsum congue a. Praesent
+laoreet enim ut neque blandit luctus. Praesent eu nulla ut ipsum aliquet
+sollicitudin vel sit amet nisi. Nunc nec ornare dolor. Quisque id nisl vel eros
+suscipit imperdiet. Aenean pellentesque porttitor egestas.
+
+Vivamus ut dolor a
+eros porta iaculis quis a tortor. In hendrerit rutrum consectetur. Morbi
+molestie ipsum vel augue pellentesque quis pulvinar purus tincidunt. Vestibulum
+pharetra dolor vitae felis ullamcorper dignissim. Duis vel nisl eu dui congue
+molestie vel quis nulla. Duis tempus sapien in velit posuere egestas. Vestibulum
+vestibulum rutrum nibh, venenatis consectetur arcu pulvinar ut.
+
+Sed sed massa
+quis lacus elementum porta. Etiam aliquet lacus sit amet metus eleifend congue.
+Suspendisse bibendum gravida dolor sed semper. Nullam luctus nisl in lorem
+pretium rutrum. Integer auctor, enim sit amet cursus aliquet, massa mauris
+pharetra tortor, id volutpat velit dui et nisl. Nullam eget euismod ante. Ut
+malesuada, ligula nec pellentesque adipiscing, massa mi ultricies orci, eu
+consectetur nunc elit vel tortor. Aenean id nulla nulla. Cum sociis natoque
+penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vivamus nunc
+risus, feugiat sed venenatis a, porttitor vel lacus. In odio ligula, scelerisque
+vel iaculis ac, aliquet ac risus.
\ No newline at end of file
diff --git a/node_modules/tar.gz/test/extract/placeholder b/node_modules/tar.gz/test/extract/placeholder
new file mode 100644
index 000000000..e69de29bb
diff --git a/node_modules/transition-complete/.npmignore b/node_modules/transition-complete/.npmignore
new file mode 100755
index 000000000..69fd427f4
--- /dev/null
+++ b/node_modules/transition-complete/.npmignore
@@ -0,0 +1,43 @@
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Node Stuff #
+##############
+node_modules/
+
+
diff --git a/node_modules/transition-complete/.travis.yml b/node_modules/transition-complete/.travis.yml
new file mode 100644
index 000000000..eb8ff8b24
--- /dev/null
+++ b/node_modules/transition-complete/.travis.yml
@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.8"
+before_script: 
+  - npm install grunt-cli -g
diff --git a/node_modules/transition-complete/Gruntfile.js b/node_modules/transition-complete/Gruntfile.js
new file mode 100755
index 000000000..f51689e1b
--- /dev/null
+++ b/node_modules/transition-complete/Gruntfile.js
@@ -0,0 +1,68 @@
+module.exports = function(grunt) {
+    grunt.initConfig({
+        pkg: grunt.file.readJSON('package.json'),
+        browserify: {
+            dist: {
+                files: {
+                    'dist/lib.js': ['transition-complete.js']
+                },
+                options: {
+                    //standalone: '',
+                    transform: ['grunt-less-browserify']
+                }
+            },
+            test: {
+                files: {
+                    'test/build.js': ['test/test.js']
+                },
+                options: {
+                    debug:     true
+                }
+            }
+        },
+        watch: {
+            tasks: [ 'browserify:dist' ]
+        },
+        jshint: {
+            options: {
+                curly:  true,
+                eqeqeq: true,
+                eqnull: true,
+                browser: true
+            },
+            uses_defaults: ['transition-complete.js']
+        },
+        uglify: {
+            dist: {
+                files: {
+                    'dist/lib.min.js': ['dist/lib.js']
+                },
+                options: {
+                    sourceMap: true
+                }
+            }
+        },
+        qunit: {
+            files: ['test/index.html']
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-browserify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-contrib-qunit');
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+    grunt.loadNpmTasks('grunt-contrib-jshint');
+
+    grunt.registerTask('test', [
+        'browserify:test',
+        'qunit',
+        'jshint'
+    ]);
+
+    grunt.registerTask('build', [
+        'test',
+        'browserify:dist',
+        'uglify'
+    ]);
+};
+
diff --git a/node_modules/transition-complete/README.md b/node_modules/transition-complete/README.md
new file mode 100755
index 000000000..698fa9fd8
--- /dev/null
+++ b/node_modules/transition-complete/README.md
@@ -0,0 +1,24 @@
+Transition Complete
+===================
+
+Fires a callback when the current CSS transition finishes.
+
+Usage
+-----
+
+Installation `npm install transition-complete`
+
+```javascript
+transitionComplete(function() {
+	//Something
+});
+```
+
+Development
+-----------
+
+To Build: `grunt build`
+
+To Develop: `grunt watch`
+
+To Test: `npm test`
diff --git a/node_modules/transition-complete/package.json b/node_modules/transition-complete/package.json
new file mode 100755
index 000000000..fe16c3a16
--- /dev/null
+++ b/node_modules/transition-complete/package.json
@@ -0,0 +1,39 @@
+{
+  "name": "transition-complete",
+  "description": "Callback when current CSS transition is complete.",
+  "version": "0.0.2",
+  "author": {
+    "name": "Brian Peacock"
+  },
+  "main": "transition-complete.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bpeacock/transition-complete.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "grunt": "~0.4.2",
+    "grunt-contrib-watch": "0.5.x",
+    "grunt-browserify": "1.3.x",
+    "grunt-contrib-jshint": "0.8.x",
+    "grunt-contrib-uglify": "0.3.x",
+    "grunt-contrib-qunit": "~0.4.0",
+    "qunitjs": "~1.14.0",
+    "sinon": "~1.8.2"
+  },
+  "license": "MIT",
+  "keywords": [],
+  "scripts": {
+    "test": "grunt test"
+  },
+  "readme": "Transition Complete\n===================\n\nFires a callback when the current CSS transition finishes.\n\nUsage\n-----\n\nInstallation `npm install transition-complete`\n\n```javascript\ntransitionComplete(function() {\n\t//Something\n});\n```\n\nDevelopment\n-----------\n\nTo Build: `grunt build`\n\nTo Develop: `grunt watch`\n\nTo Test: `npm test`\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/bpeacock/transition-complete.js/issues"
+  },
+  "homepage": "https://github.com/bpeacock/transition-complete.js",
+  "_id": "transition-complete@0.0.2",
+  "_shasum": "5885abbe0fc4869df4045c880f52295c926d94d5",
+  "_from": "transition-complete@>=0.0.2 <1.0.0-0",
+  "_resolved": "https://registry.npmjs.org/transition-complete/-/transition-complete-0.0.2.tgz"
+}
diff --git a/node_modules/transition-complete/test/index.html b/node_modules/transition-complete/test/index.html
new file mode 100755
index 000000000..dbf61cd33
--- /dev/null
+++ b/node_modules/transition-complete/test/index.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>QUnit Example</title>
+        <link rel="stylesheet" href="../node_modules/qunitjs/qunit/qunit.css">
+    </head>
+    <body>
+        <div id="qunit"></div>
+        <div id="qunit-fixture"></div>
+
+        <script src="../node_modules/qunitjs/qunit/qunit.js"></script>
+        <script src="build.js"></script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/node_modules/transition-complete/test/test.js b/node_modules/transition-complete/test/test.js
new file mode 100644
index 000000000..c51ca6f41
--- /dev/null
+++ b/node_modules/transition-complete/test/test.js
@@ -0,0 +1,17 @@
+var sinon = require('sinon'),
+    module = window.module,
+    sandbox;
+
+module("onClick", {
+    setup: function() {
+        sandbox         = sinon.sandbox.create();
+
+    },
+    teardown: function() {
+        
+    }
+});
+
+test('sample', function() {
+    ok(true);
+});
diff --git a/node_modules/transition-complete/transition-complete.js b/node_modules/transition-complete/transition-complete.js
new file mode 100755
index 000000000..304bac06b
--- /dev/null
+++ b/node_modules/transition-complete/transition-complete.js
@@ -0,0 +1,62 @@
+(function(root) {
+    var callbacks = [];
+
+    var transitionComplete = function(callback) {
+        if(callbacks.length === 0) {
+            setEvent();
+        }
+
+        callbacks.push(callback);
+    };
+
+    function setEvent() {
+        document.addEventListener(eventName(), function() {
+            var i = callbacks.length;
+            while(i--) {
+                callbacks[i]();
+            }
+
+            callbacks = [];
+        });
+    }
+
+    var _eventName;
+
+    function eventName() {
+        if(!_eventName) {
+            // Sourced from: http://stackoverflow.com/questions/5023514/how-do-i-normalize-css3-transition-functions-across-browsers
+            var el = document.createElement('fakeelement');
+                transitions = {
+                    transition:       'transitionend',
+                    OTransition:      'oTransitionEnd',
+                    MozTransition:    'transitionend',
+                    WebkitTransition: 'webkitTransitionEnd'
+                };
+
+            for(var t in transitions) {
+                if(el.style[t] !== undefined) {
+                    _eventName = transitions[t];
+                }
+            }
+        }
+
+        return _eventName;
+    }
+    
+    /*** Export ***/
+
+    // AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+          return transitionComplete;
+        });
+    }
+    // CommonJS
+    else if(typeof exports !== 'undefined') {
+        module.exports = transitionComplete;
+    }
+    // Browser Global
+    else {
+        root.transitionComplete = transitionComplete;
+    }
+})(this);
diff --git a/node_modules/unopinionate/.npmignore b/node_modules/unopinionate/.npmignore
new file mode 100755
index 000000000..69fd427f4
--- /dev/null
+++ b/node_modules/unopinionate/.npmignore
@@ -0,0 +1,43 @@
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Node Stuff #
+##############
+node_modules/
+
+
diff --git a/node_modules/unopinionate/README.md b/node_modules/unopinionate/README.md
new file mode 100755
index 000000000..e9bde6404
--- /dev/null
+++ b/node_modules/unopinionate/README.md
@@ -0,0 +1,41 @@
+unopinionate.js
+===============
+Unopinionated front-end libraries
+
+The goal of this project is to create a shim that can be used in lieu of explicit dependencies for common but competing front-end JavaScript libraries.  For instance, many projects depend on a selector library such as jQuery or Zepto but bundling or requiring a specific dependency means that those using a competing dependency will either need to include both or resort to something that uses their existing stack.
+
+Unopinionate looks for common libraries (e.g. jQuery, Zepto) that fill a specific roll (selector libraries).  Instead of depending on the library explicitly, depend on unopionate.js to deliver whatever library the user chooses.
+
+```javascript
+var $ = unopinionate.selector;
+```
+
+Unopinionate works with CommonJS and AMD as well:
+
+```javascript
+//CommonJS
+var $ = require('unopinionate').selector;
+
+//AMD (RequireJS)
+require([
+    'unopinionate'
+], function(unopinionate) {
+    var $ = unopinionate.selector;
+});
+```
+
+This was inspired by the way Backbone.js handles selector libraries.
+
+Supported Libraries
+-------------------
+- selector
+    - jQuery
+    - Zepto
+    - Ender
+
+- template
+    - Mustache
+    - Handlebars
+
+More to come...pull requests welcome.
+
diff --git a/node_modules/unopinionate/package.json b/node_modules/unopinionate/package.json
new file mode 100755
index 000000000..b11247ee4
--- /dev/null
+++ b/node_modules/unopinionate/package.json
@@ -0,0 +1,28 @@
+{
+    "name":         "unopinionate",
+    "description":  "Unopinionated front-end libraries",
+    "version":      "0.0.4",
+    "author":       {
+        "name": "Brian Peacock"
+    },
+    "main":         "unopinionate.js",
+    "repository":   {
+        "type": "git",
+        "url": "https://github.com/bpeacock/unopinionate.js"
+    },
+    "dependencies": {
+        
+    },
+    "license": "MIT",
+    "keywords": ["unopionated", "front-end", "opinionated", "selector"],
+    "readme": "unopinionate.js\n===============\nUnopinionated front-end libraries\n\nThe goal of this project is to create a shim that can be used in lieu of explicit dependencies for common but competing front-end JavaScript libraries.  For instance, many projects depend on a selector library such as jQuery or Zepto but bundling or requiring a specific dependency means that those using a competing dependency will either need to include both or resort to something that uses their existing stack.\n\nUnopinionate looks for common libraries (e.g. jQuery, Zepto) that fill a specific roll (selector libraries).  Instead of depending on the library explicitly, depend on unopionate.js to deliver whatever library the user chooses.\n\n```javascript\nvar $ = unopinionate.selector;\n```\n\nUnopinionate works with CommonJS and AMD as well:\n\n```javascript\n//CommonJS\nvar $ = require('unopinionate').selector;\n\n//AMD (RequireJS)\nrequire([\n    'unopinionate'\n], function(unopinionate) {\n    var $ = unopinionate.selector;\n});\n```\n\nThis was inspired by the way Backbone.js handles selector libraries.\n\nSupported Libraries\n-------------------\n- selector\n    - jQuery\n    - Zepto\n    - Ender\n\n- template\n    - Mustache\n    - Handlebars\n\nMore to come...pull requests welcome.\n\n",
+    "readmeFilename": "README.md",
+    "bugs": {
+        "url": "https://github.com/bpeacock/unopinionate.js/issues"
+    },
+    "homepage": "https://github.com/bpeacock/unopinionate.js",
+    "_id": "unopinionate@0.0.4",
+    "_shasum": "0be1d6007ee204b953e4aa757989eeb635dbcc7e",
+    "_from": "unopinionate@>=0.0.4 <1.0.0-0",
+    "_resolved": "https://registry.npmjs.org/unopinionate/-/unopinionate-0.0.4.tgz"
+}
diff --git a/node_modules/unopinionate/unopinionate.js b/node_modules/unopinionate/unopinionate.js
new file mode 100755
index 000000000..1d0e0ad80
--- /dev/null
+++ b/node_modules/unopinionate/unopinionate.js
@@ -0,0 +1,23 @@
+(function(root) {
+    var unopinionate = {
+        selector: root.jQuery || root.Zepto || root.ender || root.$,
+        template: root.Handlebars || root.Mustache
+    };
+
+    /*** Export ***/
+
+    //AMD
+    if(typeof define === 'function' && define.amd) {
+        define([], function() {
+            return unopinionate;
+        });
+    }
+    //CommonJS
+    else if(typeof module.exports !== 'undefined') {
+        module.exports = unopinionate;
+    }
+    //Global
+    else {
+        root.unopinionate = unopinionate;
+    }
+})(typeof window != 'undefined' ? window : global);
diff --git a/package.yaml b/package.yaml
index caca258f5..fd1dd8ad6 100644
--- a/package.yaml
+++ b/package.yaml
@@ -18,17 +18,13 @@ bin:
   sinopia: ./bin/sinopia
 
 dependencies:
-  # watch out for future updates to express.js until
-  # https://github.com/strongloop/express/issues/2264
-  # gets resolved:
-  express: '>=3.15.0 <=3.16.3'
+  express: '>=3.15.0 <4.0.0-0'
 
   commander: '>=2.3.0 <3.0.0-0'
   js-yaml: '>=3.0.1 <4.0.0-0'
   cookies: '>=0.5.0 <1.0.0-0'
   request: '>=2.31.0 <3.0.0-0'
   async: '>=0.9.0 <1.0.0-0'
-  http-errors: '~1.2.0' # ferver
 
   # 2.x and 3.x have the same interface
   semver: '>=2.2.1 <4.0.0-0'
@@ -48,6 +44,8 @@ dependencies:
   transition-complete: '>=0.0.2 <1.0.0-0'
   helpers.less: 'git://github.com/bpeacock/helpers.less.git'
   sinopia-htpasswd: '>= 0.2.0'
+  crypt3: 'git://github.com/sendanor/node-crypt3.git'
+  http-errors: '~1.2.0' # ferver
 
   # TODO: not really needed
   tar.gz: '~0.1.1'
@@ -72,6 +70,7 @@ bundledDependencies:
   - helpers.less
   - tar.gz
   - sinopia-htpasswd
+  - http-errors
 
 devDependencies:
   rimraf: '>=2.2.5 <3.0.0-0'