style Dashboard

node_modules/error/.istanbul.yml

@@ -0,0 +1,11 @@
+instrumentation:
+    default-excludes: false
+    include-all-sources: true
+    excludes:
+        - '**/test/**'
+        - '**/coverage/**'
+        - '**/example/**'
+        - '**/test.js'
+        - '**/node_modules/istanbul/**'
+        - '**/node_modules/tape/**'
+        - '**/node_modules/uber-standard/**'

node_modules/error/.npmignore

@@ -0,0 +1,16 @@
+.DS_Store
+.monitor
+.*.swp
+.nodemonignore
+releases
+*.log
+*.err
+fleet.json
+public/browserify
+bin/*.json
+.bin
+build
+compile
+.lock-wscript
+node_modules
+coverage

node_modules/error/MIGRATION.md

@@ -0,0 +1,58 @@
+## Migration
+
+## Version 7
+
+The `message` parameter to `TypedError` is now
+required. Previously `message` was optional
+for `TypedError`.
+
+## Version 6
+
+The `WrappedError` class now exposes the error that
+is being wrapped as a `cause` field instead of an
+`original` field.
+
+The following properties have been reserver on the
+wrapped error class: `cause`, `fullType`, `causeMessage`
+
+## Version 5
+
+There were no breaking changes...
+
+## Version 4
+
+The `TypedError` function now has mandatory arguments.
+The `type` and `message` arguments for `TypedError`
+are required.
+
+## Version 3
+
+The `TypedError` class now uses `string-template` for
+message formatting.
+
+Previously:
+
+```js
+var FooError = TypedError({
+  type: 'foo.x'
+  message: 'Got an error %s'
+});
+
+FooError('Oops');
+```
+
+Currently:
+
+```js
+var FooError = TypedError({
+  type: 'foo.x',
+  message: 'Got an error {ctx}',
+  ctx: null
+});
+
+FooError({ ctx: 'Oops' });
+```
+
+## Version 2
+
+Original version

node_modules/error/README.md

@@ -0,0 +1,93 @@
+# error
+
+<!--
+    [![build status][1]][2]
+    [![NPM version][3]][4]
+    [![Coverage Status][5]][6]
+    [![gemnasium Dependency Status][7]][8]
+    [![Davis Dependency status][9]][10]
+-->
+
+<!-- [![browser support][11]][12] -->
+
+Custom errors
+
+## Typed Error
+
+```js
+var TypedError = require("error/typed")
+
+var ServerError = TypedError({
+    type: 'server.5xx',
+    message: '{title} server error, status={statusCode}',
+    title: null,
+    statusCode: null
+});
+var ClientError = TypedError({
+    type: 'client.4xx',
+    message: '{title} client error, status={statusCode}',
+    title: null,
+    statusCode: null
+});
+
+var error = ServerError({
+    title:'some title',
+    statusCode: 500
+});
+var error2 = ClientError({
+    title: 'some title',
+    statusCode: 404
+});
+```
+
+## Wrapped Errors
+
+```js
+var net = require('net');
+var WrappedError = require('error/wrapped');
+
+var ServerListenError = WrappedError({
+    message: 'server: {origMessage}',
+    type: 'server.listen-failed',
+    requestedPort: null,
+    host: null
+});
+
+var server = net.createServer();
+
+server.on('error', function onError(err) {
+    if (err.code === 'EADDRINUSE') {
+        throw ServerListenError(err, {
+            requestedPort: 3000,
+            host: null
+        });
+    } else {
+        throw err;
+    }
+});
+
+server.listen(3000);
+```
+
+## Installation
+
+`npm install error`
+
+## Contributors
+
+ - Raynos
+
+## MIT Licenced
+
+  [1]: https://secure.travis-ci.org/Raynos/error.png
+  [2]: https://travis-ci.org/Raynos/error
+  [3]: https://badge.fury.io/js/error.png
+  [4]: https://badge.fury.io/js/error
+  [5]: https://coveralls.io/repos/Raynos/error/badge.png
+  [6]: https://coveralls.io/r/Raynos/error
+  [7]: https://gemnasium.com/Raynos/error.png
+  [8]: https://gemnasium.com/Raynos/error
+  [9]: https://david-dm.org/Raynos/error.png
+  [10]: https://david-dm.org/Raynos/error
+  [11]: https://ci.testling.com/Raynos/error.png
+  [12]: https://ci.testling.com/Raynos/error

node_modules/error/docs.mli

@@ -0,0 +1,26 @@
+type OptionError<T> := {
+    option: T | null,
+    message: String,
+    type: "OptionError"
+}
+
+type TypedError<T> := {
+    message: String,
+    type: T
+}
+
+type ValidationError := {
+    errors: Array<Error>,
+    message: String,
+    type: "ValidationError"
+}
+
+error/option := (String, T) => OptionError<T>
+
+error/typed := (args: {
+    message: String,
+    type: String,
+    name?: String
+}) => (opts: Object) => TypedError<String>
+
+error/validation := (Array<Error>) => ValidationError

node_modules/error/io.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = IOError;
+
+function IOError(cause, prefix) {
+    var err = new Error(prefix + ': ' + cause.message);
+
+    Object.defineProperty(err, 'type', {
+        value: 'error.IOError',
+        configurable: true,
+        enumerable: true
+    });
+    err.name = 'WrappedIOError';
+    err.statusCode = 500;
+    Object.defineProperty(err, 'cause', {
+        value: cause,
+        configurable: true,
+        enumerable: false
+    });
+    return err;
+}

node_modules/error/node_modules/xtend/.jshintrc

@@ -0,0 +1,30 @@
+{
+    "maxdepth": 4,
+    "maxstatements": 200,
+    "maxcomplexity": 12,
+    "maxlen": 80,
+    "maxparams": 5,
+
+    "curly": true,
+    "eqeqeq": true,
+    "immed": true,
+    "latedef": false,
+    "noarg": true,
+    "noempty": true,
+    "nonew": true,
+    "undef": true,
+    "unused": "vars",
+    "trailing": true,
+
+    "quotmark": true,
+    "expr": true,
+    "asi": true,
+
+    "browser": false,
+    "esnext": true,
+    "devel": false,
+    "node": false,
+    "nonstandard": false,
+
+    "predef": ["require", "module", "__dirname", "__filename"]
+}

node_modules/error/node_modules/xtend/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2012-2014 Raynos.
+
+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.

node_modules/error/node_modules/xtend/README.md

@@ -0,0 +1,32 @@
+# xtend
+
+[![browser support][3]][4]
+
+[![locked](http://badges.github.io/stability-badges/dist/locked.svg)](http://github.com/badges/stability-badges)
+
+Extend like a boss
+
+xtend is a basic utility library which allows you to extend an object by appending all of the properties from each object in a list. When there are identical properties, the right-most property takes precedence.
+
+## Examples
+
+```js
+var extend = require("xtend")
+
+// extend returns a new object. Does not mutate arguments
+var combination = extend({
+    a: "a",
+    b: "c"
+}, {
+    b: "b"
+})
+// { a: "a", b: "b" }
+```
+
+## Stability status: Locked
+
+## MIT Licensed 
+
+
+  [3]: http://ci.testling.com/Raynos/xtend.png
+  [4]: http://ci.testling.com/Raynos/xtend

node_modules/error/node_modules/xtend/immutable.js

@@ -0,0 +1,19 @@
+module.exports = extend
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend() {
+    var target = {}
+
+    for (var i = 0; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (hasOwnProperty.call(source, key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}

node_modules/error/node_modules/xtend/mutable.js

@@ -0,0 +1,17 @@
+module.exports = extend
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (hasOwnProperty.call(source, key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}

node_modules/error/node_modules/xtend/package.json

@@ -0,0 +1,86 @@
+{
+  "_from": "xtend@~4.0.0",
+  "_id": "xtend@4.0.2",
+  "_inBundle": false,
+  "_integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+  "_location": "/error/xtend",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "xtend@~4.0.0",
+    "name": "xtend",
+    "escapedName": "xtend",
+    "rawSpec": "~4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "~4.0.0"
+  },
+  "_requiredBy": [
+    "/error"
+  ],
+  "_resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+  "_shasum": "bb72779f5fa465186b1f438f674fa347fdb5db54",
+  "_spec": "xtend@~4.0.0",
+  "_where": "/Applications/XAMPP/xamppfiles/htdocs/wordpress/latehome/wp-content/plugins/opal-estate-pro/node_modules/error",
+  "author": {
+    "name": "Raynos",
+    "email": "raynos2@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/Raynos/xtend/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Jake Verbaten"
+    },
+    {
+      "name": "Matt Esch"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "extend like a boss",
+  "devDependencies": {
+    "tape": "~1.1.0"
+  },
+  "engines": {
+    "node": ">=0.4"
+  },
+  "homepage": "https://github.com/Raynos/xtend",
+  "keywords": [
+    "extend",
+    "merge",
+    "options",
+    "opts",
+    "object",
+    "array"
+  ],
+  "license": "MIT",
+  "main": "immutable",
+  "name": "xtend",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Raynos/xtend.git"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "testling": {
+    "files": "test.js",
+    "browsers": [
+      "ie/7..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest"
+    ]
+  },
+  "version": "4.0.2"
+}

node_modules/error/node_modules/xtend/test.js

@@ -0,0 +1,103 @@
+var test = require("tape")
+var extend = require("./")
+var mutableExtend = require("./mutable")
+
+test("merge", function(assert) {
+    var a = { a: "foo" }
+    var b = { b: "bar" }
+
+    assert.deepEqual(extend(a, b), { a: "foo", b: "bar" })
+    assert.end()
+})
+
+test("replace", function(assert) {
+    var a = { a: "foo" }
+    var b = { a: "bar" }
+
+    assert.deepEqual(extend(a, b), { a: "bar" })
+    assert.end()
+})
+
+test("undefined", function(assert) {
+    var a = { a: undefined }
+    var b = { b: "foo" }
+
+    assert.deepEqual(extend(a, b), { a: undefined, b: "foo" })
+    assert.deepEqual(extend(b, a), { a: undefined, b: "foo" })
+    assert.end()
+})
+
+test("handle 0", function(assert) {
+    var a = { a: "default" }
+    var b = { a: 0 }
+
+    assert.deepEqual(extend(a, b), { a: 0 })
+    assert.deepEqual(extend(b, a), { a: "default" })
+    assert.end()
+})
+
+test("is immutable", function (assert) {
+    var record = {}
+
+    extend(record, { foo: "bar" })
+    assert.equal(record.foo, undefined)
+    assert.end()
+})
+
+test("null as argument", function (assert) {
+    var a = { foo: "bar" }
+    var b = null
+    var c = void 0
+
+    assert.deepEqual(extend(b, a, c), { foo: "bar" })
+    assert.end()
+})
+
+test("mutable", function (assert) {
+    var a = { foo: "bar" }
+
+    mutableExtend(a, { bar: "baz" })
+
+    assert.equal(a.bar, "baz")
+    assert.end()
+})
+
+test("null prototype", function(assert) {
+    var a = { a: "foo" }
+    var b = Object.create(null)
+    b.b = "bar";
+
+    assert.deepEqual(extend(a, b), { a: "foo", b: "bar" })
+    assert.end()
+})
+
+test("null prototype mutable", function (assert) {
+    var a = { foo: "bar" }
+    var b = Object.create(null)
+    b.bar = "baz";
+
+    mutableExtend(a, b)
+
+    assert.equal(a.bar, "baz")
+    assert.end()
+})
+
+test("prototype pollution", function (assert) {
+    var a = {}
+    var maliciousPayload = '{"__proto__":{"oops":"It works!"}}'
+
+    assert.strictEqual(a.oops, undefined)
+    extend({}, maliciousPayload)
+    assert.strictEqual(a.oops, undefined)
+    assert.end()
+})
+
+test("prototype pollution mutable", function (assert) {
+    var a = {}
+    var maliciousPayload = '{"__proto__":{"oops":"It works!"}}'
+
+    assert.strictEqual(a.oops, undefined)
+    mutableExtend({}, maliciousPayload)
+    assert.strictEqual(a.oops, undefined)
+    assert.end()
+})

node_modules/error/option.js

@@ -0,0 +1,19 @@
+module.exports = OptionError
+
+function OptionError(message, options) {
+    var result = new Error()
+
+    Object.defineProperty(result, "type", {
+        value: result.type,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    })
+
+    result.option = options || null
+    result.message = message
+    result.type = "OptionError"
+
+    return result
+}
+

node_modules/error/package.json

@@ -0,0 +1,90 @@
+{
+  "_from": "error@^7.0.0",
+  "_id": "error@7.0.2",
+  "_inBundle": false,
+  "_integrity": "sha1-pfdf/02ZJhJt2sDqXcOOaJFTywI=",
+  "_location": "/error",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "error@^7.0.0",
+    "name": "error",
+    "escapedName": "error",
+    "rawSpec": "^7.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.0.0"
+  },
+  "_requiredBy": [
+    "/body"
+  ],
+  "_resolved": "https://registry.npmjs.org/error/-/error-7.0.2.tgz",
+  "_shasum": "a5f75fff4d9926126ddac0ea5dc38e689153cb02",
+  "_spec": "error@^7.0.0",
+  "_where": "/Applications/XAMPP/xamppfiles/htdocs/wordpress/latehome/wp-content/plugins/opal-estate-pro/node_modules/body",
+  "author": {
+    "name": "Raynos",
+    "email": "raynos2@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/Raynos/error/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Raynos"
+    }
+  ],
+  "dependencies": {
+    "string-template": "~0.2.1",
+    "xtend": "~4.0.0"
+  },
+  "deprecated": false,
+  "description": "Custom errors",
+  "devDependencies": {
+    "istanbul": "0.3.13",
+    "tape": "^3.5.0",
+    "uber-standard": "3.6.4"
+  },
+  "homepage": "https://github.com/Raynos/error",
+  "keywords": [],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/Raynos/error/raw/master/LICENSE"
+    }
+  ],
+  "main": "index",
+  "name": "error",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Raynos/error.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover --report none --print detail ./test/index.js",
+    "lint": "standard -v .",
+    "test": "npm run lint && node test/index.js",
+    "test-browser": "testem-browser ./test/browser/index.js",
+    "testem": "testem-both -b=./test/browser/index.js",
+    "travis-test": "istanbul cover ./test/index.js && ((cat coverage/lcov.info | coveralls) || exit 0)",
+    "view-cover": "istanbul report html && google-chrome ./coverage/index.html"
+  },
+  "testling": {
+    "files": "test/index.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "version": "7.0.2"
+}

node_modules/error/test/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./typed.js');
+require('./wrapped.js');

node_modules/error/test/typed.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var test = require('tape');
+
+var TypedError = require('../typed.js');
+
+test('a server error', function t(assert) {
+    var ServerError = TypedError({
+        type: 'server.5xx.error',
+        message: '{title} server error, status={statusCode}'
+    });
+
+    var error = ServerError({
+        title: 'some title',
+        statusCode: 500
+    });
+
+    assert.equal(ServerError.type, 'server.5xx.error');
+
+    assert.equal(error.type, 'server.5xx.error');
+    assert.equal(error.fullType, 'server.5xx.error');
+    assert.equal(error.statusCode, 500);
+    assert.equal(error.message, 'some title server error, status=500');
+
+    assert.end();
+});
+
+test('a client error', function t(assert) {
+    var ClientError = TypedError({
+        type: 'client.4xx.error',
+        message: '{title} client error, status={statusCode}'
+    });
+
+    var error2 = ClientError({
+        title: 'some title',
+        statusCode: 404
+    });
+
+    assert.equal(error2.type, 'client.4xx.error');
+    assert.equal(error2.fullType, 'client.4xx.error');
+    assert.equal(error2.statusCode, 404);
+    assert.equal(error2.message, 'some title client error, status=404');
+
+    assert.end();
+});

node_modules/error/test/wrapped.js

@@ -0,0 +1,182 @@
+'use strict';
+
+var test = require('tape');
+var net = require('net');
+
+var WrappedError = require('../wrapped.js');
+
+test('can create a wrapped error', function t(assert) {
+    var ServerListenError = WrappedError({
+        message: 'server: {causeMessage}',
+        type: 'server.listen-failed',
+        requestedPort: null,
+        host: null
+    });
+
+    var err = new Error('listen EADDRINUSE');
+    err.code = 'EADDRINUSE';
+
+    var err2 = ServerListenError(err, {
+        requestedPort: 3426,
+        host: 'localhost'
+    });
+
+    assert.equal(ServerListenError.type, 'server.listen-failed');
+
+    assert.equal(err2.message, 'server: listen EADDRINUSE');
+    assert.equal(err2.requestedPort, 3426);
+    assert.equal(err2.host, 'localhost');
+    assert.equal(err2.code, 'EADDRINUSE');
+
+    assert.equal(err2.cause, err);
+
+    assert.equal(err2.toString(),
+        'ServerListenFailedError: server: listen EADDRINUSE');
+
+    assert.equal(JSON.stringify(err2), JSON.stringify({
+        type: 'server.listen-failed',
+        message: 'server: listen EADDRINUSE',
+        requestedPort: 3426,
+        host: 'localhost',
+        name: 'ServerListenFailedError',
+        causeMessage: 'listen EADDRINUSE',
+        origMessage: 'listen EADDRINUSE',
+        code: 'EADDRINUSE',
+        fullType: 'server.listen-failed~!~error.wrapped-unknown'
+    }));
+
+    assert.end();
+});
+
+test('can create wrapped error with syscall', function t(assert) {
+    var SysCallError = WrappedError({
+        'message': 'tchannel socket error ({code} from ' +
+            '{syscall}): {origMessage}',
+        type: 'syscall.error'
+    });
+
+    var err = new Error('listen EADDRINUSE');
+    err.code = 'EADDRINUSE';
+    err.syscall = 'listen';
+
+    var err2 = SysCallError(err);
+
+    assert.equal(err2.message, 'tchannel socket error ' +
+        '(EADDRINUSE from listen): listen EADDRINUSE');
+    assert.equal(err2.syscall, 'listen');
+    assert.equal(err2.code, 'EADDRINUSE');
+    assert.equal(err2.type, 'syscall.error');
+
+    assert.end();
+});
+
+test('wrapping twice', function t(assert) {
+    var ReadError = WrappedError({
+        type: 'my.read-error',
+        message: 'read: {causeMessage}'
+    });
+
+    var DatabaseError = WrappedError({
+        type: 'my.database-error',
+        message: 'db: {causeMessage}'
+    });
+
+    var BusinessError = WrappedError({
+        type: 'my.business-error',
+        message: 'business: {causeMessage}'
+    });
+
+    var err = BusinessError(
+        DatabaseError(
+            ReadError(
+                new Error('oops')
+            )
+        )
+    );
+    assert.ok(err);
+
+    assert.equal(err.message, 'business: db: read: oops');
+    assert.equal(err.type, 'my.business-error');
+    assert.equal(err.fullType, 'my.business-error~!~' +
+        'my.database-error~!~' +
+        'my.read-error~!~' +
+        'error.wrapped-unknown');
+
+    assert.end();
+});
+
+test('handles bad recursive strings', function t(assert) {
+    var ReadError = WrappedError({
+        type: 'wat.wat',
+        message: 'read: {causeMessage}'
+    });
+
+    var err2 = ReadError(new Error('hi {causeMessage}'));
+
+    assert.ok(err2);
+    assert.equal(err2.message,
+        'read: hi $INVALID_CAUSE_MESSAGE_LITERAL');
+
+    assert.end();
+});
+
+test('can wrap real IO errors', function t(assert) {
+    var ServerListenError = WrappedError({
+        message: 'server: {causeMessage}',
+        type: 'server.listen-failed',
+        requestedPort: null,
+        host: null
+    });
+
+    var otherServer = net.createServer();
+    otherServer.once('listening', onPortAllocated);
+    otherServer.listen(0);
+
+    function onPortAllocated() {
+        var port = otherServer.address().port;
+
+        var server = net.createServer();
+        server.on('error', onError);
+
+        server.listen(port);
+
+        function onError(cause) {
+            var err = ServerListenError(cause, {
+                host: 'localhost',
+                requestedPort: port
+            });
+
+            otherServer.close();
+            assertOnError(err, cause, port);
+        }
+    }
+
+    function assertOnError(err, cause, port) {
+        assert.equal(err.message, 'server: listen EADDRINUSE');
+        assert.equal(err.requestedPort, port);
+        assert.equal(err.host, 'localhost');
+        assert.equal(err.code, 'EADDRINUSE');
+
+        assert.equal(err.cause, cause);
+
+        assert.equal(err.toString(),
+            'ServerListenFailedError: server: listen EADDRINUSE');
+
+        assert.equal(JSON.stringify(err), JSON.stringify({
+            type: 'server.listen-failed',
+            message: 'server: listen EADDRINUSE',
+            requestedPort: port,
+            host: 'localhost',
+            name: 'ServerListenFailedError',
+            causeMessage: 'listen EADDRINUSE',
+            origMessage: 'listen EADDRINUSE',
+            code: 'EADDRINUSE',
+            errno: 'EADDRINUSE',
+            syscall: 'listen',
+            fullType: 'server.listen-failed~!~' +
+                'error.wrapped-io.listen.EADDRINUSE'
+        }));
+
+        assert.end();
+    }
+});

node_modules/error/typed.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var template = require('string-template');
+var extend = require('xtend/mutable');
+var assert = require('assert');
+
+var isWordBoundary = /[_.-](\w|$)/g;
+
+module.exports = TypedError;
+
+function TypedError(args) {
+    assert(args, 'TypedError: must specify options');
+    assert(args.type, 'TypedError: must specify options.type');
+    assert(args.message, 'TypedError: must specify options.message');
+
+    assert(!has(args, 'fullType'),
+        'TypedError: fullType field is reserved');
+
+    var message = args.message;
+    if (args.type && !args.name) {
+        var errorName = camelCase(args.type) + 'Error';
+        args.name = errorName[0].toUpperCase() + errorName.substr(1);
+    }
+
+    extend(createError, args);
+    createError._name = args.name;
+
+    return createError;
+
+    function createError(opts) {
+        var result = new Error();
+
+        Object.defineProperty(result, 'type', {
+            value: result.type,
+            enumerable: true,
+            writable: true,
+            configurable: true
+        });
+
+        var options = extend({}, args, opts);
+        if (!options.fullType) {
+            options.fullType = options.type;
+        }
+
+        extend(result, options);
+        if (opts && opts.message) {
+            result.message = template(opts.message, options);
+        } else if (message) {
+            result.message = template(message, options);
+        }
+
+        return result;
+    }
+}
+
+function camelCase(str) {
+    return str.replace(isWordBoundary, upperCase);
+}
+
+function upperCase(_, x) {
+    return x.toUpperCase();
+}
+
+function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

node_modules/error/validation.js

@@ -0,0 +1,19 @@
+module.exports = ValidationError
+
+function ValidationError(errors) {
+    var result = new Error()
+
+    Object.defineProperty(result, "type", {
+        value: result.type,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    })
+
+    result.errors = errors
+    result.message = errors[0].message
+    result.type = "ValidationError"
+
+    return result
+}
+

node_modules/error/wrapped.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var extend = require('xtend/mutable');
+var assert = require('assert');
+
+var TypedError = require('./typed.js');
+
+var objectToString = Object.prototype.toString;
+var ERROR_TYPE = '[object Error]';
+var causeMessageRegex = /\{causeMessage\}/g;
+var origMessageRegex = /\{origMessage\}/g;
+
+module.exports = WrappedError;
+
+function WrappedError(options) {
+    assert(options, 'WrappedError: must specify options');
+    assert(options.type, 'WrappedError: must specify type');
+    assert(options.message, 'WrappedError: must specify message');
+
+    assert(!has(options, 'cause'),
+        'WrappedError: cause field is reserved');
+    assert(!has(options, 'fullType'),
+        'WrappedError: fullType field is reserved');
+    assert(!has(options, 'causeMessage'),
+        'WrappedError: causeMessage field is reserved');
+    assert(!has(options, 'origMessage'),
+        'WrappedError: origMessage field is reserved');
+
+    var createTypedError = TypedError(options);
+    extend(createError, options);
+    createError._name = options.name;
+
+    return createError;
+
+    function createError(cause, opts) {
+        /*eslint max-statements: [2, 25]*/
+        assert(cause, 'an error is required');
+        assert(isError(cause),
+            'WrappedError: first argument must be an error');
+
+        var causeMessage = cause.message;
+        if (causeMessage.indexOf('{causeMessage}') >= 0) {
+            // recover
+            causeMessage = causeMessage.replace(
+                causeMessageRegex,
+                '$INVALID_CAUSE_MESSAGE_LITERAL'
+            );
+        }
+        if (causeMessage.indexOf('{origMessage}') >= 0) {
+            causeMessage = causeMessage.replace(
+                origMessageRegex,
+                '$INVALID_ORIG_MESSAGE_LITERAL'
+            );
+        }
+
+        var nodeCause = false;
+        var errOptions = extend({}, opts, {
+            causeMessage: causeMessage,
+            origMessage: causeMessage
+        });
+
+        if (has(cause, 'code') && !has(errOptions, 'code')) {
+            errOptions.code = cause.code;
+        }
+
+        if (has(cause, 'errno') && !has(errOptions, 'errno')) {
+            errOptions.errno = cause.errno;
+            nodeCause = true;
+        }
+
+        if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
+            errOptions.syscall = cause.syscall;
+            nodeCause = true;
+        }
+
+        var causeType = cause.type;
+        if (!causeType && nodeCause) {
+            causeType = 'error.wrapped-io.' +
+                (cause.syscall || 'unknown') + '.' +
+                (cause.errno || 'unknown');
+        } else {
+            causeType = 'error.wrapped-unknown';
+        }
+
+        errOptions.fullType = options.type + '~!~' +
+            (cause.fullType || cause.type || causeType);
+
+        var err = createTypedError(errOptions);
+
+        Object.defineProperty(err, 'cause', {
+            value: cause,
+            configurable: true,
+            enumerable: false
+        });
+        return err;
+    }
+}
+
+function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isError(err) {
+    return objectToString.call(err) === ERROR_TYPE;
+}