teaspoon 0.7.9 → 0.8.0

data/vendor/assets/javascripts/support/chai.js

@@ -27,10 +27,14 @@
     // perform real require()
     // by invoking the module's
     // registered function
-    if (!module.exports) {
-      module.exports = {};
-      module.client = module.component = true;
-      module.call(this, module.exports, require.relative(resolved), module);
+    if (!module._resolving && !module.exports) {
+      var mod = {};
+      mod.exports = {};
+      mod.client = mod.component = true;
+      module._resolving = true;
+      module.call(this, mod.exports, require.relative(resolved), mod);
+      delete module._resolving;
+      module.exports = mod.exports;
     }
 
     return module.exports;
@@ -64,7 +68,6 @@
 
   require.resolve = function(path) {
     if (path.charAt(0) === '/') path = path.slice(1);
-    var index = path + '/index.js';
 
     var paths = [
       path,
@@ -77,10 +80,7 @@
     for (var i = 0; i < paths.length; i++) {
       var path = paths[i];
       if (require.modules.hasOwnProperty(path)) return path;
-    }
-
-    if (require.aliases.hasOwnProperty(index)) {
-      return require.aliases[index];
+      if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
     }
   };
 
@@ -200,287 +200,745 @@
 
     return localRequire;
   };
-  require.register("chai/index.js", function(exports, require, module){
-    module.exports = require('./lib/chai');
-
-  });
-  require.register("chai/lib/chai.js", function(exports, require, module){
+  require.register("chaijs-assertion-error/index.js", function(exports, require, module){
     /*!
-     * chai
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * assertion-error
+     * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
      * MIT Licensed
      */
 
-    var used = []
-        , exports = module.exports = {};
+    /*!
+     * Return a function that will copy properties from
+     * one object to another excluding any originally
+     * listed. Returned function will create a new `{}`.
+     *
+     * @param {String} excluded properties ...
+     * @return {Function}
+     */
+
+    function exclude () {
+      var excludes = [].slice.call(arguments);
+
+      function excludeProps (res, obj) {
+        Object.keys(obj).forEach(function (key) {
+          if (!~excludes.indexOf(key)) res[key] = obj[key];
+        });
+      }
+
+      return function extendExclude () {
+        var args = [].slice.call(arguments)
+            , i = 0
+            , res = {};
+
+        for (; i < args.length; i++) {
+          excludeProps(res, args[i]);
+        }
+
+        return res;
+      };
+    };
 
     /*!
-     * Chai version
+     * Primary Exports
+     */
+
+    module.exports = AssertionError;
+
+    /**
+     * ### AssertionError
+     *
+     * An extension of the JavaScript `Error` constructor for
+     * assertion and validation scenarios.
+     *
+     * @param {String} message
+     * @param {Object} properties to include (optional)
+     * @param {callee} start stack function (optional)
      */
 
-    exports.version = '1.6.1';
+    function AssertionError (message, _props, ssf) {
+      var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')
+          , props = extend(_props || {});
+
+      // default values
+      this.message = message || 'Unspecified AssertionError';
+      this.showDiff = false;
+
+      // copy from properties
+      for (var key in props) {
+        this[key] = props[key];
+      }
+
+      // capture stack trace
+      ssf = ssf || arguments.callee;
+      if (ssf && Error.captureStackTrace) {
+        Error.captureStackTrace(this, ssf);
+      }
+    }
 
     /*!
-     * Primary `Assertion` prototype
+     * Inherit from Error.prototype
      */
 
-    exports.Assertion = require('./chai/assertion');
+    AssertionError.prototype = Object.create(Error.prototype);
 
     /*!
-     * Assertion Error
+     * Statically set name
      */
 
-    exports.AssertionError = require('./chai/error');
+    AssertionError.prototype.name = 'AssertionError';
 
     /*!
-     * Utils for plugins (not exported)
+     * Ensure correct constructor
      */
 
-    var util = require('./chai/utils');
+    AssertionError.prototype.constructor = AssertionError;
 
     /**
-     * # .use(function)
-     *
-     * Provides a way to extend the internals of Chai
+     * Allow errors to be converted to JSON for static transfer.
      *
-     * @param {Function}
-     * @returns {this} for chaining
-     * @api public
+     * @param {Boolean} include stack (default: `true`)
+     * @return {Object} object that can be `JSON.stringify`
      */
 
-    exports.use = function (fn) {
-      if (!~used.indexOf(fn)) {
-        fn(this, util);
-        used.push(fn);
+    AssertionError.prototype.toJSON = function (stack) {
+      var extend = exclude('constructor', 'toJSON', 'stack')
+          , props = extend({ name: this.name }, this);
+
+      // include stack if exists and not turned off
+      if (false !== stack && this.stack) {
+        props.stack = this.stack;
       }
 
-      return this;
+      return props;
     };
 
+  });
+  require.register("chaijs-type-detect/lib/type.js", function(exports, require, module){
     /*!
-     * Core Assertions
+     * type-detect
+     * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
+     * MIT Licensed
      */
 
-    var core = require('./chai/core/assertions');
-    exports.use(core);
-
     /*!
-     * Expect interface
+     * Primary Exports
      */
 
-    var expect = require('./chai/interface/expect');
-    exports.use(expect);
+    var exports = module.exports = getType;
 
     /*!
-     * Should interface
+     * Detectable javascript natives
      */
 
-    var should = require('./chai/interface/should');
-    exports.use(should);
+    var natives = {
+      '[object Array]': 'array'
+      , '[object RegExp]': 'regexp'
+      , '[object Function]': 'function'
+      , '[object Arguments]': 'arguments'
+      , '[object Date]': 'date'
+    };
 
-    /*!
-     * Assert interface
+    /**
+     * ### typeOf (obj)
+     *
+     * Use several different techniques to determine
+     * the type of object being tested.
+     *
+     *
+     * @param {Mixed} object
+     * @return {String} object type
+     * @api public
      */
 
-    var assert = require('./chai/interface/assert');
-    exports.use(assert);
+    function getType (obj) {
+      var str = Object.prototype.toString.call(obj);
+      if (natives[str]) return natives[str];
+      if (obj === null) return 'null';
+      if (obj === undefined) return 'undefined';
+      if (obj === Object(obj)) return 'object';
+      return typeof obj;
+    }
+
+    exports.Library = Library;
+
+    /**
+     * ### Library
+     *
+     * Create a repository for custom type detection.
+     *
+     * ```js
+     * var lib = new type.Library;
+     * ```
+     *
+     */
+
+    function Library () {
+      this.tests = {};
+    }
+
+    /**
+     * #### .of (obj)
+     *
+     * Expose replacement `typeof` detection to the library.
+     *
+     * ```js
+     * if ('string' === lib.of('hello world')) {
+ *   // ...
+ * }
+     * ```
+     *
+     * @param {Mixed} object to test
+     * @return {String} type
+     */
+
+    Library.prototype.of = getType;
+
+    /**
+     * #### .define (type, test)
+     *
+     * Add a test to for the `.test()` assertion.
+     *
+     * Can be defined as a regular expression:
+     *
+     * ```js
+     * lib.define('int', /^[0-9]+$/);
+     * ```
+     *
+     * ... or as a function:
+     *
+     * ```js
+     * lib.define('bln', function (obj) {
+ *   if ('boolean' === lib.of(obj)) return true;
+ *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
+ *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
+ *   return !! ~blns.indexOf(obj);
+ * });
+     * ```
+     *
+     * @param {String} type
+     * @param {RegExp|Function} test
+     * @api public
+     */
+
+    Library.prototype.define = function (type, test) {
+      if (arguments.length === 1) return this.tests[type];
+      this.tests[type] = test;
+      return this;
+    };
+
+    /**
+     * #### .test (obj, test)
+     *
+     * Assert that an object is of type. Will first
+     * check natives, and if that does not pass it will
+     * use the user defined custom tests.
+     *
+     * ```js
+     * assert(lib.test('1', 'int'));
+     * assert(lib.test('yes', 'bln'));
+     * ```
+     *
+     * @param {Mixed} object
+     * @param {String} type
+     * @return {Boolean} result
+     * @api public
+     */
+
+    Library.prototype.test = function (obj, type) {
+      if (type === getType(obj)) return true;
+      var test = this.tests[type];
+
+      if (test && 'regexp' === getType(test)) {
+        return test.test(obj);
+      } else if (test && 'function' === getType(test)) {
+        return test(obj);
+      } else {
+        throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
+      }
+    };
 
   });
-  require.register("chai/lib/chai/assertion.js", function(exports, require, module){
+  require.register("chaijs-deep-eql/lib/eql.js", function(exports, require, module){
     /*!
-     * chai
-     * http://chaijs.com
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * deep-eql
+     * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
     /*!
-     * Module dependencies.
+     * Module dependencies
      */
 
-    var AssertionError = require('./error')
-        , util = require('./utils')
-        , flag = util.flag;
+    var type = require('type-detect');
 
     /*!
-     * Module export.
+     * Buffer.isBuffer browser shim
      */
 
-    module.exports = Assertion;
-
+    var Buffer;
+    try { Buffer = require('buffer').Buffer; }
+    catch(ex) {
+      Buffer = {};
+      Buffer.isBuffer = function() { return false; }
+    }
 
     /*!
-     * Assertion Constructor
+     * Primary Export
+     */
+
+    module.exports = deepEqual;
+
+    /**
+     * Assert super-strict (egal) equality between
+     * two objects of any type.
      *
-     * Creates object for chaining.
+     * @param {Mixed} a
+     * @param {Mixed} b
+     * @param {Array} memoised (optional)
+     * @return {Boolean} equal match
+     */
+
+    function deepEqual(a, b, m) {
+      if (sameValue(a, b)) {
+        return true;
+      } else if ('date' === type(a)) {
+        return dateEqual(a, b);
+      } else if ('regexp' === type(a)) {
+        return regexpEqual(a, b);
+      } else if (Buffer.isBuffer(a)) {
+        return bufferEqual(a, b);
+      } else if ('arguments' === type(a)) {
+        return argumentsEqual(a, b, m);
+      } else if (!typeEqual(a, b)) {
+        return false;
+      } else if (('object' !== type(a) && 'object' !== type(b))
+          && ('array' !== type(a) && 'array' !== type(b))) {
+        return sameValue(a, b);
+      } else {
+        return objectEqual(a, b, m);
+      }
+    }
+
+    /*!
+     * Strict (egal) equality test. Ensures that NaN always
+     * equals NaN and `-0` does not equal `+0`.
      *
-     * @api private
+     * @param {Mixed} a
+     * @param {Mixed} b
+     * @return {Boolean} equal match
      */
 
-    function Assertion (obj, msg, stack) {
-      flag(this, 'ssfi', stack || arguments.callee);
-      flag(this, 'object', obj);
-      flag(this, 'message', msg);
+    function sameValue(a, b) {
+      if (a === b) return a !== 0 || 1 / a === 1 / b;
+      return a !== a && b !== b;
     }
 
     /*!
-     * ### Assertion.includeStack
+     * Compare the types of two given objects and
+     * return if they are equal. Note that an Array
+     * has a type of `array` (not `object`) and arguments
+     * have a type of `arguments` (not `array`/`object`).
      *
-     * User configurable property, influences whether stack trace
-     * is included in Assertion error message. Default of false
-     * suppresses stack trace in the error message
+     * @param {Mixed} a
+     * @param {Mixed} b
+     * @return {Boolean} result
+     */
+
+    function typeEqual(a, b) {
+      return type(a) === type(b);
+    }
+
+    /*!
+     * Compare two Date objects by asserting that
+     * the time values are equal using `saveValue`.
      *
-     *     Assertion.includeStack = true;  // enable stack on error
+     * @param {Date} a
+     * @param {Date} b
+     * @return {Boolean} result
+     */
+
+    function dateEqual(a, b) {
+      if ('date' !== type(b)) return false;
+      return sameValue(a.getTime(), b.getTime());
+    }
+
+    /*!
+     * Compare two regular expressions by converting them
+     * to string and checking for `sameValue`.
      *
-     * @api public
+     * @param {RegExp} a
+     * @param {RegExp} b
+     * @return {Boolean} result
      */
 
-    Assertion.includeStack = false;
+    function regexpEqual(a, b) {
+      if ('regexp' !== type(b)) return false;
+      return sameValue(a.toString(), b.toString());
+    }
 
     /*!
-     * ### Assertion.showDiff
+     * Assert deep equality of two `arguments` objects.
+     * Unfortunately, these must be sliced to arrays
+     * prior to test to ensure no bad behavior.
      *
-     * User configurable property, influences whether or not
-     * the `showDiff` flag should be included in the thrown
-     * AssertionErrors. `false` will always be `false`; `true`
-     * will be true when the assertion has requested a diff
-     * be shown.
+     * @param {Arguments} a
+     * @param {Arguments} b
+     * @param {Array} memoize (optional)
+     * @return {Boolean} result
+     */
+
+    function argumentsEqual(a, b, m) {
+      if ('arguments' !== type(b)) return false;
+      a = [].slice.call(a);
+      b = [].slice.call(b);
+      return deepEqual(a, b, m);
+    }
+
+    /*!
+     * Get enumerable properties of a given object.
      *
-     * @api public
+     * @param {Object} a
+     * @return {Array} property names
      */
 
-    Assertion.showDiff = true;
+    function enumerable(a) {
+      var res = [];
+      for (var key in a) res.push(key);
+      return res;
+    }
 
-    Assertion.addProperty = function (name, fn) {
-      util.addProperty(this.prototype, name, fn);
-    };
+    /*!
+     * Simple equality for flat iterable objects
+     * such as Arrays or Node.js buffers.
+     *
+     * @param {Iterable} a
+     * @param {Iterable} b
+     * @return {Boolean} result
+     */
 
-    Assertion.addMethod = function (name, fn) {
-      util.addMethod(this.prototype, name, fn);
-    };
+    function iterableEqual(a, b) {
+      if (a.length !==  b.length) return false;
 
-    Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
-      util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
-    };
+      var i = 0;
+      var match = true;
 
-    Assertion.overwriteProperty = function (name, fn) {
-      util.overwriteProperty(this.prototype, name, fn);
-    };
+      for (; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          match = false;
+          break;
+        }
+      }
 
-    Assertion.overwriteMethod = function (name, fn) {
-      util.overwriteMethod(this.prototype, name, fn);
-    };
+      return match;
+    }
 
     /*!
-     * ### .assert(expression, message, negateMessage, expected, actual)
+     * Extension to `iterableEqual` specifically
+     * for Node.js Buffers.
      *
-     * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
-     *
-     * @name assert
-     * @param {Philosophical} expression to be tested
-     * @param {String} message to display if fails
-     * @param {String} negatedMessage to display if negated expression fails
-     * @param {Mixed} expected value (remember to check for negation)
-     * @param {Mixed} actual (optional) will default to `this.obj`
-     * @api private
+     * @param {Buffer} a
+     * @param {Mixed} b
+     * @return {Boolean} result
      */
 
-    Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
-      var ok = util.test(this, arguments);
-      if (true !== showDiff) showDiff = false;
-      if (true !== Assertion.showDiff) showDiff = false;
-
-      if (!ok) {
-        var msg = util.getMessage(this, arguments)
-            , actual = util.getActual(this, arguments);
-        throw new AssertionError({
-          message: msg
-          , actual: actual
-          , expected: expected
-          , stackStartFunction: (Assertion.includeStack) ? this.assert : flag(this, 'ssfi')
-          , showDiff: showDiff
-        });
-      }
-    };
+    function bufferEqual(a, b) {
+      if (!Buffer.isBuffer(b)) return false;
+      return iterableEqual(a, b);
+    }
 
     /*!
-     * ### ._obj
+     * Block for `objectEqual` ensuring non-existing
+     * values don't get in.
      *
-     * Quick reference to stored `actual` value for plugin developers.
+     * @param {Mixed} object
+     * @return {Boolean} result
+     */
+
+    function isValue(a) {
+      return a !== null && a !== undefined;
+    }
+
+    /*!
+     * Recursively check the equality of two objects.
+     * Once basic sameness has been established it will
+     * defer to `deepEqual` for each enumerable key
+     * in the object.
      *
-     * @api private
+     * @param {Mixed} a
+     * @param {Mixed} b
+     * @return {Boolean} result
      */
 
-    Object.defineProperty(Assertion.prototype, '_obj',
-        { get: function () {
-          return flag(this, 'object');
+    function objectEqual(a, b, m) {
+      if (!isValue(a) || !isValue(b)) {
+        return false;
+      }
+
+      if (a.prototype !== b.prototype) {
+        return false;
+      }
+
+      var i;
+      if (m) {
+        for (i = 0; i < m.length; i++) {
+          if ((m[i][0] === a && m[i][1] === b)
+              ||  (m[i][0] === b && m[i][1] === a)) {
+            return true;
+          }
         }
-          , set: function (val) {
-          flag(this, 'object', val);
+      } else {
+        m = [];
+      }
+
+      try {
+        var ka = enumerable(a);
+        var kb = enumerable(b);
+      } catch (ex) {
+        return false;
+      }
+
+      ka.sort();
+      kb.sort();
+
+      if (!iterableEqual(ka, kb)) {
+        return false;
+      }
+
+      m.push([ a, b ]);
+
+      var key;
+      for (i = ka.length - 1; i >= 0; i--) {
+        key = ka[i];
+        if (!deepEqual(a[key], b[key], m)) {
+          return false;
         }
-        });
+      }
+
+      return true;
+    }
+
+  });
+  require.register("chai/index.js", function(exports, require, module){
+    module.exports = require('./lib/chai');
 
   });
-  require.register("chai/lib/chai/error.js", function(exports, require, module){
+  require.register("chai/lib/chai.js", function(exports, require, module){
     /*!
      * chai
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
+    var used = []
+        , exports = module.exports = {};
+
     /*!
-     * Main export
+     * Chai version
      */
 
-    module.exports = AssertionError;
+    exports.version = '1.8.1';
+
+    /*!
+     * Assertion Error
+     */
+
+    exports.AssertionError = require('assertion-error');
+
+    /*!
+     * Utils for plugins (not exported)
+     */
+
+    var util = require('./chai/utils');
 
     /**
-     * # AssertionError (constructor)
-     *
-     * Create a new assertion error based on the Javascript
-     * `Error` prototype.
+     * # .use(function)
      *
-     * **Options**
-     * - message
-     * - actual
-     * - expected
-     * - operator
-     * - startStackFunction
+     * Provides a way to extend the internals of Chai
      *
-     * @param {Object} options
+     * @param {Function}
+     * @returns {this} for chaining
      * @api public
      */
 
-    function AssertionError (options) {
-      options = options || {};
-      this.message = options.message;
-      this.actual = options.actual;
-      this.expected = options.expected;
-      this.operator = options.operator;
-      this.showDiff = options.showDiff;
-
-      if (options.stackStartFunction && Error.captureStackTrace) {
-        var stackStartFunction = options.stackStartFunction;
-        Error.captureStackTrace(this, stackStartFunction);
+    exports.use = function (fn) {
+      if (!~used.indexOf(fn)) {
+        fn(this, util);
+        used.push(fn);
       }
-    }
+
+      return this;
+    };
 
     /*!
-     * Inherit from Error
+     * Primary `Assertion` prototype
      */
 
-    AssertionError.prototype = Object.create(Error.prototype);
-    AssertionError.prototype.name = 'AssertionError';
-    AssertionError.prototype.constructor = AssertionError;
+    var assertion = require('./chai/assertion');
+    exports.use(assertion);
 
-    /**
-     * # toString()
-     *
-     * Override default to string method
+    /*!
+     * Core Assertions
+     */
+
+    var core = require('./chai/core/assertions');
+    exports.use(core);
+
+    /*!
+     * Expect interface
+     */
+
+    var expect = require('./chai/interface/expect');
+    exports.use(expect);
+
+    /*!
+     * Should interface
+     */
+
+    var should = require('./chai/interface/should');
+    exports.use(should);
+
+    /*!
+     * Assert interface
      */
 
-    AssertionError.prototype.toString = function() {
-      return this.message;
+    var assert = require('./chai/interface/assert');
+    exports.use(assert);
+
+  });
+  require.register("chai/lib/chai/assertion.js", function(exports, require, module){
+    /*!
+     * chai
+     * http://chaijs.com
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
+     * MIT Licensed
+     */
+
+    module.exports = function (_chai, util) {
+      /*!
+       * Module dependencies.
+       */
+
+      var AssertionError = _chai.AssertionError
+          , flag = util.flag;
+
+      /*!
+       * Module export.
+       */
+
+      _chai.Assertion = Assertion;
+
+      /*!
+       * Assertion Constructor
+       *
+       * Creates object for chaining.
+       *
+       * @api private
+       */
+
+      function Assertion (obj, msg, stack) {
+        flag(this, 'ssfi', stack || arguments.callee);
+        flag(this, 'object', obj);
+        flag(this, 'message', msg);
+      }
+
+      /*!
+       * ### Assertion.includeStack
+       *
+       * User configurable property, influences whether stack trace
+       * is included in Assertion error message. Default of false
+       * suppresses stack trace in the error message
+       *
+       *     Assertion.includeStack = true;  // enable stack on error
+       *
+       * @api public
+       */
+
+      Assertion.includeStack = false;
+
+      /*!
+       * ### Assertion.showDiff
+       *
+       * User configurable property, influences whether or not
+       * the `showDiff` flag should be included in the thrown
+       * AssertionErrors. `false` will always be `false`; `true`
+       * will be true when the assertion has requested a diff
+       * be shown.
+       *
+       * @api public
+       */
+
+      Assertion.showDiff = true;
+
+      Assertion.addProperty = function (name, fn) {
+        util.addProperty(this.prototype, name, fn);
+      };
+
+      Assertion.addMethod = function (name, fn) {
+        util.addMethod(this.prototype, name, fn);
+      };
+
+      Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
+        util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
+      };
+
+      Assertion.overwriteProperty = function (name, fn) {
+        util.overwriteProperty(this.prototype, name, fn);
+      };
+
+      Assertion.overwriteMethod = function (name, fn) {
+        util.overwriteMethod(this.prototype, name, fn);
+      };
+
+      Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
+        util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
+      };
+
+      /*!
+       * ### .assert(expression, message, negateMessage, expected, actual)
+       *
+       * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
+       *
+       * @name assert
+       * @param {Philosophical} expression to be tested
+       * @param {String} message to display if fails
+       * @param {String} negatedMessage to display if negated expression fails
+       * @param {Mixed} expected value (remember to check for negation)
+       * @param {Mixed} actual (optional) will default to `this.obj`
+       * @api private
+       */
+
+      Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
+        var ok = util.test(this, arguments);
+        if (true !== showDiff) showDiff = false;
+        if (true !== Assertion.showDiff) showDiff = false;
+
+        if (!ok) {
+          var msg = util.getMessage(this, arguments)
+              , actual = util.getActual(this, arguments);
+          throw new AssertionError(msg, {
+            actual: actual
+            , expected: expected
+            , showDiff: showDiff
+          }, (Assertion.includeStack) ? this.assert : flag(this, 'ssfi'));
+        }
+      };
+
+      /*!
+       * ### ._obj
+       *
+       * Quick reference to stored `actual` value for plugin developers.
+       *
+       * @api private
+       */
+
+      Object.defineProperty(Assertion.prototype, '_obj',
+          { get: function () {
+            return flag(this, 'object');
+          }
+            , set: function (val) {
+            flag(this, 'object', val);
+          }
+          });
     };
 
   });
@@ -488,7 +946,7 @@
     /*!
      * chai
      * http://chaijs.com
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -500,7 +958,7 @@
       /**
        * ### Language Chains
        *
-       * The following are provide as chainable getters to
+       * The following are provided as chainable getters to
        * improve the readability of your assertions. They
        * do not provide an testing capability unless they
        * have been overwritten by a plugin.
@@ -513,6 +971,7 @@
        * - is
        * - that
        * - and
+       * - has
        * - have
        * - with
        * - at
@@ -524,7 +983,7 @@
        */
 
       [ 'to', 'be', 'been'
-        , 'is', 'and', 'have'
+        , 'is', 'and', 'has', 'have'
         , 'with', 'that', 'at'
         , 'of', 'same' ].forEach(function (chain) {
             Assertion.addProperty(chain, function () {
@@ -632,9 +1091,21 @@
 
       function include (val, msg) {
         if (msg) flag(this, 'message', msg);
-        var obj = flag(this, 'object')
+        var obj = flag(this, 'object');
+
+        if (_.type(val) === 'object') {
+          if (!flag(this, 'negate')) {
+            for (var k in val) new Assertion(obj).property(k, val[k]);
+            return;
+          }
+          var subset = {}
+          for (var k in val) subset[k] = obj[k]
+          var expected = _.eql(subset, val);
+        } else {
+          var expected = obj && ~obj.indexOf(val)
+        }
         this.assert(
-            ~obj.indexOf(val)
+            expected
             , 'expected #{this} to include ' + _.inspect(val)
             , 'expected #{this} to not include ' + _.inspect(val));
       }
@@ -731,8 +1202,8 @@
        *
        * Asserts that the target is `undefined`.
        *
-       *      expect(undefined).to.be.undefined;
-       *      expect(null).to.not.be.undefined;
+       *     expect(undefined).to.be.undefined;
+       *     expect(null).to.not.be.undefined;
        *
        * @name undefined
        * @api public
@@ -1489,6 +1960,7 @@
        * @param {String|RegExp} expected error message
        * @param {String} message _optional_
        * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+       * @returns error for chaining (null if no error)
        * @api public
        */
 
@@ -1513,7 +1985,10 @@
           constructor = null;
           errMsg = null;
         } else if (typeof constructor === 'function') {
-          name = (new constructor()).name;
+          name = constructor.prototype.name || constructor.name;
+          if (name === 'Error' && constructor !== Error) {
+            name = (new constructor()).name;
+          }
         } else {
           constructor = null;
         }
@@ -1527,12 +2002,14 @@
                 err === desiredError
                 , 'expected #{this} to throw #{exp} but #{act} was thrown'
                 , 'expected #{this} to not throw #{exp}'
-                , desiredError
-                , err
+                , (desiredError instanceof Error ? desiredError.toString() : desiredError)
+                , (err instanceof Error ? err.toString() : err)
             );
 
+            flag(this, 'object', err);
             return this;
           }
+
           // next, check constructor
           if (constructor) {
             this.assert(
@@ -1540,11 +2017,15 @@
                 , 'expected #{this} to throw #{exp} but #{act} was thrown'
                 , 'expected #{this} to not throw #{exp} but #{act} was thrown'
                 , name
-                , err
+                , (err instanceof Error ? err.toString() : err)
             );
 
-            if (!errMsg) return this;
+            if (!errMsg) {
+              flag(this, 'object', err);
+              return this;
+            }
           }
+
           // next, check message
           var message = 'object' === _.type(err) && "message" in err
               ? err.message
@@ -1559,6 +2040,7 @@
                 , message
             );
 
+            flag(this, 'object', err);
             return this;
           } else if ((message != null) && errMsg && 'string' === typeof errMsg) {
             this.assert(
@@ -1569,6 +2051,7 @@
                 , message
             );
 
+            flag(this, 'object', err);
             return this;
           } else {
             thrown = true;
@@ -1591,9 +2074,11 @@
             thrown === true
             , 'expected #{this} to throw ' + expectedThrown + actuallyGot
             , 'expected #{this} to not throw ' + expectedThrown + actuallyGot
-            , desiredError
-            , thrownError
+            , (desiredError instanceof Error ? desiredError.toString() : desiredError)
+            , (thrownError instanceof Error ? thrownError.toString() : thrownError)
         );
+
+        flag(this, 'object', thrownError);
       };
 
       Assertion.addMethod('throw', assertThrows);
@@ -1612,8 +2097,8 @@
        * To check if a constructor will respond to a static function,
        * set the `itself` flag.
        *
-       *    Klass.baz = function(){};
-       *    expect(Klass).itself.to.respondTo('baz');
+       *     Klass.baz = function(){};
+       *     expect(Klass).itself.to.respondTo('baz');
        *
        * @name respondTo
        * @param {String} method
@@ -1641,12 +2126,12 @@
        *
        * Sets the `itself` flag, later used by the `respondTo` assertion.
        *
-       *    function Foo() {}
-       *    Foo.bar = function() {}
-       *    Foo.prototype.baz = function() {}
+       *     function Foo() {}
+       *     Foo.bar = function() {}
+       *     Foo.prototype.baz = function() {}
        *
-       *    expect(Foo).itself.to.respondTo('bar');
-       *    expect(Foo).itself.not.to.respondTo('baz');
+       *     expect(Foo).itself.to.respondTo('bar');
+       *     expect(Foo).itself.not.to.respondTo('baz');
        *
        * @name itself
        * @api public
@@ -1712,16 +2197,16 @@
       }
 
       /**
-       * ### .members
+       * ### .members(set)
        *
        * Asserts that the target is a superset of `set`,
        * or that the target and `set` have the same members.
        *
-       *    expect([1, 2, 3]).to.include.members([3, 2]);
-       *    expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
+       *     expect([1, 2, 3]).to.include.members([3, 2]);
+       *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
        *
-       *    expect([4, 2]).to.have.members([2, 4]);
-       *    expect([5, 2]).to.not.have.members([5, 2, 1]);
+       *     expect([4, 2]).to.have.members([2, 4]);
+       *     expect([5, 2]).to.not.have.members([5, 2, 1]);
        *
        * @name members
        * @param {Array} set
@@ -1760,7 +2245,7 @@
   require.register("chai/lib/chai/interface/assert.js", function(exports, require, module){
     /*!
      * chai
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -1815,13 +2300,12 @@
        */
 
       assert.fail = function (actual, expected, message, operator) {
-        throw new chai.AssertionError({
+        message = message || 'assert.fail()';
+        throw new chai.AssertionError(message, {
           actual: actual
           , expected: expected
-          , message: message
           , operator: operator
-          , stackStartFunction: assert.fail
-        });
+        }, assert.fail);
       };
 
       /**
@@ -1842,6 +2326,24 @@
         new Assertion(val, msg).is.ok;
       };
 
+      /**
+       * ### .notOk(object, [message])
+       *
+       * Asserts that `object` is falsy.
+       *
+       *     assert.notOk('everything', 'this will fail');
+       *     assert.notOk(false, 'this will pass');
+       *
+       * @name notOk
+       * @param {Mixed} object to test
+       * @param {String} message
+       * @api public
+       */
+
+      assert.notOk = function (val, msg) {
+        new Assertion(val, msg).is.not.ok;
+      };
+
       /**
        * ### .equal(actual, expected, [message])
        *
@@ -2399,18 +2901,7 @@
        */
 
       assert.include = function (exp, inc, msg) {
-        var obj = new Assertion(exp, msg);
-
-        if (Array.isArray(exp)) {
-          obj.to.include(inc);
-        } else if ('string' === typeof exp) {
-          obj.to.contain.string(inc);
-        } else {
-          throw new chai.AssertionError({
-            message: 'expected an array or string'
-            , stackStartFunction: assert.include
-          });
-        }
+        new Assertion(exp, msg).include(inc);
       };
 
       /**
@@ -2430,18 +2921,7 @@
        */
 
       assert.notInclude = function (exp, inc, msg) {
-        var obj = new Assertion(exp, msg);
-
-        if (Array.isArray(exp)) {
-          obj.to.not.include(inc);
-        } else if ('string' === typeof exp) {
-          obj.to.not.contain.string(inc);
-        } else {
-          throw new chai.AssertionError({
-            message: 'expected an array or string'
-            , stackStartFunction: assert.include
-          });
-        }
+        new Assertion(exp, msg).not.include(inc);
       };
 
       /**
@@ -2685,7 +3165,8 @@
           errt = null;
         }
 
-        new Assertion(fn, msg).to.Throw(errt, errs);
+        var assertErr = new Assertion(fn, msg).to.Throw(errt, errs);
+        return flag(assertErr, 'object');
       };
 
       /**
@@ -2823,7 +3304,7 @@
   require.register("chai/lib/chai/interface/expect.js", function(exports, require, module){
     /*!
      * chai
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -2838,7 +3319,7 @@
   require.register("chai/lib/chai/interface/should.js", function(exports, require, module){
     /*!
      * chai
-     * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -2917,7 +3398,7 @@
   require.register("chai/lib/chai/utils/addChainableMethod.js", function(exports, require, module){
     /*!
      * Chai - addChainingMethod utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -2972,15 +3453,27 @@
      */
 
     module.exports = function (ctx, name, method, chainingBehavior) {
-      if (typeof chainingBehavior !== 'function')
+      if (typeof chainingBehavior !== 'function') {
         chainingBehavior = function () { };
+      }
+
+      var chainableBehavior = {
+        method: method
+        , chainingBehavior: chainingBehavior
+      };
+
+      // save the methods so we can overwrite them later, if we need to.
+      if (!ctx.__methods) {
+        ctx.__methods = {};
+      }
+      ctx.__methods[name] = chainableBehavior;
 
       Object.defineProperty(ctx, name,
           { get: function () {
-            chainingBehavior.call(this);
+            chainableBehavior.chainingBehavior.call(this);
 
             var assert = function () {
-              var result = method.apply(this, arguments);
+              var result = chainableBehavior.method.apply(this, arguments);
               return result === undefined ? this : result;
             };
 
@@ -3014,7 +3507,7 @@
   require.register("chai/lib/chai/utils/addMethod.js", function(exports, require, module){
     /*!
      * Chai - addMethod utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3054,7 +3547,7 @@
   require.register("chai/lib/chai/utils/addProperty.js", function(exports, require, module){
     /*!
      * Chai - addProperty utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3093,141 +3586,11 @@
           });
     };
 
-  });
-  require.register("chai/lib/chai/utils/eql.js", function(exports, require, module){
-// This is (almost) directly from Node.js assert
-// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
-
-    module.exports = _deepEqual;
-
-    var getEnumerableProperties = require('./getEnumerableProperties');
-
-// for the browser
-    var Buffer;
-    try {
-      Buffer = require('buffer').Buffer;
-    } catch (ex) {
-      Buffer = {
-        isBuffer: function () { return false; }
-      };
-    }
-
-    function _deepEqual(actual, expected, memos) {
-
-      // 7.1. All identical values are equivalent, as determined by ===.
-      if (actual === expected) {
-        return true;
-
-      } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
-        if (actual.length != expected.length) return false;
-
-        for (var i = 0; i < actual.length; i++) {
-          if (actual[i] !== expected[i]) return false;
-        }
-
-        return true;
-
-        // 7.2. If the expected value is a Date object, the actual value is
-        // equivalent if it is also a Date object that refers to the same time.
-      } else if (actual instanceof Date && expected instanceof Date) {
-        return actual.getTime() === expected.getTime();
-
-        // 7.3. Other pairs that do not both pass typeof value == 'object',
-        // equivalence is determined by ==.
-      } else if (typeof actual != 'object' && typeof expected != 'object') {
-        return actual === expected;
-
-      } else if (actual instanceof RegExp && expected instanceof RegExp){
-        return actual.toString() === expected.toString();
-
-        // 7.4. For all other Object pairs, including Array objects, equivalence is
-        // determined by having the same number of owned properties (as verified
-        // with Object.prototype.hasOwnProperty.call), the same set of keys
-        // (although not necessarily the same order), equivalent values for every
-        // corresponding key, and an identical 'prototype' property. Note: this
-        // accounts for both named and indexed properties on Arrays.
-      } else {
-        return objEquiv(actual, expected, memos);
-      }
-    }
-
-    function isUndefinedOrNull(value) {
-      return value === null || value === undefined;
-    }
-
-    function isArguments(object) {
-      return Object.prototype.toString.call(object) == '[object Arguments]';
-    }
-
-    function objEquiv(a, b, memos) {
-      if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
-        return false;
-
-      // an identical 'prototype' property.
-      if (a.prototype !== b.prototype) return false;
-
-      // check if we have already compared a and b
-      var i;
-      if (memos) {
-        for(i = 0; i < memos.length; i++) {
-          if ((memos[i][0] === a && memos[i][1] === b) ||
-              (memos[i][0] === b && memos[i][1] === a))
-            return true;
-        }
-      } else {
-        memos = [];
-      }
-
-      //~~~I've managed to break Object.keys through screwy arguments passing.
-      //   Converting to array solves the problem.
-      if (isArguments(a)) {
-        if (!isArguments(b)) {
-          return false;
-        }
-        a = pSlice.call(a);
-        b = pSlice.call(b);
-        return _deepEqual(a, b, memos);
-      }
-      try {
-        var ka = getEnumerableProperties(a),
-            kb = getEnumerableProperties(b),
-            key;
-      } catch (e) {//happens when one is a string literal and the other isn't
-        return false;
-      }
-
-      // having the same number of owned properties (keys incorporates
-      // hasOwnProperty)
-      if (ka.length != kb.length)
-        return false;
-
-      //the same set of keys (although not necessarily the same order),
-      ka.sort();
-      kb.sort();
-      //~~~cheap key test
-      for (i = ka.length - 1; i >= 0; i--) {
-        if (ka[i] != kb[i])
-          return false;
-      }
-
-      // remember objects we have compared to guard against circular references
-      memos.push([ a, b ]);
-
-      //equivalent values for every corresponding key, and
-      //~~~possibly expensive deep test
-      for (i = ka.length - 1; i >= 0; i--) {
-        key = ka[i];
-        if (!_deepEqual(a[key], b[key], memos)) return false;
-      }
-
-      return true;
-    }
-
   });
   require.register("chai/lib/chai/utils/flag.js", function(exports, require, module){
     /*!
      * Chai - flag utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3262,7 +3625,7 @@
   require.register("chai/lib/chai/utils/getActual.js", function(exports, require, module){
     /*!
      * Chai - getActual utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3284,7 +3647,7 @@
   require.register("chai/lib/chai/utils/getEnumerableProperties.js", function(exports, require, module){
     /*!
      * Chai - getEnumerableProperties utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3312,7 +3675,7 @@
   require.register("chai/lib/chai/utils/getMessage.js", function(exports, require, module){
     /*!
      * Chai - message composition utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3332,7 +3695,7 @@
      * and template tags. Template tags will return
      * a stringified inspection of the object referenced.
      *
-     * Messsage template tags:
+     * Message template tags:
      * - `#{this}` current asserted object
      * - `#{act}` actual value
      * - `#{exp}` expected value
@@ -3364,7 +3727,7 @@
   require.register("chai/lib/chai/utils/getName.js", function(exports, require, module){
     /*!
      * Chai - getName utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3387,7 +3750,7 @@
   require.register("chai/lib/chai/utils/getPathValue.js", function(exports, require, module){
     /*!
      * Chai - getPathValue utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * @see https://github.com/logicalparadox/filtr
      * MIT Licensed
      */
@@ -3492,7 +3855,7 @@
   require.register("chai/lib/chai/utils/getProperties.js", function(exports, require, module){
     /*!
      * Chai - getProperties utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -3592,7 +3955,7 @@
      * Deep equal utility
      */
 
-    exports.eql = require('./eql');
+    exports.eql = require('deep-eql');
 
     /*!
      * Deep path value
@@ -3636,6 +3999,12 @@
 
     exports.addChainableMethod = require('./addChainableMethod');
 
+    /*!
+     * Overwrite chainable method
+     */
+
+    exports.overwriteChainableMethod = require('./overwriteChainableMethod');
+
 
   });
   require.register("chai/lib/chai/utils/inspect.js", function(exports, require, module){
@@ -3706,7 +4075,11 @@
           value.inspect !== exports.inspect &&
         // Also filter out any prototype objects using the circular check.
           !(value.constructor && value.constructor.prototype === value)) {
-        return value.inspect(recurseTimes);
+        var ret = value.inspect(recurseTimes);
+        if (typeof ret !== 'string') {
+          ret = formatValue(ctx, ret, recurseTimes);
+        }
+        return ret;
       }
 
       // Primitive types cannot have properties
@@ -3960,7 +4333,7 @@
   require.register("chai/lib/chai/utils/objDisplay.js", function(exports, require, module){
     /*!
      * Chai - flag utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4011,7 +4384,7 @@
   require.register("chai/lib/chai/utils/overwriteMethod.js", function(exports, require, module){
     /*!
      * Chai - overwriteMethod utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4065,7 +4438,7 @@
   require.register("chai/lib/chai/utils/overwriteProperty.js", function(exports, require, module){
     /*!
      * Chai - overwriteProperty utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4118,11 +4491,67 @@
           });
     };
 
+  });
+  require.register("chai/lib/chai/utils/overwriteChainableMethod.js", function(exports, require, module){
+    /*!
+     * Chai - overwriteChainableMethod utility
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+     * MIT Licensed
+     */
+
+    /**
+     * ### overwriteChainableMethod (ctx, name, fn)
+     *
+     * Overwites an already existing chainable method
+     * and provides access to the previous function or
+     * property.  Must return functions to be used for
+     * name.
+     *
+     *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
+     *       function (_super) {
+ *       }
+     *     , function (_super) {
+ *       }
+     *     );
+     *
+     * Can also be accessed directly from `chai.Assertion`.
+     *
+     *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);
+     *
+     * Then can be used as any other assertion.
+     *
+     *     expect(myFoo).to.have.length(3);
+     *     expect(myFoo).to.have.length.above(3);
+     *
+     * @param {Object} ctx object whose method / property is to be overwritten
+     * @param {String} name of method / property to overwrite
+     * @param {Function} method function that returns a function to be used for name
+     * @param {Function} chainingBehavior function that returns a function to be used for property
+     * @name overwriteChainableMethod
+     * @api public
+     */
+
+    module.exports = function (ctx, name, method, chainingBehavior) {
+      var chainableBehavior = ctx.__methods[name];
+
+      var _chainingBehavior = chainableBehavior.chainingBehavior;
+      chainableBehavior.chainingBehavior = function () {
+        var result = chainingBehavior(_chainingBehavior).call(this);
+        return result === undefined ? this : result;
+      };
+
+      var _method = chainableBehavior.method;
+      chainableBehavior.method = function () {
+        var result = method(_method).apply(this, arguments);
+        return result === undefined ? this : result;
+      };
+    };
+
   });
   require.register("chai/lib/chai/utils/test.js", function(exports, require, module){
     /*!
      * Chai - test utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4151,7 +4580,7 @@
   require.register("chai/lib/chai/utils/transferFlags.js", function(exports, require, module){
     /*!
      * Chai - transferFlags utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4198,7 +4627,7 @@
   require.register("chai/lib/chai/utils/type.js", function(exports, require, module){
     /*!
      * Chai - type utility
-     * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
      * MIT Licensed
      */
 
@@ -4243,12 +4672,25 @@
     };
 
   });
-  require.alias("chai/index.js", "chai/index.js");
 
-  if (typeof exports == "object") {
+
+
+
+  require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
+  require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
+  require.alias("chaijs-assertion-error/index.js", "assertion-error/index.js");
+  require.alias("chaijs-assertion-error/index.js", "chaijs-assertion-error/index.js");
+  require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/lib/eql.js");
+  require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/index.js");
+  require.alias("chaijs-deep-eql/lib/eql.js", "deep-eql/index.js");
+  require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/lib/type.js");
+  require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/index.js");
+  require.alias("chaijs-type-detect/lib/type.js", "chaijs-type-detect/index.js");
+  require.alias("chaijs-deep-eql/lib/eql.js", "chaijs-deep-eql/index.js");
+  require.alias("chai/index.js", "chai/index.js");if (typeof exports == "object") {
     module.exports = require("chai");
   } else if (typeof define == "function" && define.amd) {
-    define(function(){ return require("chai"); });
+    define([], function(){ return require("chai"); });
   } else {
     this["chai"] = require("chai");
   }})();