@nostrwatch/utils 0.2.0

package/dist/browser/node_modules/.pnpm/chai@4.5.0/node_modules/chai/lib/chai/interface/assert.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.amd.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/chai@4.5.0/node_modules/chai/lib/chai/interface/assert.js"],"sourcesContent":["/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, util) {\n  /*!\n   * Chai dependencies.\n   */\n\n  var Assertion = chai.Assertion\n    , flag = util.flag;\n\n  /*!\n   * Module export.\n   */\n\n  /**\n   * ### assert(expression, message)\n   *\n   * Write your own test expressions.\n   *\n   *     assert('foo' !== 'bar', 'foo is not bar');\n   *     assert(Array.isArray([]), 'empty arrays are arrays');\n   *\n   * @param {Mixed} expression to test for truthiness\n   * @param {String} message to display on error\n   * @name assert\n   * @namespace Assert\n   * @api public\n   */\n\n  var assert = chai.assert = function (express, errmsg) {\n    var test = new Assertion(null, null, chai.assert, true);\n    test.assert(\n        express\n      , errmsg\n      , '[ negation message unavailable ]'\n    );\n  };\n\n  /**\n   * ### .fail([message])\n   * ### .fail(actual, expected, [message], [operator])\n   *\n   * Throw a failure. Node.js `assert` module-compatible.\n   *\n   *     assert.fail();\n   *     assert.fail(\"custom error message\");\n   *     assert.fail(1, 2);\n   *     assert.fail(1, 2, \"custom error message\");\n   *     assert.fail(1, 2, \"custom error message\", \">\");\n   *     assert.fail(1, 2, undefined, \">\");\n   *\n   * @name fail\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @param {String} operator\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.fail = function (actual, expected, message, operator) {\n    if (arguments.length < 2) {\n        // Comply with Node's fail([message]) interface\n\n        message = actual;\n        actual = undefined;\n    }\n\n    message = message || 'assert.fail()';\n    throw new chai.AssertionError(message, {\n        actual: actual\n      , expected: expected\n      , operator: operator\n    }, assert.fail);\n  };\n\n  /**\n   * ### .isOk(object, [message])\n   *\n   * Asserts that `object` is truthy.\n   *\n   *     assert.isOk('everything', 'everything is ok');\n   *     assert.isOk(false, 'this will fail');\n   *\n   * @name isOk\n   * @alias ok\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isOk = function (val, msg) {\n    new Assertion(val, msg, assert.isOk, true).is.ok;\n  };\n\n  /**\n   * ### .isNotOk(object, [message])\n   *\n   * Asserts that `object` is falsy.\n   *\n   *     assert.isNotOk('everything', 'this will fail');\n   *     assert.isNotOk(false, 'this will pass');\n   *\n   * @name isNotOk\n   * @alias notOk\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotOk = function (val, msg) {\n    new Assertion(val, msg, assert.isNotOk, true).is.not.ok;\n  };\n\n  /**\n   * ### .equal(actual, expected, [message])\n   *\n   * Asserts non-strict equality (`==`) of `actual` and `expected`.\n   *\n   *     assert.equal(3, '3', '== coerces values to strings');\n   *\n   * @name equal\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.equal = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.equal, true);\n\n    test.assert(\n        exp == flag(test, 'object')\n      , 'expected #{this} to equal #{exp}'\n      , 'expected #{this} to not equal #{act}'\n      , exp\n      , act\n      , true\n    );\n  };\n\n  /**\n   * ### .notEqual(actual, expected, [message])\n   *\n   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.\n   *\n   *     assert.notEqual(3, 4, 'these numbers are not equal');\n   *\n   * @name notEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notEqual = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.notEqual, true);\n\n    test.assert(\n        exp != flag(test, 'object')\n      , 'expected #{this} to not equal #{exp}'\n      , 'expected #{this} to equal #{act}'\n      , exp\n      , act\n      , true\n    );\n  };\n\n  /**\n   * ### .strictEqual(actual, expected, [message])\n   *\n   * Asserts strict equality (`===`) of `actual` and `expected`.\n   *\n   *     assert.strictEqual(true, true, 'these booleans are strictly equal');\n   *\n   * @name strictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.strictEqual = function (act, exp, msg) {\n    new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);\n  };\n\n  /**\n   * ### .notStrictEqual(actual, expected, [message])\n   *\n   * Asserts strict inequality (`!==`) of `actual` and `expected`.\n   *\n   *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');\n   *\n   * @name notStrictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notStrictEqual = function (act, exp, msg) {\n    new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);\n  };\n\n  /**\n   * ### .deepEqual(actual, expected, [message])\n   *\n   * Asserts that `actual` is deeply equal to `expected`.\n   *\n   *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });\n   *\n   * @name deepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @alias deepStrictEqual\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepEqual = assert.deepStrictEqual = function (act, exp, msg) {\n    new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);\n  };\n\n  /**\n   * ### .notDeepEqual(actual, expected, [message])\n   *\n   * Assert that `actual` is not deeply equal to `expected`.\n   *\n   *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });\n   *\n   * @name notDeepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepEqual = function (act, exp, msg) {\n    new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);\n  };\n\n   /**\n   * ### .isAbove(valueToCheck, valueToBeAbove, [message])\n   *\n   * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`.\n   *\n   *     assert.isAbove(5, 2, '5 is strictly greater than 2');\n   *\n   * @name isAbove\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAbove\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAbove = function (val, abv, msg) {\n    new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);\n  };\n\n   /**\n   * ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message])\n   *\n   * Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`.\n   *\n   *     assert.isAtLeast(5, 2, '5 is greater or equal to 2');\n   *     assert.isAtLeast(3, 3, '3 is greater or equal to 3');\n   *\n   * @name isAtLeast\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAtLeast\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAtLeast = function (val, atlst, msg) {\n    new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);\n  };\n\n   /**\n   * ### .isBelow(valueToCheck, valueToBeBelow, [message])\n   *\n   * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`.\n   *\n   *     assert.isBelow(3, 6, '3 is strictly less than 6');\n   *\n   * @name isBelow\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeBelow\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isBelow = function (val, blw, msg) {\n    new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);\n  };\n\n   /**\n   * ### .isAtMost(valueToCheck, valueToBeAtMost, [message])\n   *\n   * Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`.\n   *\n   *     assert.isAtMost(3, 6, '3 is less than or equal to 6');\n   *     assert.isAtMost(4, 4, '4 is less than or equal to 4');\n   *\n   * @name isAtMost\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAtMost\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAtMost = function (val, atmst, msg) {\n    new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);\n  };\n\n  /**\n   * ### .isTrue(value, [message])\n   *\n   * Asserts that `value` is true.\n   *\n   *     var teaServed = true;\n   *     assert.isTrue(teaServed, 'the tea has been served');\n   *\n   * @name isTrue\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isTrue = function (val, msg) {\n    new Assertion(val, msg, assert.isTrue, true).is['true'];\n  };\n\n  /**\n   * ### .isNotTrue(value, [message])\n   *\n   * Asserts that `value` is not true.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotTrue(tea, 'great, time for tea!');\n   *\n   * @name isNotTrue\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotTrue = function (val, msg) {\n    new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);\n  };\n\n  /**\n   * ### .isFalse(value, [message])\n   *\n   * Asserts that `value` is false.\n   *\n   *     var teaServed = false;\n   *     assert.isFalse(teaServed, 'no tea yet? hmm...');\n   *\n   * @name isFalse\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFalse = function (val, msg) {\n    new Assertion(val, msg, assert.isFalse, true).is['false'];\n  };\n\n  /**\n   * ### .isNotFalse(value, [message])\n   *\n   * Asserts that `value` is not false.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotFalse(tea, 'great, time for tea!');\n   *\n   * @name isNotFalse\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFalse = function (val, msg) {\n    new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);\n  };\n\n  /**\n   * ### .isNull(value, [message])\n   *\n   * Asserts that `value` is null.\n   *\n   *     assert.isNull(err, 'there was no error');\n   *\n   * @name isNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNull = function (val, msg) {\n    new Assertion(val, msg, assert.isNull, true).to.equal(null);\n  };\n\n  /**\n   * ### .isNotNull(value, [message])\n   *\n   * Asserts that `value` is not null.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotNull(tea, 'great, time for tea!');\n   *\n   * @name isNotNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotNull = function (val, msg) {\n    new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);\n  };\n\n  /**\n   * ### .isNaN\n   *\n   * Asserts that value is NaN.\n   *\n   *     assert.isNaN(NaN, 'NaN is NaN');\n   *\n   * @name isNaN\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNaN = function (val, msg) {\n    new Assertion(val, msg, assert.isNaN, true).to.be.NaN;\n  };\n\n  /**\n   * ### .isNotNaN\n   *\n   * Asserts that value is not NaN.\n   *\n   *     assert.isNotNaN(4, '4 is not NaN');\n   *\n   * @name isNotNaN\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n  assert.isNotNaN = function (val, msg) {\n    new Assertion(val, msg, assert.isNotNaN, true).not.to.be.NaN;\n  };\n\n  /**\n   * ### .exists\n   *\n   * Asserts that the target is neither `null` nor `undefined`.\n   *\n   *     var foo = 'hi';\n   *\n   *     assert.exists(foo, 'foo is neither `null` nor `undefined`');\n   *\n   * @name exists\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.exists = function (val, msg) {\n    new Assertion(val, msg, assert.exists, true).to.exist;\n  };\n\n  /**\n   * ### .notExists\n   *\n   * Asserts that the target is either `null` or `undefined`.\n   *\n   *     var bar = null\n   *       , baz;\n   *\n   *     assert.notExists(bar);\n   *     assert.notExists(baz, 'baz is either null or undefined');\n   *\n   * @name notExists\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notExists = function (val, msg) {\n    new Assertion(val, msg, assert.notExists, true).to.not.exist;\n  };\n\n  /**\n   * ### .isUndefined(value, [message])\n   *\n   * Asserts that `value` is `undefined`.\n   *\n   *     var tea;\n   *     assert.isUndefined(tea, 'no tea defined');\n   *\n   * @name isUndefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isUndefined = function (val, msg) {\n    new Assertion(val, msg, assert.isUndefined, true).to.equal(undefined);\n  };\n\n  /**\n   * ### .isDefined(value, [message])\n   *\n   * Asserts that `value` is not `undefined`.\n   *\n   *     var tea = 'cup of chai';\n   *     assert.isDefined(tea, 'tea has been defined');\n   *\n   * @name isDefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isDefined = function (val, msg) {\n    new Assertion(val, msg, assert.isDefined, true).to.not.equal(undefined);\n  };\n\n  /**\n   * ### .isFunction(value, [message])\n   *\n   * Asserts that `value` is a function.\n   *\n   *     function serveTea() { return 'cup of tea'; };\n   *     assert.isFunction(serveTea, 'great, we can have tea now');\n   *\n   * @name isFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFunction = function (val, msg) {\n    new Assertion(val, msg, assert.isFunction, true).to.be.a('function');\n  };\n\n  /**\n   * ### .isNotFunction(value, [message])\n   *\n   * Asserts that `value` is _not_ a function.\n   *\n   *     var serveTea = [ 'heat', 'pour', 'sip' ];\n   *     assert.isNotFunction(serveTea, 'great, we have listed the steps');\n   *\n   * @name isNotFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFunction = function (val, msg) {\n    new Assertion(val, msg, assert.isNotFunction, true).to.not.be.a('function');\n  };\n\n  /**\n   * ### .isObject(value, [message])\n   *\n   * Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).\n   * _The assertion does not match subclassed objects._\n   *\n   *     var selection = { name: 'Chai', serve: 'with spices' };\n   *     assert.isObject(selection, 'tea selection is an object');\n   *\n   * @name isObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isObject = function (val, msg) {\n    new Assertion(val, msg, assert.isObject, true).to.be.a('object');\n  };\n\n  /**\n   * ### .isNotObject(value, [message])\n   *\n   * Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).\n   *\n   *     var selection = 'chai'\n   *     assert.isNotObject(selection, 'tea selection is not an object');\n   *     assert.isNotObject(null, 'null is not an object');\n   *\n   * @name isNotObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotObject = function (val, msg) {\n    new Assertion(val, msg, assert.isNotObject, true).to.not.be.a('object');\n  };\n\n  /**\n   * ### .isArray(value, [message])\n   *\n   * Asserts that `value` is an array.\n   *\n   *     var menu = [ 'green', 'chai', 'oolong' ];\n   *     assert.isArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isArray = function (val, msg) {\n    new Assertion(val, msg, assert.isArray, true).to.be.an('array');\n  };\n\n  /**\n   * ### .isNotArray(value, [message])\n   *\n   * Asserts that `value` is _not_ an array.\n   *\n   *     var menu = 'green|chai|oolong';\n   *     assert.isNotArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isNotArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotArray = function (val, msg) {\n    new Assertion(val, msg, assert.isNotArray, true).to.not.be.an('array');\n  };\n\n  /**\n   * ### .isString(value, [message])\n   *\n   * Asserts that `value` is a string.\n   *\n   *     var teaOrder = 'chai';\n   *     assert.isString(teaOrder, 'order placed');\n   *\n   * @name isString\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isString = function (val, msg) {\n    new Assertion(val, msg, assert.isString, true).to.be.a('string');\n  };\n\n  /**\n   * ### .isNotString(value, [message])\n   *\n   * Asserts that `value` is _not_ a string.\n   *\n   *     var teaOrder = 4;\n   *     assert.isNotString(teaOrder, 'order placed');\n   *\n   * @name isNotString\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotString = function (val, msg) {\n    new Assertion(val, msg, assert.isNotString, true).to.not.be.a('string');\n  };\n\n  /**\n   * ### .isNumber(value, [message])\n   *\n   * Asserts that `value` is a number.\n   *\n   *     var cups = 2;\n   *     assert.isNumber(cups, 'how many cups');\n   *\n   * @name isNumber\n   * @param {Number} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNumber = function (val, msg) {\n    new Assertion(val, msg, assert.isNumber, true).to.be.a('number');\n  };\n\n  /**\n   * ### .isNotNumber(value, [message])\n   *\n   * Asserts that `value` is _not_ a number.\n   *\n   *     var cups = '2 cups please';\n   *     assert.isNotNumber(cups, 'how many cups');\n   *\n   * @name isNotNumber\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotNumber = function (val, msg) {\n    new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a('number');\n  };\n\n   /**\n   * ### .isFinite(value, [message])\n   *\n   * Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity`.\n   *\n   *     var cups = 2;\n   *     assert.isFinite(cups, 'how many cups');\n   *\n   *     assert.isFinite(NaN); // throws\n   *\n   * @name isFinite\n   * @param {Number} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFinite = function (val, msg) {\n    new Assertion(val, msg, assert.isFinite, true).to.be.finite;\n  };\n\n  /**\n   * ### .isBoolean(value, [message])\n   *\n   * Asserts that `value` is a boolean.\n   *\n   *     var teaReady = true\n   *       , teaServed = false;\n   *\n   *     assert.isBoolean(teaReady, 'is the tea ready');\n   *     assert.isBoolean(teaServed, 'has tea been served');\n   *\n   * @name isBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isBoolean = function (val, msg) {\n    new Assertion(val, msg, assert.isBoolean, true).to.be.a('boolean');\n  };\n\n  /**\n   * ### .isNotBoolean(value, [message])\n   *\n   * Asserts that `value` is _not_ a boolean.\n   *\n   *     var teaReady = 'yep'\n   *       , teaServed = 'nope';\n   *\n   *     assert.isNotBoolean(teaReady, 'is the tea ready');\n   *     assert.isNotBoolean(teaServed, 'has tea been served');\n   *\n   * @name isNotBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotBoolean = function (val, msg) {\n    new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a('boolean');\n  };\n\n  /**\n   * ### .typeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');\n   *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');\n   *     assert.typeOf('tea', 'string', 'we have a string');\n   *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');\n   *     assert.typeOf(null, 'null', 'we have a null');\n   *     assert.typeOf(undefined, 'undefined', 'we have an undefined');\n   *\n   * @name typeOf\n   * @param {Mixed} value\n   * @param {String} name\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.typeOf = function (val, type, msg) {\n    new Assertion(val, msg, assert.typeOf, true).to.be.a(type);\n  };\n\n  /**\n   * ### .notTypeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is _not_ `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.notTypeOf('tea', 'number', 'strings are not numbers');\n   *\n   * @name notTypeOf\n   * @param {Mixed} value\n   * @param {String} typeof name\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notTypeOf = function (val, type, msg) {\n    new Assertion(val, msg, assert.notTypeOf, true).to.not.be.a(type);\n  };\n\n  /**\n   * ### .instanceOf(object, constructor, [message])\n   *\n   * Asserts that `value` is an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new Tea('chai');\n   *\n   *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');\n   *\n   * @name instanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.instanceOf = function (val, type, msg) {\n    new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type);\n  };\n\n  /**\n   * ### .notInstanceOf(object, constructor, [message])\n   *\n   * Asserts `value` is not an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new String('chai');\n   *\n   *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');\n   *\n   * @name notInstanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notInstanceOf = function (val, type, msg) {\n    new Assertion(val, msg, assert.notInstanceOf, true)\n      .to.not.be.instanceOf(type);\n  };\n\n  /**\n   * ### .include(haystack, needle, [message])\n   *\n   * Asserts that `haystack` includes `needle`. Can be used to assert the\n   * inclusion of a value in an array, a substring in a string, or a subset of\n   * properties in an object.\n   *\n   *     assert.include([1,2,3], 2, 'array contains value');\n   *     assert.include('foobar', 'foo', 'string contains substring');\n   *     assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property');\n   *\n   * Strict equality (===) is used. When asserting the inclusion of a value in\n   * an array, the array is searched for an element that's strictly equal to the\n   * given value. When asserting a subset of properties in an object, the object\n   * is searched for the given property keys, checking that each one is present\n   * and strictly equal to the given property value. For instance:\n   *\n   *     var obj1 = {a: 1}\n   *       , obj2 = {b: 2};\n   *     assert.include([obj1, obj2], obj1);\n   *     assert.include({foo: obj1, bar: obj2}, {foo: obj1});\n   *     assert.include({foo: obj1, bar: obj2}, {foo: obj1, bar: obj2});\n   *\n   * @name include\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.include = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.include, true).include(inc);\n  };\n\n  /**\n   * ### .notInclude(haystack, needle, [message])\n   *\n   * Asserts that `haystack` does not include `needle`. Can be used to assert\n   * the absence of a value in an array, a substring in a string, or a subset of\n   * properties in an object.\n   *\n   *     assert.notInclude([1,2,3], 4, \"array doesn't contain value\");\n   *     assert.notInclude('foobar', 'baz', \"string doesn't contain substring\");\n   *     assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn't contain property');\n   *\n   * Strict equality (===) is used. When asserting the absence of a value in an\n   * array, the array is searched to confirm the absence of an element that's\n   * strictly equal to the given value. When asserting a subset of properties in\n   * an object, the object is searched to confirm that at least one of the given\n   * property keys is either not present or not strictly equal to the given\n   * property value. For instance:\n   *\n   *     var obj1 = {a: 1}\n   *       , obj2 = {b: 2};\n   *     assert.notInclude([obj1, obj2], {a: 1});\n   *     assert.notInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});\n   *     assert.notInclude({foo: obj1, bar: obj2}, {foo: obj1, bar: {b: 2}});\n   *\n   * @name notInclude\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.notInclude, true).not.include(inc);\n  };\n\n  /**\n   * ### .deepInclude(haystack, needle, [message])\n   *\n   * Asserts that `haystack` includes `needle`. Can be used to assert the\n   * inclusion of a value in an array or a subset of properties in an object.\n   * Deep equality is used.\n   *\n   *     var obj1 = {a: 1}\n   *       , obj2 = {b: 2};\n   *     assert.deepInclude([obj1, obj2], {a: 1});\n   *     assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});\n   *     assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 2}});\n   *\n   * @name deepInclude\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);\n  };\n\n  /**\n   * ### .notDeepInclude(haystack, needle, [message])\n   *\n   * Asserts that `haystack` does not include `needle`. Can be used to assert\n   * the absence of a value in an array or a subset of properties in an object.\n   * Deep equality is used.\n   *\n   *     var obj1 = {a: 1}\n   *       , obj2 = {b: 2};\n   *     assert.notDeepInclude([obj1, obj2], {a: 9});\n   *     assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 9}});\n   *     assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 9}});\n   *\n   * @name notDeepInclude\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);\n  };\n\n  /**\n   * ### .nestedInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the inclusion of a subset of properties in an\n   * object.\n   * Enables the use of dot- and bracket-notation for referencing nested\n   * properties.\n   * '[]' and '.' in property names can be escaped using double backslashes.\n   *\n   *     assert.nestedInclude({'.a': {'b': 'x'}}, {'\\\\.a.[b]': 'x'});\n   *     assert.nestedInclude({'a': {'[b]': 'x'}}, {'a.\\\\[b\\\\]': 'x'});\n   *\n   * @name nestedInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.nestedInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);\n  };\n\n  /**\n   * ### .notNestedInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' does not include 'needle'.\n   * Can be used to assert the absence of a subset of properties in an\n   * object.\n   * Enables the use of dot- and bracket-notation for referencing nested\n   * properties.\n   * '[]' and '.' in property names can be escaped using double backslashes.\n   *\n   *     assert.notNestedInclude({'.a': {'b': 'x'}}, {'\\\\.a.b': 'y'});\n   *     assert.notNestedInclude({'a': {'[b]': 'x'}}, {'a.\\\\[b\\\\]': 'y'});\n   *\n   * @name notNestedInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notNestedInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.notNestedInclude, true)\n      .not.nested.include(inc);\n  };\n\n  /**\n   * ### .deepNestedInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the inclusion of a subset of properties in an\n   * object while checking for deep equality.\n   * Enables the use of dot- and bracket-notation for referencing nested\n   * properties.\n   * '[]' and '.' in property names can be escaped using double backslashes.\n   *\n   *     assert.deepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {x: 1}});\n   *     assert.deepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\\\.a.\\\\[b\\\\]': {x: 1}});\n   *\n   * @name deepNestedInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepNestedInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.deepNestedInclude, true)\n      .deep.nested.include(inc);\n  };\n\n  /**\n   * ### .notDeepNestedInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' does not include 'needle'.\n   * Can be used to assert the absence of a subset of properties in an\n   * object while checking for deep equality.\n   * Enables the use of dot- and bracket-notation for referencing nested\n   * properties.\n   * '[]' and '.' in property names can be escaped using double backslashes.\n   *\n   *     assert.notDeepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {y: 1}})\n   *     assert.notDeepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\\\.a.\\\\[b\\\\]': {y: 2}});\n   *\n   * @name notDeepNestedInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepNestedInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.notDeepNestedInclude, true)\n      .not.deep.nested.include(inc);\n  };\n\n  /**\n   * ### .ownInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the inclusion of a subset of properties in an\n   * object while ignoring inherited properties.\n   *\n   *     assert.ownInclude({ a: 1 }, { a: 1 });\n   *\n   * @name ownInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.ownInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);\n  };\n\n  /**\n   * ### .notOwnInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the absence of a subset of properties in an\n   * object while ignoring inherited properties.\n   *\n   *     Object.prototype.b = 2;\n   *\n   *     assert.notOwnInclude({ a: 1 }, { b: 2 });\n   *\n   * @name notOwnInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notOwnInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);\n  };\n\n  /**\n   * ### .deepOwnInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the inclusion of a subset of properties in an\n   * object while ignoring inherited properties and checking for deep equality.\n   *\n   *      assert.deepOwnInclude({a: {b: 2}}, {a: {b: 2}});\n   *\n   * @name deepOwnInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepOwnInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.deepOwnInclude, true)\n      .deep.own.include(inc);\n  };\n\n   /**\n   * ### .notDeepOwnInclude(haystack, needle, [message])\n   *\n   * Asserts that 'haystack' includes 'needle'.\n   * Can be used to assert the absence of a subset of properties in an\n   * object while ignoring inherited properties and checking for deep equality.\n   *\n   *      assert.notDeepOwnInclude({a: {b: 2}}, {a: {c: 3}});\n   *\n   * @name notDeepOwnInclude\n   * @param {Object} haystack\n   * @param {Object} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepOwnInclude = function(exp, inc, msg) {\n    new Assertion(exp, msg, assert.notDeepOwnInclude, true)\n      .not.deep.own.include(inc);\n  };\n\n  /**\n   * ### .match(value, regexp, [message])\n   *\n   * Asserts that `value` matches the regular expression `regexp`.\n   *\n   *     assert.match('foobar', /^foo/, 'regexp matches');\n   *\n   * @name match\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.match = function (exp, re, msg) {\n    new Assertion(exp, msg, assert.match, true).to.match(re);\n  };\n\n  /**\n   * ### .notMatch(value, regexp, [message])\n   *\n   * Asserts that `value` does not match the regular expression `regexp`.\n   *\n   *     assert.notMatch('foobar', /^foo/, 'regexp does not match');\n   *\n   * @name notMatch\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notMatch = function (exp, re, msg) {\n    new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);\n  };\n\n  /**\n   * ### .property(object, property, [message])\n   *\n   * Asserts that `object` has a direct or inherited property named by\n   * `property`.\n   *\n   *     assert.property({ tea: { green: 'matcha' }}, 'tea');\n   *     assert.property({ tea: { green: 'matcha' }}, 'toString');\n   *\n   * @name property\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.property = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.property, true).to.have.property(prop);\n  };\n\n  /**\n   * ### .notProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a direct or inherited property named\n   * by `property`.\n   *\n   *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');\n   *\n   * @name notProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.notProperty, true)\n      .to.not.have.property(prop);\n  };\n\n  /**\n   * ### .propertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a direct or inherited property named by\n   * `property` with a value given by `value`. Uses a strict equality check\n   * (===).\n   *\n   *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');\n   *\n   * @name propertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.propertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.propertyVal, true)\n      .to.have.property(prop, val);\n  };\n\n  /**\n   * ### .notPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a direct or inherited property named\n   * by `property` with value given by `value`. Uses a strict equality check\n   * (===).\n   *\n   *     assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');\n   *     assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');\n   *\n   * @name notPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.notPropertyVal, true)\n      .to.not.have.property(prop, val);\n  };\n\n  /**\n   * ### .deepPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a direct or inherited property named by\n   * `property` with a value given by `value`. Uses a deep equality check.\n   *\n   *     assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });\n   *\n   * @name deepPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.deepPropertyVal, true)\n      .to.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .notDeepPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a direct or inherited property named\n   * by `property` with value given by `value`. Uses a deep equality check.\n   *\n   *     assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });\n   *     assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });\n   *     assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });\n   *\n   * @name notDeepPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.notDeepPropertyVal, true)\n      .to.not.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .ownProperty(object, property, [message])\n   *\n   * Asserts that `object` has a direct property named by `property`. Inherited\n   * properties aren't checked.\n   *\n   *     assert.ownProperty({ tea: { green: 'matcha' }}, 'tea');\n   *\n   * @name ownProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.ownProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.ownProperty, true)\n      .to.have.own.property(prop);\n  };\n\n  /**\n   * ### .notOwnProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a direct property named by\n   * `property`. Inherited properties aren't checked.\n   *\n   *     assert.notOwnProperty({ tea: { green: 'matcha' }}, 'coffee');\n   *     assert.notOwnProperty({}, 'toString');\n   *\n   * @name notOwnProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notOwnProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.notOwnProperty, true)\n      .to.not.have.own.property(prop);\n  };\n\n  /**\n   * ### .ownPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a direct property named by `property` and a value\n   * equal to the provided `value`. Uses a strict equality check (===).\n   * Inherited properties aren't checked.\n   *\n   *     assert.ownPropertyVal({ coffee: 'is good'}, 'coffee', 'is good');\n   *\n   * @name ownPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.ownPropertyVal = function (obj, prop, value, msg) {\n    new Assertion(obj, msg, assert.ownPropertyVal, true)\n      .to.have.own.property(prop, value);\n  };\n\n  /**\n   * ### .notOwnPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a direct property named by `property`\n   * with a value equal to the provided `value`. Uses a strict equality check\n   * (===). Inherited properties aren't checked.\n   *\n   *     assert.notOwnPropertyVal({ tea: 'is better'}, 'tea', 'is worse');\n   *     assert.notOwnPropertyVal({}, 'toString', Object.prototype.toString);\n   *\n   * @name notOwnPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notOwnPropertyVal = function (obj, prop, value, msg) {\n    new Assertion(obj, msg, assert.notOwnPropertyVal, true)\n      .to.not.have.own.property(prop, value);\n  };\n\n  /**\n   * ### .deepOwnPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a direct property named by `property` and a value\n   * equal to the provided `value`. Uses a deep equality check. Inherited\n   * properties aren't checked.\n   *\n   *     assert.deepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });\n   *\n   * @name deepOwnPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.deepOwnPropertyVal = function (obj, prop, value, msg) {\n    new Assertion(obj, msg, assert.deepOwnPropertyVal, true)\n      .to.have.deep.own.property(prop, value);\n  };\n\n  /**\n   * ### .notDeepOwnPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a direct property named by `property`\n   * with a value equal to the provided `value`. Uses a deep equality check.\n   * Inherited properties aren't checked.\n   *\n   *     assert.notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });\n   *     assert.notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });\n   *     assert.notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });\n   *     assert.notDeepOwnPropertyVal({}, 'toString', Object.prototype.toString);\n   *\n   * @name notDeepOwnPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notDeepOwnPropertyVal = function (obj, prop, value, msg) {\n    new Assertion(obj, msg, assert.notDeepOwnPropertyVal, true)\n      .to.not.have.deep.own.property(prop, value);\n  };\n\n  /**\n   * ### .nestedProperty(object, property, [message])\n   *\n   * Asserts that `object` has a direct or inherited property named by\n   * `property`, which can be a string using dot- and bracket-notation for\n   * nested reference.\n   *\n   *     assert.nestedProperty({ tea: { green: 'matcha' }}, 'tea.green');\n   *\n   * @name nestedProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.nestedProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.nestedProperty, true)\n      .to.have.nested.property(prop);\n  };\n\n  /**\n   * ### .notNestedProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property`, which\n   * can be a string using dot- and bracket-notation for nested reference. The\n   * property cannot exist on the object nor anywhere in its prototype chain.\n   *\n   *     assert.notNestedProperty({ tea: { green: 'matcha' }}, 'tea.oolong');\n   *\n   * @name notNestedProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notNestedProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg, assert.notNestedProperty, true)\n      .to.not.have.nested.property(prop);\n  };\n\n  /**\n   * ### .nestedPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with value given\n   * by `value`. `property` can use dot- and bracket-notation for nested\n   * reference. Uses a strict equality check (===).\n   *\n   *     assert.nestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');\n   *\n   * @name nestedPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.nestedPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.nestedPropertyVal, true)\n      .to.have.nested.property(prop, val);\n  };\n\n  /**\n   * ### .notNestedPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property` with\n   * value given by `value`. `property` can use dot- and bracket-notation for\n   * nested reference. Uses a strict equality check (===).\n   *\n   *     assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');\n   *     assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'coffee.green', 'matcha');\n   *\n   * @name notNestedPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notNestedPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.notNestedPropertyVal, true)\n      .to.not.have.nested.property(prop, val);\n  };\n\n  /**\n   * ### .deepNestedPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with a value given\n   * by `value`. `property` can use dot- and bracket-notation for nested\n   * reference. Uses a deep equality check.\n   *\n   *     assert.deepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yum' });\n   *\n   * @name deepNestedPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepNestedPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.deepNestedPropertyVal, true)\n      .to.have.deep.nested.property(prop, val);\n  };\n\n  /**\n   * ### .notDeepNestedPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property` with\n   * value given by `value`. `property` can use dot- and bracket-notation for\n   * nested reference. Uses a deep equality check.\n   *\n   *     assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' });\n   *     assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' });\n   *     assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' });\n   *\n   * @name notDeepNestedPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepNestedPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg, assert.notDeepNestedPropertyVal, true)\n      .to.not.have.deep.nested.property(prop, val);\n  }\n\n  /**\n   * ### .lengthOf(object, length, [message])\n   *\n   * Asserts that `object` has a `length` or `size` with the expected value.\n   *\n   *     assert.lengthOf([1,2,3], 3, 'array has length of 3');\n   *     assert.lengthOf('foobar', 6, 'string has length of 6');\n   *     assert.lengthOf(new Set([1,2,3]), 3, 'set has size of 3');\n   *     assert.lengthOf(new Map([['a',1],['b',2],['c',3]]), 3, 'map has size of 3');\n   *\n   * @name lengthOf\n   * @param {Mixed} object\n   * @param {Number} length\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.lengthOf = function (exp, len, msg) {\n    new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);\n  };\n\n  /**\n   * ### .hasAnyKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has at least one of the `keys` provided.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'iDontExist', 'baz']);\n   *     assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, iDontExist: 99, baz: 1337});\n   *     assert.hasAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);\n   *     assert.hasAnyKeys(new Set([{foo: 'bar'}, 'anotherKey']), [{foo: 'bar'}, 'anotherKey']);\n   *\n   * @name hasAnyKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.hasAnyKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys);\n  }\n\n  /**\n   * ### .hasAllKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has all and only all of the `keys` provided.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);\n   *     assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337]);\n   *     assert.hasAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);\n   *     assert.hasAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);\n   *\n   * @name hasAllKeys\n   * @param {Mixed} object\n   * @param {String[]} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.hasAllKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys);\n  }\n\n  /**\n   * ### .containsAllKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has all of the `keys` provided but may have more keys not listed.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'baz']);\n   *     assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);\n   *     assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, baz: 1337});\n   *     assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337});\n   *     assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}]);\n   *     assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);\n   *     assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}]);\n   *     assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);\n   *\n   * @name containsAllKeys\n   * @param {Mixed} object\n   * @param {String[]} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.containsAllKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.containsAllKeys, true)\n      .to.contain.all.keys(keys);\n  }\n\n  /**\n   * ### .doesNotHaveAnyKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has none of the `keys` provided.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);\n   *     assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});\n   *     assert.doesNotHaveAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);\n   *     assert.doesNotHaveAnyKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);\n   *\n   * @name doesNotHaveAnyKeys\n   * @param {Mixed} object\n   * @param {String[]} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotHaveAnyKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true)\n      .to.not.have.any.keys(keys);\n  }\n\n  /**\n   * ### .doesNotHaveAllKeys(object, [keys], [message])\n   *\n   * Asserts that `object` does not have at least one of the `keys` provided.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);\n   *     assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});\n   *     assert.doesNotHaveAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);\n   *     assert.doesNotHaveAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);\n   *\n   * @name doesNotHaveAllKeys\n   * @param {Mixed} object\n   * @param {String[]} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotHaveAllKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.doesNotHaveAllKeys, true)\n      .to.not.have.all.keys(keys);\n  }\n\n  /**\n   * ### .hasAnyDeepKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has at least one of the `keys` provided.\n   * Since Sets and Maps can have objects as keys you can use this assertion to perform\n   * a deep comparison.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});\n   *     assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), [{one: 'one'}, {two: 'two'}]);\n   *     assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);\n   *     assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});\n   *     assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {three: 'three'}]);\n   *     assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);\n   *\n   * @name hasAnyDeepKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.hasAnyDeepKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.hasAnyDeepKeys, true)\n      .to.have.any.deep.keys(keys);\n  }\n\n /**\n   * ### .hasAllDeepKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has all and only all of the `keys` provided.\n   * Since Sets and Maps can have objects as keys you can use this assertion to perform\n   * a deep comparison.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne']]), {one: 'one'});\n   *     assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);\n   *     assert.hasAllDeepKeys(new Set([{one: 'one'}]), {one: 'one'});\n   *     assert.hasAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);\n   *\n   * @name hasAllDeepKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.hasAllDeepKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.hasAllDeepKeys, true)\n      .to.have.all.deep.keys(keys);\n  }\n\n /**\n   * ### .containsAllDeepKeys(object, [keys], [message])\n   *\n   * Asserts that `object` contains all of the `keys` provided.\n   * Since Sets and Maps can have objects as keys you can use this assertion to perform\n   * a deep comparison.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});\n   *     assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);\n   *     assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});\n   *     assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);\n   *\n   * @name containsAllDeepKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.containsAllDeepKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.containsAllDeepKeys, true)\n      .to.contain.all.deep.keys(keys);\n  }\n\n /**\n   * ### .doesNotHaveAnyDeepKeys(object, [keys], [message])\n   *\n   * Asserts that `object` has none of the `keys` provided.\n   * Since Sets and Maps can have objects as keys you can use this assertion to perform\n   * a deep comparison.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});\n   *     assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);\n   *     assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});\n   *     assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);\n   *\n   * @name doesNotHaveAnyDeepKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotHaveAnyDeepKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.doesNotHaveAnyDeepKeys, true)\n      .to.not.have.any.deep.keys(keys);\n  }\n\n /**\n   * ### .doesNotHaveAllDeepKeys(object, [keys], [message])\n   *\n   * Asserts that `object` does not have at least one of the `keys` provided.\n   * Since Sets and Maps can have objects as keys you can use this assertion to perform\n   * a deep comparison.\n   * You can also provide a single object instead of a `keys` array and its keys\n   * will be used as the expected set of keys.\n   *\n   *     assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});\n   *     assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {one: 'one'}]);\n   *     assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});\n   *     assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {fifty: 'fifty'}]);\n   *\n   * @name doesNotHaveAllDeepKeys\n   * @param {Mixed} object\n   * @param {Array|Object} keys\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotHaveAllDeepKeys = function (obj, keys, msg) {\n    new Assertion(obj, msg, assert.doesNotHaveAllDeepKeys, true)\n      .to.not.have.all.deep.keys(keys);\n  }\n\n /**\n   * ### .throws(fn, [errorLike/string/regexp], [string/regexp], [message])\n   *\n   * If `errorLike` is an `Error` constructor, asserts that `fn` will throw an error that is an\n   * instance of `errorLike`.\n   * If `errorLike` is an `Error` instance, asserts that the error thrown is the same\n   * instance as `errorLike`.\n   * If `errMsgMatcher` is provided, it also asserts that the error thrown will have a\n   * message matching `errMsgMatcher`.\n   *\n   *     assert.throws(fn, 'Error thrown must have this msg');\n   *     assert.throws(fn, /Error thrown must have a msg that matches this/);\n   *     assert.throws(fn, ReferenceError);\n   *     assert.throws(fn, errorInstance);\n   *     assert.throws(fn, ReferenceError, 'Error thrown must be a ReferenceError and have this msg');\n   *     assert.throws(fn, errorInstance, 'Error thrown must be the same errorInstance and have this msg');\n   *     assert.throws(fn, ReferenceError, /Error thrown must be a ReferenceError and match this/);\n   *     assert.throws(fn, errorInstance, /Error thrown must be the same errorInstance and match this/);\n   *\n   * @name throws\n   * @alias throw\n   * @alias Throw\n   * @param {Function} fn\n   * @param {ErrorConstructor|Error} errorLike\n   * @param {RegExp|String} errMsgMatcher\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.throws = function (fn, errorLike, errMsgMatcher, msg) {\n    if ('string' === typeof errorLike || errorLike instanceof RegExp) {\n      errMsgMatcher = errorLike;\n      errorLike = null;\n    }\n\n    var assertErr = new Assertion(fn, msg, assert.throws, true)\n      .to.throw(errorLike, errMsgMatcher);\n    return flag(assertErr, 'object');\n  };\n\n  /**\n   * ### .doesNotThrow(fn, [errorLike/string/regexp], [string/regexp], [message])\n   *\n   * If `errorLike` is an `Error` constructor, asserts that `fn` will _not_ throw an error that is an\n   * instance of `errorLike`.\n   * If `errorLike` is an `Error` instance, asserts that the error thrown is _not_ the same\n   * instance as `errorLike`.\n   * If `errMsgMatcher` is provided, it also asserts that the error thrown will _not_ have a\n   * message matching `errMsgMatcher`.\n   *\n   *     assert.doesNotThrow(fn, 'Any Error thrown must not have this message');\n   *     assert.doesNotThrow(fn, /Any Error thrown must not match this/);\n   *     assert.doesNotThrow(fn, Error);\n   *     assert.doesNotThrow(fn, errorInstance);\n   *     assert.doesNotThrow(fn, Error, 'Error must not have this message');\n   *     assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');\n   *     assert.doesNotThrow(fn, Error, /Error must not match this/);\n   *     assert.doesNotThrow(fn, errorInstance, /Error must not match this/);\n   *\n   * @name doesNotThrow\n   * @param {Function} fn\n   * @param {ErrorConstructor} errorLike\n   * @param {RegExp|String} errMsgMatcher\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotThrow = function (fn, errorLike, errMsgMatcher, msg) {\n    if ('string' === typeof errorLike || errorLike instanceof RegExp) {\n      errMsgMatcher = errorLike;\n      errorLike = null;\n    }\n\n    new Assertion(fn, msg, assert.doesNotThrow, true)\n      .to.not.throw(errorLike, errMsgMatcher);\n  };\n\n  /**\n   * ### .operator(val1, operator, val2, [message])\n   *\n   * Compares two values using `operator`.\n   *\n   *     assert.operator(1, '<', 2, 'everything is ok');\n   *     assert.operator(1, '>', 2, 'this will fail');\n   *\n   * @name operator\n   * @param {Mixed} val1\n   * @param {String} operator\n   * @param {Mixed} val2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.operator = function (val, operator, val2, msg) {\n    var ok;\n    switch(operator) {\n      case '==':\n        ok = val == val2;\n        break;\n      case '===':\n        ok = val === val2;\n        break;\n      case '>':\n        ok = val > val2;\n        break;\n      case '>=':\n        ok = val >= val2;\n        break;\n      case '<':\n        ok = val < val2;\n        break;\n      case '<=':\n        ok = val <= val2;\n        break;\n      case '!=':\n        ok = val != val2;\n        break;\n      case '!==':\n        ok = val !== val2;\n        break;\n      default:\n        msg = msg ? msg + ': ' : msg;\n        throw new chai.AssertionError(\n          msg + 'Invalid operator \"' + operator + '\"',\n          undefined,\n          assert.operator\n        );\n    }\n    var test = new Assertion(ok, msg, assert.operator, true);\n    test.assert(\n        true === flag(test, 'object')\n      , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)\n      , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );\n  };\n\n  /**\n   * ### .closeTo(actual, expected, delta, [message])\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');\n   *\n   * @name closeTo\n   * @param {Number} actual\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.closeTo = function (act, exp, delta, msg) {\n    new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);\n  };\n\n  /**\n   * ### .approximately(actual, expected, delta, [message])\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     assert.approximately(1.5, 1, 0.5, 'numbers are close');\n   *\n   * @name approximately\n   * @param {Number} actual\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.approximately = function (act, exp, delta, msg) {\n    new Assertion(act, msg, assert.approximately, true)\n      .to.be.approximately(exp, delta);\n  };\n\n  /**\n   * ### .sameMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members in any order. Uses a\n   * strict equality check (===).\n   *\n   *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');\n   *\n   * @name sameMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.sameMembers, true)\n      .to.have.same.members(set2);\n  }\n\n  /**\n   * ### .notSameMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` don't have the same members in any order.\n   * Uses a strict equality check (===).\n   *\n   *     assert.notSameMembers([ 1, 2, 3 ], [ 5, 1, 3 ], 'not same members');\n   *\n   * @name notSameMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notSameMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.notSameMembers, true)\n      .to.not.have.same.members(set2);\n  }\n\n  /**\n   * ### .sameDeepMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members in any order. Uses a\n   * deep equality check.\n   *\n   *     assert.sameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members');\n   *\n   * @name sameDeepMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameDeepMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.sameDeepMembers, true)\n      .to.have.same.deep.members(set2);\n  }\n\n  /**\n   * ### .notSameDeepMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` don't have the same members in any order.\n   * Uses a deep equality check.\n   *\n   *     assert.notSameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { f: 5 }], 'not same deep members');\n   *\n   * @name notSameDeepMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notSameDeepMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.notSameDeepMembers, true)\n      .to.not.have.same.deep.members(set2);\n  }\n\n  /**\n   * ### .sameOrderedMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members in the same order.\n   * Uses a strict equality check (===).\n   *\n   *     assert.sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');\n   *\n   * @name sameOrderedMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameOrderedMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.sameOrderedMembers, true)\n      .to.have.same.ordered.members(set2);\n  }\n\n  /**\n   * ### .notSameOrderedMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` don't have the same members in the same\n   * order. Uses a strict equality check (===).\n   *\n   *     assert.notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');\n   *\n   * @name notSameOrderedMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notSameOrderedMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.notSameOrderedMembers, true)\n      .to.not.have.same.ordered.members(set2);\n  }\n\n  /**\n   * ### .sameDeepOrderedMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members in the same order.\n   * Uses a deep equality check.\n   *\n   *     assert.sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');\n   *\n   * @name sameDeepOrderedMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameDeepOrderedMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.sameDeepOrderedMembers, true)\n      .to.have.same.deep.ordered.members(set2);\n  }\n\n  /**\n   * ### .notSameDeepOrderedMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` don't have the same members in the same\n   * order. Uses a deep equality check.\n   *\n   *     assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { z: 5 } ], 'not same deep ordered members');\n   *     assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');\n   *\n   * @name notSameDeepOrderedMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notSameDeepOrderedMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg, assert.notSameDeepOrderedMembers, true)\n      .to.not.have.same.deep.ordered.members(set2);\n  }\n\n  /**\n   * ### .includeMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset` in any order. Uses a\n   * strict equality check (===). Duplicates are ignored.\n   *\n   *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1, 2 ], 'include members');\n   *\n   * @name includeMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.includeMembers, true)\n      .to.include.members(subset);\n  }\n\n  /**\n   * ### .notIncludeMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` isn't included in `superset` in any order. Uses a\n   * strict equality check (===). Duplicates are ignored.\n   *\n   *     assert.notIncludeMembers([ 1, 2, 3 ], [ 5, 1 ], 'not include members');\n   *\n   * @name notIncludeMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notIncludeMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.notIncludeMembers, true)\n      .to.not.include.members(subset);\n  }\n\n  /**\n   * ### .includeDeepMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset` in any order. Uses a deep\n   * equality check. Duplicates are ignored.\n   *\n   *     assert.includeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { b: 2 } ], 'include deep members');\n   *\n   * @name includeDeepMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeDeepMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.includeDeepMembers, true)\n      .to.include.deep.members(subset);\n  }\n\n  /**\n   * ### .notIncludeDeepMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` isn't included in `superset` in any order. Uses a\n   * deep equality check. Duplicates are ignored.\n   *\n   *     assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');\n   *\n   * @name notIncludeDeepMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notIncludeDeepMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.notIncludeDeepMembers, true)\n      .to.not.include.deep.members(subset);\n  }\n\n  /**\n   * ### .includeOrderedMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset` in the same order\n   * beginning with the first element in `superset`. Uses a strict equality\n   * check (===).\n   *\n   *     assert.includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');\n   *\n   * @name includeOrderedMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeOrderedMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.includeOrderedMembers, true)\n      .to.include.ordered.members(subset);\n  }\n\n  /**\n   * ### .notIncludeOrderedMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` isn't included in `superset` in the same order\n   * beginning with the first element in `superset`. Uses a strict equality\n   * check (===).\n   *\n   *     assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');\n   *     assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 3 ], 'not include ordered members');\n   *\n   * @name notIncludeOrderedMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notIncludeOrderedMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.notIncludeOrderedMembers, true)\n      .to.not.include.ordered.members(subset);\n  }\n\n  /**\n   * ### .includeDeepOrderedMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset` in the same order\n   * beginning with the first element in `superset`. Uses a deep equality\n   * check.\n   *\n   *     assert.includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');\n   *\n   * @name includeDeepOrderedMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeDeepOrderedMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.includeDeepOrderedMembers, true)\n      .to.include.deep.ordered.members(subset);\n  }\n\n  /**\n   * ### .notIncludeDeepOrderedMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` isn't included in `superset` in the same order\n   * beginning with the first element in `superset`. Uses a deep equality\n   * check.\n   *\n   *     assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { f: 5 } ], 'not include deep ordered members');\n   *     assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 } ], 'not include deep ordered members');\n   *     assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { c: 3 } ], 'not include deep ordered members');\n   *\n   * @name notIncludeDeepOrderedMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notIncludeDeepOrderedMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg, assert.notIncludeDeepOrderedMembers, true)\n      .to.not.include.deep.ordered.members(subset);\n  }\n\n  /**\n   * ### .oneOf(inList, list, [message])\n   *\n   * Asserts that non-object, non-array value `inList` appears in the flat array `list`.\n   *\n   *     assert.oneOf(1, [ 2, 1 ], 'Not found in list');\n   *\n   * @name oneOf\n   * @param {*} inList\n   * @param {Array<*>} list\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.oneOf = function (inList, list, msg) {\n    new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);\n  }\n\n  /**\n   * ### .changes(function, object, property, [message])\n   *\n   * Asserts that a function changes the value of a property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 22 };\n   *     assert.changes(fn, obj, 'val');\n   *\n   * @name changes\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.changes = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.changes, true).to.change(obj, prop);\n  }\n\n   /**\n   * ### .changesBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function changes the value of a property by an amount (delta).\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val += 2 };\n   *     assert.changesBy(fn, obj, 'val', 2);\n   *\n   * @name changesBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.changesBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.changesBy, true)\n      .to.change(obj, prop).by(delta);\n  }\n\n   /**\n   * ### .doesNotChange(function, object, property, [message])\n   *\n   * Asserts that a function does not change the value of a property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { console.log('foo'); };\n   *     assert.doesNotChange(fn, obj, 'val');\n   *\n   * @name doesNotChange\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotChange = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.doesNotChange, true)\n      .to.not.change(obj, prop);\n  }\n\n  /**\n   * ### .changesButNotBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function does not change the value of a property or of a function's return value by an amount (delta)\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val += 10 };\n   *     assert.changesButNotBy(fn, obj, 'val', 5);\n   *\n   * @name changesButNotBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.changesButNotBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.changesButNotBy, true)\n      .to.change(obj, prop).but.not.by(delta);\n  }\n\n  /**\n   * ### .increases(function, object, property, [message])\n   *\n   * Asserts that a function increases a numeric object property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 13 };\n   *     assert.increases(fn, obj, 'val');\n   *\n   * @name increases\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.increases = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.increases, true)\n      .to.increase(obj, prop);\n  }\n\n  /**\n   * ### .increasesBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function increases a numeric object property or a function's return value by an amount (delta).\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val += 10 };\n   *     assert.increasesBy(fn, obj, 'val', 10);\n   *\n   * @name increasesBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.increasesBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.increasesBy, true)\n      .to.increase(obj, prop).by(delta);\n  }\n\n  /**\n   * ### .doesNotIncrease(function, object, property, [message])\n   *\n   * Asserts that a function does not increase a numeric object property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 8 };\n   *     assert.doesNotIncrease(fn, obj, 'val');\n   *\n   * @name doesNotIncrease\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotIncrease = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.doesNotIncrease, true)\n      .to.not.increase(obj, prop);\n  }\n\n  /**\n   * ### .increasesButNotBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function does not increase a numeric object property or function's return value by an amount (delta).\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     assert.increasesButNotBy(fn, obj, 'val', 10);\n   *\n   * @name increasesButNotBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.increasesButNotBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.increasesButNotBy, true)\n      .to.increase(obj, prop).but.not.by(delta);\n  }\n\n  /**\n   * ### .decreases(function, object, property, [message])\n   *\n   * Asserts that a function decreases a numeric object property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     assert.decreases(fn, obj, 'val');\n   *\n   * @name decreases\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.decreases = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.decreases, true)\n      .to.decrease(obj, prop);\n  }\n\n  /**\n   * ### .decreasesBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function decreases a numeric object property or a function's return value by an amount (delta)\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val -= 5 };\n   *     assert.decreasesBy(fn, obj, 'val', 5);\n   *\n   * @name decreasesBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.decreasesBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.decreasesBy, true)\n      .to.decrease(obj, prop).by(delta);\n  }\n\n  /**\n   * ### .doesNotDecrease(function, object, property, [message])\n   *\n   * Asserts that a function does not decreases a numeric object property.\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     assert.doesNotDecrease(fn, obj, 'val');\n   *\n   * @name doesNotDecrease\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotDecrease = function (fn, obj, prop, msg) {\n    if (arguments.length === 3 && typeof obj === 'function') {\n      msg = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.doesNotDecrease, true)\n      .to.not.decrease(obj, prop);\n  }\n\n  /**\n   * ### .doesNotDecreaseBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     assert.doesNotDecreaseBy(fn, obj, 'val', 1);\n   *\n   * @name doesNotDecreaseBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotDecreaseBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    return new Assertion(fn, msg, assert.doesNotDecreaseBy, true)\n      .to.not.decrease(obj, prop).by(delta);\n  }\n\n  /**\n   * ### .decreasesButNotBy(function, object, property, delta, [message])\n   *\n   * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     assert.decreasesButNotBy(fn, obj, 'val', 1);\n   *\n   * @name decreasesButNotBy\n   * @param {Function} modifier function\n   * @param {Object} object or getter function\n   * @param {String} property name _optional_\n   * @param {Number} change amount (delta)\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.decreasesButNotBy = function (fn, obj, prop, delta, msg) {\n    if (arguments.length === 4 && typeof obj === 'function') {\n      var tmpMsg = delta;\n      delta = prop;\n      msg = tmpMsg;\n    } else if (arguments.length === 3) {\n      delta = prop;\n      prop = null;\n    }\n\n    new Assertion(fn, msg, assert.decreasesButNotBy, true)\n      .to.decrease(obj, prop).but.not.by(delta);\n  }\n\n  /*!\n   * ### .ifError(object)\n   *\n   * Asserts if value is not a false value, and throws if it is a true value.\n   * This is added to allow for chai to be a drop-in replacement for Node's\n   * assert class.\n   *\n   *     var err = new Error('I am a custom error');\n   *     assert.ifError(err); // Rethrows err!\n   *\n   * @name ifError\n   * @param {Object} object\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.ifError = function (val) {\n    if (val) {\n      throw(val);\n    }\n  };\n\n  /**\n   * ### .isExtensible(object)\n   *\n   * Asserts that `object` is extensible (can have new properties added to it).\n   *\n   *     assert.isExtensible({});\n   *\n   * @name isExtensible\n   * @alias extensible\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isExtensible = function (obj, msg) {\n    new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;\n  };\n\n  /**\n   * ### .isNotExtensible(object)\n   *\n   * Asserts that `object` is _not_ extensible.\n   *\n   *     var nonExtensibleObject = Object.preventExtensions({});\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.freeze({});\n   *\n   *     assert.isNotExtensible(nonExtensibleObject);\n   *     assert.isNotExtensible(sealedObject);\n   *     assert.isNotExtensible(frozenObject);\n   *\n   * @name isNotExtensible\n   * @alias notExtensible\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotExtensible = function (obj, msg) {\n    new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;\n  };\n\n  /**\n   * ### .isSealed(object)\n   *\n   * Asserts that `object` is sealed (cannot have new properties added to it\n   * and its existing properties cannot be removed).\n   *\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.seal({});\n   *\n   *     assert.isSealed(sealedObject);\n   *     assert.isSealed(frozenObject);\n   *\n   * @name isSealed\n   * @alias sealed\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isSealed = function (obj, msg) {\n    new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;\n  };\n\n  /**\n   * ### .isNotSealed(object)\n   *\n   * Asserts that `object` is _not_ sealed.\n   *\n   *     assert.isNotSealed({});\n   *\n   * @name isNotSealed\n   * @alias notSealed\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotSealed = function (obj, msg) {\n    new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;\n  };\n\n  /**\n   * ### .isFrozen(object)\n   *\n   * Asserts that `object` is frozen (cannot have new properties added to it\n   * and its existing properties cannot be modified).\n   *\n   *     var frozenObject = Object.freeze({});\n   *     assert.frozen(frozenObject);\n   *\n   * @name isFrozen\n   * @alias frozen\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFrozen = function (obj, msg) {\n    new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;\n  };\n\n  /**\n   * ### .isNotFrozen(object)\n   *\n   * Asserts that `object` is _not_ frozen.\n   *\n   *     assert.isNotFrozen({});\n   *\n   * @name isNotFrozen\n   * @alias notFrozen\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFrozen = function (obj, msg) {\n    new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;\n  };\n\n  /**\n   * ### .isEmpty(target)\n   *\n   * Asserts that the target does not contain any values.\n   * For arrays and strings, it checks the `length` property.\n   * For `Map` and `Set` instances, it checks the `size` property.\n   * For non-function objects, it gets the count of own\n   * enumerable string keys.\n   *\n   *     assert.isEmpty([]);\n   *     assert.isEmpty('');\n   *     assert.isEmpty(new Map);\n   *     assert.isEmpty({});\n   *\n   * @name isEmpty\n   * @alias empty\n   * @param {Object|Array|String|Map|Set} target\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isEmpty = function(val, msg) {\n    new Assertion(val, msg, assert.isEmpty, true).to.be.empty;\n  };\n\n  /**\n   * ### .isNotEmpty(target)\n   *\n   * Asserts that the target contains values.\n   * For arrays and strings, it checks the `length` property.\n   * For `Map` and `Set` instances, it checks the `size` property.\n   * For non-function objects, it gets the count of own\n   * enumerable string keys.\n   *\n   *     assert.isNotEmpty([1, 2]);\n   *     assert.isNotEmpty('34');\n   *     assert.isNotEmpty(new Set([5, 6]));\n   *     assert.isNotEmpty({ key: 7 });\n   *\n   * @name isNotEmpty\n   * @alias notEmpty\n   * @param {Object|Array|String|Map|Set} target\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotEmpty = function(val, msg) {\n    new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;\n  };\n\n  /*!\n   * Aliases.\n   */\n\n  (function alias(name, as){\n    assert[as] = assert[name];\n    return alias;\n  })\n  ('isOk', 'ok')\n  ('isNotOk', 'notOk')\n  ('throws', 'throw')\n  ('throws', 'Throw')\n  ('isExtensible', 'extensible')\n  ('isNotExtensible', 'notExtensible')\n  ('isSealed', 'sealed')\n  ('isNotSealed', 'notSealed')\n  ('isFrozen', 'frozen')\n  ('isNotFrozen', 'notFrozen')\n  ('isEmpty', 'empty')\n  ('isNotEmpty', 'notEmpty');\n};\n"],"names":["assert","chai","util","Assertion","flag","express","errmsg","fail","actual","expected","message","operator","arguments","length","undefined","AssertionError","isOk","val","msg","is","ok","isNotOk","not","equal","act","exp","test","notEqual","strictEqual","to","notStrictEqual","deepEqual","deepStrictEqual","eql","notDeepEqual","isAbove","abv","be","above","isAtLeast","atlst","least","isBelow","blw","below","isAtMost","atmst","most","isTrue","isNotTrue","isFalse","isNotFalse","isNull","isNotNull","isNaN","NaN","isNotNaN","exists","exist","notExists","isUndefined","isDefined","isFunction","a","isNotFunction","isObject","isNotObject","isArray","an","isNotArray","isString","isNotString","isNumber","isNotNumber","isFinite","finite","isBoolean","isNotBoolean","typeOf","type","notTypeOf","instanceOf","notInstanceOf","include","inc","notInclude","deepInclude","deep","notDeepInclude","nestedInclude","nested","notNestedInclude","deepNestedInclude","notDeepNestedInclude","ownInclude","own","notOwnInclude","deepOwnInclude","notDeepOwnInclude","match","re","notMatch","property","obj","prop","have","notProperty","propertyVal","notPropertyVal","deepPropertyVal","notDeepPropertyVal","ownProperty","notOwnProperty","ownPropertyVal","value","notOwnPropertyVal","deepOwnPropertyVal","notDeepOwnPropertyVal","nestedProperty","notNestedProperty","nestedPropertyVal","notNestedPropertyVal","deepNestedPropertyVal","notDeepNestedPropertyVal","lengthOf","len","hasAnyKeys","keys","any","hasAllKeys","all","containsAllKeys","contain","doesNotHaveAnyKeys","doesNotHaveAllKeys","hasAnyDeepKeys","hasAllDeepKeys","containsAllDeepKeys","doesNotHaveAnyDeepKeys","doesNotHaveAllDeepKeys","throws","fn","errorLike","errMsgMatcher","RegExp","assertErr","throw","doesNotThrow","val2","inspect","closeTo","delta","approximately","sameMembers","set1","set2","same","members","notSameMembers","sameDeepMembers","notSameDeepMembers","sameOrderedMembers","ordered","notSameOrderedMembers","sameDeepOrderedMembers","notSameDeepOrderedMembers","includeMembers","superset","subset","notIncludeMembers","includeDeepMembers","notIncludeDeepMembers","includeOrderedMembers","notIncludeOrderedMembers","includeDeepOrderedMembers","notIncludeDeepOrderedMembers","oneOf","inList","list","changes","change","changesBy","tmpMsg","by","doesNotChange","changesButNotBy","but","increases","increase","increasesBy","doesNotIncrease","increasesButNotBy","decreases","decrease","decreasesBy","doesNotDecrease","doesNotDecreaseBy","decreasesButNotBy","ifError","isExtensible","extensible","isNotExtensible","isSealed","sealed","isNotSealed","isFrozen","frozen","isNotFrozen","isEmpty","empty","isNotEmpty","alias","name","as"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/chai@4.5.0/node_modules/chai/lib/chai/interface/assert.esm.js

@@ -0,0 +1,34 @@
+/*!
+ * chai
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+var e,n;function requireAssert(){return n||(n=1,e=function(e,n){
+/*!
+	   * Chai dependencies.
+	   */
+var t=e.Assertion,o=n.flag,s=e.assert=function(n,o){new t(null,null,e.assert,!0).assert(n,o,"[ negation message unavailable ]")};
+/*!
+	   * Module export.
+	   */s.fail=function(n,t,o,r){throw arguments.length<2&&(o=n,n=void 0),o=o||"assert.fail()",new e.AssertionError(o,{actual:n,expected:t,operator:r},s.fail)},s.isOk=function(e,n){new t(e,n,s.isOk,!0).is.ok},s.isNotOk=function(e,n){new t(e,n,s.isNotOk,!0).is.not.ok},s.equal=function(e,n,r){var i=new t(e,r,s.equal,!0);i.assert(n==o(i,"object"),"expected #{this} to equal #{exp}","expected #{this} to not equal #{act}",n,e,!0)},s.notEqual=function(e,n,r){var i=new t(e,r,s.notEqual,!0);i.assert(n!=o(i,"object"),"expected #{this} to not equal #{exp}","expected #{this} to equal #{act}",n,e,!0)},s.strictEqual=function(e,n,o){new t(e,o,s.strictEqual,!0).to.equal(n)},s.notStrictEqual=function(e,n,o){new t(e,o,s.notStrictEqual,!0).to.not.equal(n)},s.deepEqual=s.deepStrictEqual=function(e,n,o){new t(e,o,s.deepEqual,!0).to.eql(n)},s.notDeepEqual=function(e,n,o){new t(e,o,s.notDeepEqual,!0).to.not.eql(n)},s.isAbove=function(e,n,o){new t(e,o,s.isAbove,!0).to.be.above(n)},s.isAtLeast=function(e,n,o){new t(e,o,s.isAtLeast,!0).to.be.least(n)},s.isBelow=function(e,n,o){new t(e,o,s.isBelow,!0).to.be.below(n)},s.isAtMost=function(e,n,o){new t(e,o,s.isAtMost,!0).to.be.most(n)},s.isTrue=function(e,n){new t(e,n,s.isTrue,!0).is.true},s.isNotTrue=function(e,n){new t(e,n,s.isNotTrue,!0).to.not.equal(!0)},s.isFalse=function(e,n){new t(e,n,s.isFalse,!0).is.false},s.isNotFalse=function(e,n){new t(e,n,s.isNotFalse,!0).to.not.equal(!1)},s.isNull=function(e,n){new t(e,n,s.isNull,!0).to.equal(null)},s.isNotNull=function(e,n){new t(e,n,s.isNotNull,!0).to.not.equal(null)},s.isNaN=function(e,n){new t(e,n,s.isNaN,!0).to.be.NaN},s.isNotNaN=function(e,n){new t(e,n,s.isNotNaN,!0).not.to.be.NaN},s.exists=function(e,n){new t(e,n,s.exists,!0).to.exist},s.notExists=function(e,n){new t(e,n,s.notExists,!0).to.not.exist},s.isUndefined=function(e,n){new t(e,n,s.isUndefined,!0).to.equal(void 0)},s.isDefined=function(e,n){new t(e,n,s.isDefined,!0).to.not.equal(void 0)},s.isFunction=function(e,n){new t(e,n,s.isFunction,!0).to.be.a("function")},s.isNotFunction=function(e,n){new t(e,n,s.isNotFunction,!0).to.not.be.a("function")},s.isObject=function(e,n){new t(e,n,s.isObject,!0).to.be.a("object")},s.isNotObject=function(e,n){new t(e,n,s.isNotObject,!0).to.not.be.a("object")},s.isArray=function(e,n){new t(e,n,s.isArray,!0).to.be.an("array")},s.isNotArray=function(e,n){new t(e,n,s.isNotArray,!0).to.not.be.an("array")},s.isString=function(e,n){new t(e,n,s.isString,!0).to.be.a("string")},s.isNotString=function(e,n){new t(e,n,s.isNotString,!0).to.not.be.a("string")},s.isNumber=function(e,n){new t(e,n,s.isNumber,!0).to.be.a("number")},s.isNotNumber=function(e,n){new t(e,n,s.isNotNumber,!0).to.not.be.a("number")},s.isFinite=function(e,n){new t(e,n,s.isFinite,!0).to.be.finite},s.isBoolean=function(e,n){new t(e,n,s.isBoolean,!0).to.be.a("boolean")},s.isNotBoolean=function(e,n){new t(e,n,s.isNotBoolean,!0).to.not.be.a("boolean")},s.typeOf=function(e,n,o){new t(e,o,s.typeOf,!0).to.be.a(n)},s.notTypeOf=function(e,n,o){new t(e,o,s.notTypeOf,!0).to.not.be.a(n)},s.instanceOf=function(e,n,o){new t(e,o,s.instanceOf,!0).to.be.instanceOf(n)},s.notInstanceOf=function(e,n,o){new t(e,o,s.notInstanceOf,!0).to.not.be.instanceOf(n)},s.include=function(e,n,o){new t(e,o,s.include,!0).include(n)},s.notInclude=function(e,n,o){new t(e,o,s.notInclude,!0).not.include(n)},s.deepInclude=function(e,n,o){new t(e,o,s.deepInclude,!0).deep.include(n)},s.notDeepInclude=function(e,n,o){new t(e,o,s.notDeepInclude,!0).not.deep.include(n)},s.nestedInclude=function(e,n,o){new t(e,o,s.nestedInclude,!0).nested.include(n)},s.notNestedInclude=function(e,n,o){new t(e,o,s.notNestedInclude,!0).not.nested.include(n)},s.deepNestedInclude=function(e,n,o){new t(e,o,s.deepNestedInclude,!0).deep.nested.include(n)},s.notDeepNestedInclude=function(e,n,o){new t(e,o,s.notDeepNestedInclude,!0).not.deep.nested.include(n)},s.ownInclude=function(e,n,o){new t(e,o,s.ownInclude,!0).own.include(n)},s.notOwnInclude=function(e,n,o){new t(e,o,s.notOwnInclude,!0).not.own.include(n)},s.deepOwnInclude=function(e,n,o){new t(e,o,s.deepOwnInclude,!0).deep.own.include(n)},s.notDeepOwnInclude=function(e,n,o){new t(e,o,s.notDeepOwnInclude,!0).not.deep.own.include(n)},s.match=function(e,n,o){new t(e,o,s.match,!0).to.match(n)},s.notMatch=function(e,n,o){new t(e,o,s.notMatch,!0).to.not.match(n)},s.property=function(e,n,o){new t(e,o,s.property,!0).to.have.property(n)},s.notProperty=function(e,n,o){new t(e,o,s.notProperty,!0).to.not.have.property(n)},s.propertyVal=function(e,n,o,r){new t(e,r,s.propertyVal,!0).to.have.property(n,o)},s.notPropertyVal=function(e,n,o,r){new t(e,r,s.notPropertyVal,!0).to.not.have.property(n,o)},s.deepPropertyVal=function(e,n,o,r){new t(e,r,s.deepPropertyVal,!0).to.have.deep.property(n,o)},s.notDeepPropertyVal=function(e,n,o,r){new t(e,r,s.notDeepPropertyVal,!0).to.not.have.deep.property(n,o)},s.ownProperty=function(e,n,o){new t(e,o,s.ownProperty,!0).to.have.own.property(n)},s.notOwnProperty=function(e,n,o){new t(e,o,s.notOwnProperty,!0).to.not.have.own.property(n)},s.ownPropertyVal=function(e,n,o,r){new t(e,r,s.ownPropertyVal,!0).to.have.own.property(n,o)},s.notOwnPropertyVal=function(e,n,o,r){new t(e,r,s.notOwnPropertyVal,!0).to.not.have.own.property(n,o)},s.deepOwnPropertyVal=function(e,n,o,r){new t(e,r,s.deepOwnPropertyVal,!0).to.have.deep.own.property(n,o)},s.notDeepOwnPropertyVal=function(e,n,o,r){new t(e,r,s.notDeepOwnPropertyVal,!0).to.not.have.deep.own.property(n,o)},s.nestedProperty=function(e,n,o){new t(e,o,s.nestedProperty,!0).to.have.nested.property(n)},s.notNestedProperty=function(e,n,o){new t(e,o,s.notNestedProperty,!0).to.not.have.nested.property(n)},s.nestedPropertyVal=function(e,n,o,r){new t(e,r,s.nestedPropertyVal,!0).to.have.nested.property(n,o)},s.notNestedPropertyVal=function(e,n,o,r){new t(e,r,s.notNestedPropertyVal,!0).to.not.have.nested.property(n,o)},s.deepNestedPropertyVal=function(e,n,o,r){new t(e,r,s.deepNestedPropertyVal,!0).to.have.deep.nested.property(n,o)},s.notDeepNestedPropertyVal=function(e,n,o,r){new t(e,r,s.notDeepNestedPropertyVal,!0).to.not.have.deep.nested.property(n,o)},s.lengthOf=function(e,n,o){new t(e,o,s.lengthOf,!0).to.have.lengthOf(n)},s.hasAnyKeys=function(e,n,o){new t(e,o,s.hasAnyKeys,!0).to.have.any.keys(n)},s.hasAllKeys=function(e,n,o){new t(e,o,s.hasAllKeys,!0).to.have.all.keys(n)},s.containsAllKeys=function(e,n,o){new t(e,o,s.containsAllKeys,!0).to.contain.all.keys(n)},s.doesNotHaveAnyKeys=function(e,n,o){new t(e,o,s.doesNotHaveAnyKeys,!0).to.not.have.any.keys(n)},s.doesNotHaveAllKeys=function(e,n,o){new t(e,o,s.doesNotHaveAllKeys,!0).to.not.have.all.keys(n)},s.hasAnyDeepKeys=function(e,n,o){new t(e,o,s.hasAnyDeepKeys,!0).to.have.any.deep.keys(n)},s.hasAllDeepKeys=function(e,n,o){new t(e,o,s.hasAllDeepKeys,!0).to.have.all.deep.keys(n)},s.containsAllDeepKeys=function(e,n,o){new t(e,o,s.containsAllDeepKeys,!0).to.contain.all.deep.keys(n)},s.doesNotHaveAnyDeepKeys=function(e,n,o){new t(e,o,s.doesNotHaveAnyDeepKeys,!0).to.not.have.any.deep.keys(n)},s.doesNotHaveAllDeepKeys=function(e,n,o){new t(e,o,s.doesNotHaveAllDeepKeys,!0).to.not.have.all.deep.keys(n)},s.throws=function(e,n,r,i){("string"==typeof n||n instanceof RegExp)&&(r=n,n=null);var a=new t(e,i,s.throws,!0).to.throw(n,r);return o(a,"object")},s.doesNotThrow=function(e,n,o,r){("string"==typeof n||n instanceof RegExp)&&(o=n,n=null),new t(e,r,s.doesNotThrow,!0).to.not.throw(n,o)},s.operator=function(r,i,a,c){var u;switch(i){case"==":u=r==a;break;case"===":u=r===a;break;case">":u=r>a;break;case">=":u=r>=a;break;case"<":u=r<a;break;case"<=":u=r<=a;break;case"!=":u=r!=a;break;case"!==":u=r!==a;break;default:throw c=c?c+": ":c,new e.AssertionError(c+'Invalid operator "'+i+'"',void 0,s.operator)}var l=new t(u,c,s.operator,!0);l.assert(!0===o(l,"object"),"expected "+n.inspect(r)+" to be "+i+" "+n.inspect(a),"expected "+n.inspect(r)+" to not be "+i+" "+n.inspect(a))},s.closeTo=function(e,n,o,r){new t(e,r,s.closeTo,!0).to.be.closeTo(n,o)},s.approximately=function(e,n,o,r){new t(e,r,s.approximately,!0).to.be.approximately(n,o)},s.sameMembers=function(e,n,o){new t(e,o,s.sameMembers,!0).to.have.same.members(n)},s.notSameMembers=function(e,n,o){new t(e,o,s.notSameMembers,!0).to.not.have.same.members(n)},s.sameDeepMembers=function(e,n,o){new t(e,o,s.sameDeepMembers,!0).to.have.same.deep.members(n)},s.notSameDeepMembers=function(e,n,o){new t(e,o,s.notSameDeepMembers,!0).to.not.have.same.deep.members(n)},s.sameOrderedMembers=function(e,n,o){new t(e,o,s.sameOrderedMembers,!0).to.have.same.ordered.members(n)},s.notSameOrderedMembers=function(e,n,o){new t(e,o,s.notSameOrderedMembers,!0).to.not.have.same.ordered.members(n)},s.sameDeepOrderedMembers=function(e,n,o){new t(e,o,s.sameDeepOrderedMembers,!0).to.have.same.deep.ordered.members(n)},s.notSameDeepOrderedMembers=function(e,n,o){new t(e,o,s.notSameDeepOrderedMembers,!0).to.not.have.same.deep.ordered.members(n)},s.includeMembers=function(e,n,o){new t(e,o,s.includeMembers,!0).to.include.members(n)},s.notIncludeMembers=function(e,n,o){new t(e,o,s.notIncludeMembers,!0).to.not.include.members(n)},s.includeDeepMembers=function(e,n,o){new t(e,o,s.includeDeepMembers,!0).to.include.deep.members(n)},s.notIncludeDeepMembers=function(e,n,o){new t(e,o,s.notIncludeDeepMembers,!0).to.not.include.deep.members(n)},s.includeOrderedMembers=function(e,n,o){new t(e,o,s.includeOrderedMembers,!0).to.include.ordered.members(n)},s.notIncludeOrderedMembers=function(e,n,o){new t(e,o,s.notIncludeOrderedMembers,!0).to.not.include.ordered.members(n)},s.includeDeepOrderedMembers=function(e,n,o){new t(e,o,s.includeDeepOrderedMembers,!0).to.include.deep.ordered.members(n)},s.notIncludeDeepOrderedMembers=function(e,n,o){new t(e,o,s.notIncludeDeepOrderedMembers,!0).to.not.include.deep.ordered.members(n)},s.oneOf=function(e,n,o){new t(e,o,s.oneOf,!0).to.be.oneOf(n)},s.changes=function(e,n,o,r){3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.changes,!0).to.change(n,o)},s.changesBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.changesBy,!0).to.change(n,o).by(r)},s.doesNotChange=function(e,n,o,r){return 3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.doesNotChange,!0).to.not.change(n,o)},s.changesButNotBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.changesButNotBy,!0).to.change(n,o).but.not.by(r)},s.increases=function(e,n,o,r){return 3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.increases,!0).to.increase(n,o)},s.increasesBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.increasesBy,!0).to.increase(n,o).by(r)},s.doesNotIncrease=function(e,n,o,r){return 3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.doesNotIncrease,!0).to.not.increase(n,o)},s.increasesButNotBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.increasesButNotBy,!0).to.increase(n,o).but.not.by(r)},s.decreases=function(e,n,o,r){return 3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.decreases,!0).to.decrease(n,o)},s.decreasesBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.decreasesBy,!0).to.decrease(n,o).by(r)},s.doesNotDecrease=function(e,n,o,r){return 3===arguments.length&&"function"==typeof n&&(r=o,o=null),new t(e,r,s.doesNotDecrease,!0).to.not.decrease(n,o)},s.doesNotDecreaseBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);return new t(e,i,s.doesNotDecreaseBy,!0).to.not.decrease(n,o).by(r)},s.decreasesButNotBy=function(e,n,o,r,i){if(4===arguments.length&&"function"==typeof n){var a=r;r=o,i=a}else 3===arguments.length&&(r=o,o=null);new t(e,i,s.decreasesButNotBy,!0).to.decrease(n,o).but.not.by(r)},
+/*!
+	   * ### .ifError(object)
+	   *
+	   * Asserts if value is not a false value, and throws if it is a true value.
+	   * This is added to allow for chai to be a drop-in replacement for Node's
+	   * assert class.
+	   *
+	   *     var err = new Error('I am a custom error');
+	   *     assert.ifError(err); // Rethrows err!
+	   *
+	   * @name ifError
+	   * @param {Object} object
+	   * @namespace Assert
+	   * @api public
+	   */
+s.ifError=function(e){if(e)throw e},s.isExtensible=function(e,n){new t(e,n,s.isExtensible,!0).to.be.extensible},s.isNotExtensible=function(e,n){new t(e,n,s.isNotExtensible,!0).to.not.be.extensible},s.isSealed=function(e,n){new t(e,n,s.isSealed,!0).to.be.sealed},s.isNotSealed=function(e,n){new t(e,n,s.isNotSealed,!0).to.not.be.sealed},s.isFrozen=function(e,n){new t(e,n,s.isFrozen,!0).to.be.frozen},s.isNotFrozen=function(e,n){new t(e,n,s.isNotFrozen,!0).to.not.be.frozen},s.isEmpty=function(e,n){new t(e,n,s.isEmpty,!0).to.be.empty},s.isNotEmpty=function(e,n){new t(e,n,s.isNotEmpty,!0).to.not.be.empty},
+/*!
+	   * Aliases.
+	   */
+function alias(e,n){return s[n]=s[e],alias}("isOk","ok")("isNotOk","notOk")("throws","throw")("throws","Throw")("isExtensible","extensible")("isNotExtensible","notExtensible")("isSealed","sealed")("isNotSealed","notSealed")("isFrozen","frozen")("isNotFrozen","notFrozen")("isEmpty","empty")("isNotEmpty","notEmpty")}),e}export{requireAssert as __require};
+//# sourceMappingURL=assert.esm.js.map