chai 4.3.10 → 5.0.0

package/lib/chai/interface/expect.js

@@ -4,44 +4,47 @@
  * MIT Licensed
  */
 
-module.exports = function (chai, util) {
-  chai.expect = function (val, message) {
-    return new chai.Assertion(val, message);
-  };
+import * as chai from '../../../index.js';
+import {Assertion} from '../assertion.js';
+import {AssertionError} from 'assertion-error';
 
-  /**
-   * ### .fail([message])
-   * ### .fail(actual, expected, [message], [operator])
-   *
-   * Throw a failure.
-   *
-   *     expect.fail();
-   *     expect.fail("custom error message");
-   *     expect.fail(1, 2);
-   *     expect.fail(1, 2, "custom error message");
-   *     expect.fail(1, 2, "custom error message", ">");
-   *     expect.fail(1, 2, undefined, ">");
-   *
-   * @name fail
-   * @param {Mixed} actual
-   * @param {Mixed} expected
-   * @param {String} message
-   * @param {String} operator
-   * @namespace BDD
-   * @api public
-   */
+function expect(val, message) {
+  return new Assertion(val, message);
+}
 
-  chai.expect.fail = function (actual, expected, message, operator) {
-    if (arguments.length < 2) {
-        message = actual;
-        actual = undefined;
-    }
+export {expect};
+/**
+ * ### .fail([message])
+ * ### .fail(actual, expected, [message], [operator])
+ *
+ * Throw a failure.
+ *
+ *     expect.fail();
+ *     expect.fail("custom error message");
+ *     expect.fail(1, 2);
+ *     expect.fail(1, 2, "custom error message");
+ *     expect.fail(1, 2, "custom error message", ">");
+ *     expect.fail(1, 2, undefined, ">");
+ *
+ * @name fail
+ * @param {Mixed} actual
+ * @param {Mixed} expected
+ * @param {String} message
+ * @param {String} operator
+ * @namespace BDD
+ * @api public
+ */
+
+expect.fail = function (actual, expected, message, operator) {
+  if (arguments.length < 2) {
+      message = actual;
+      actual = undefined;
+  }
 
-    message = message || 'expect.fail()';
-    throw new chai.AssertionError(message, {
-        actual: actual
-      , expected: expected
-      , operator: operator
-    }, chai.expect.fail);
-  };
+  message = message || 'expect.fail()';
+  throw new AssertionError(message, {
+      actual: actual
+    , expected: expected
+    , operator: operator
+  }, chai.expect.fail);
 };

package/lib/chai/interface/should.js

@@ -4,216 +4,215 @@
  * MIT Licensed
  */
 
-module.exports = function (chai, util) {
-  var Assertion = chai.Assertion;
-
-  function loadShould () {
-    // explicitly define this method as function as to have it's name to include as `ssfi`
-    function shouldGetter() {
-      if (this instanceof String
-          || this instanceof Number
-          || this instanceof Boolean
-          || typeof Symbol === 'function' && this instanceof Symbol
-          || typeof BigInt === 'function' && this instanceof BigInt) {
-        return new Assertion(this.valueOf(), null, shouldGetter);
-      }
-      return new Assertion(this, null, shouldGetter);
+import {Assertion} from '../assertion.js';
+import {AssertionError} from 'assertion-error';
+
+function loadShould () {
+  // explicitly define this method as function as to have it's name to include as `ssfi`
+  function shouldGetter() {
+    if (this instanceof String
+        || this instanceof Number
+        || this instanceof Boolean
+        || typeof Symbol === 'function' && this instanceof Symbol
+        || typeof BigInt === 'function' && this instanceof BigInt) {
+      return new Assertion(this.valueOf(), null, shouldGetter);
     }
-    function shouldSetter(value) {
-      // See https://github.com/chaijs/chai/issues/86: this makes
-      // `whatever.should = someValue` actually set `someValue`, which is
-      // especially useful for `global.should = require('chai').should()`.
-      //
-      // Note that we have to use [[DefineProperty]] instead of [[Put]]
-      // since otherwise we would trigger this very setter!
-      Object.defineProperty(this, 'should', {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    }
-    // modify Object.prototype to have `should`
-    Object.defineProperty(Object.prototype, 'should', {
-      set: shouldSetter
-      , get: shouldGetter
-      , configurable: true
+    return new Assertion(this, null, shouldGetter);
+  }
+  function shouldSetter(value) {
+    // See https://github.com/chaijs/chai/issues/86: this makes
+    // `whatever.should = someValue` actually set `someValue`, which is
+    // especially useful for `global.should = require('chai').should()`.
+    //
+    // Note that we have to use [[DefineProperty]] instead of [[Put]]
+    // since otherwise we would trigger this very setter!
+    Object.defineProperty(this, 'should', {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
-
-    var should = {};
-
-    /**
-     * ### .fail([message])
-     * ### .fail(actual, expected, [message], [operator])
-     *
-     * Throw a failure.
-     *
-     *     should.fail();
-     *     should.fail("custom error message");
-     *     should.fail(1, 2);
-     *     should.fail(1, 2, "custom error message");
-     *     should.fail(1, 2, "custom error message", ">");
-     *     should.fail(1, 2, undefined, ">");
-     *
-     *
-     * @name fail
-     * @param {Mixed} actual
-     * @param {Mixed} expected
-     * @param {String} message
-     * @param {String} operator
-     * @namespace BDD
-     * @api public
-     */
-
-    should.fail = function (actual, expected, message, operator) {
-      if (arguments.length < 2) {
-          message = actual;
-          actual = undefined;
-      }
-
-      message = message || 'should.fail()';
-      throw new chai.AssertionError(message, {
-          actual: actual
-        , expected: expected
-        , operator: operator
-      }, should.fail);
-    };
-
-    /**
-     * ### .equal(actual, expected, [message])
-     *
-     * Asserts non-strict equality (`==`) of `actual` and `expected`.
-     *
-     *     should.equal(3, '3', '== coerces values to strings');
-     *
-     * @name equal
-     * @param {Mixed} actual
-     * @param {Mixed} expected
-     * @param {String} message
-     * @namespace Should
-     * @api public
-     */
-
-    should.equal = function (val1, val2, msg) {
-      new Assertion(val1, msg).to.equal(val2);
-    };
-
-    /**
-     * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
-     *
-     * Asserts that `function` will throw an error that is an instance of
-     * `constructor`, or alternately that it will throw an error with message
-     * matching `regexp`.
-     *
-     *     should.throw(fn, 'function throws a reference error');
-     *     should.throw(fn, /function throws a reference error/);
-     *     should.throw(fn, ReferenceError);
-     *     should.throw(fn, ReferenceError, 'function throws a reference error');
-     *     should.throw(fn, ReferenceError, /function throws a reference error/);
-     *
-     * @name throw
-     * @alias Throw
-     * @param {Function} function
-     * @param {ErrorConstructor} constructor
-     * @param {RegExp} regexp
-     * @param {String} message
-     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-     * @namespace Should
-     * @api public
-     */
-
-    should.Throw = function (fn, errt, errs, msg) {
-      new Assertion(fn, msg).to.Throw(errt, errs);
-    };
-
-    /**
-     * ### .exist
-     *
-     * Asserts that the target is neither `null` nor `undefined`.
-     *
-     *     var foo = 'hi';
-     *
-     *     should.exist(foo, 'foo exists');
-     *
-     * @name exist
-     * @namespace Should
-     * @api public
-     */
-
-    should.exist = function (val, msg) {
-      new Assertion(val, msg).to.exist;
+  }
+  // modify Object.prototype to have `should`
+  Object.defineProperty(Object.prototype, 'should', {
+    set: shouldSetter
+    , get: shouldGetter
+    , configurable: true
+  });
+
+  var should = {};
+
+  /**
+   * ### .fail([message])
+   * ### .fail(actual, expected, [message], [operator])
+   *
+   * Throw a failure.
+   *
+   *     should.fail();
+   *     should.fail("custom error message");
+   *     should.fail(1, 2);
+   *     should.fail(1, 2, "custom error message");
+   *     should.fail(1, 2, "custom error message", ">");
+   *     should.fail(1, 2, undefined, ">");
+   *
+   *
+   * @name fail
+   * @param {Mixed} actual
+   * @param {Mixed} expected
+   * @param {String} message
+   * @param {String} operator
+   * @namespace BDD
+   * @api public
+   */
+
+  should.fail = function (actual, expected, message, operator) {
+    if (arguments.length < 2) {
+        message = actual;
+        actual = undefined;
     }
 
-    // negation
-    should.not = {}
-
-    /**
-     * ### .not.equal(actual, expected, [message])
-     *
-     * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
-     *
-     *     should.not.equal(3, 4, 'these numbers are not equal');
-     *
-     * @name not.equal
-     * @param {Mixed} actual
-     * @param {Mixed} expected
-     * @param {String} message
-     * @namespace Should
-     * @api public
-     */
-
-    should.not.equal = function (val1, val2, msg) {
-      new Assertion(val1, msg).to.not.equal(val2);
-    };
-
-    /**
-     * ### .throw(function, [constructor/regexp], [message])
-     *
-     * Asserts that `function` will _not_ throw an error that is an instance of
-     * `constructor`, or alternately that it will not throw an error with message
-     * matching `regexp`.
-     *
-     *     should.not.throw(fn, Error, 'function does not throw');
-     *
-     * @name not.throw
-     * @alias not.Throw
-     * @param {Function} function
-     * @param {ErrorConstructor} constructor
-     * @param {RegExp} regexp
-     * @param {String} message
-     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-     * @namespace Should
-     * @api public
-     */
-
-    should.not.Throw = function (fn, errt, errs, msg) {
-      new Assertion(fn, msg).to.not.Throw(errt, errs);
-    };
-
-    /**
-     * ### .not.exist
-     *
-     * Asserts that the target is neither `null` nor `undefined`.
-     *
-     *     var bar = null;
-     *
-     *     should.not.exist(bar, 'bar does not exist');
-     *
-     * @name not.exist
-     * @namespace Should
-     * @api public
-     */
-
-    should.not.exist = function (val, msg) {
-      new Assertion(val, msg).to.not.exist;
-    }
+    message = message || 'should.fail()';
+    throw new AssertionError(message, {
+        actual: actual
+      , expected: expected
+      , operator: operator
+    }, should.fail);
+  };
+
+  /**
+   * ### .equal(actual, expected, [message])
+   *
+   * Asserts non-strict equality (`==`) of `actual` and `expected`.
+   *
+   *     should.equal(3, '3', '== coerces values to strings');
+   *
+   * @name equal
+   * @param {Mixed} actual
+   * @param {Mixed} expected
+   * @param {String} message
+   * @namespace Should
+   * @api public
+   */
+
+  should.equal = function (val1, val2, msg) {
+    new Assertion(val1, msg).to.equal(val2);
+  };
 
-    should['throw'] = should['Throw'];
-    should.not['throw'] = should.not['Throw'];
+  /**
+   * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
+   *
+   * Asserts that `function` will throw an error that is an instance of
+   * `constructor`, or alternately that it will throw an error with message
+   * matching `regexp`.
+   *
+   *     should.throw(fn, 'function throws a reference error');
+   *     should.throw(fn, /function throws a reference error/);
+   *     should.throw(fn, ReferenceError);
+   *     should.throw(fn, ReferenceError, 'function throws a reference error');
+   *     should.throw(fn, ReferenceError, /function throws a reference error/);
+   *
+   * @name throw
+   * @alias Throw
+   * @param {Function} function
+   * @param {ErrorConstructor} constructor
+   * @param {RegExp} regexp
+   * @param {String} message
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+   * @namespace Should
+   * @api public
+   */
+
+  should.Throw = function (fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.Throw(errt, errs);
+  };
 
-    return should;
+  /**
+   * ### .exist
+   *
+   * Asserts that the target is neither `null` nor `undefined`.
+   *
+   *     var foo = 'hi';
+   *
+   *     should.exist(foo, 'foo exists');
+   *
+   * @name exist
+   * @namespace Should
+   * @api public
+   */
+
+  should.exist = function (val, msg) {
+    new Assertion(val, msg).to.exist;
+  }
+
+  // negation
+  should.not = {}
+
+  /**
+   * ### .not.equal(actual, expected, [message])
+   *
+   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
+   *
+   *     should.not.equal(3, 4, 'these numbers are not equal');
+   *
+   * @name not.equal
+   * @param {Mixed} actual
+   * @param {Mixed} expected
+   * @param {String} message
+   * @namespace Should
+   * @api public
+   */
+
+  should.not.equal = function (val1, val2, msg) {
+    new Assertion(val1, msg).to.not.equal(val2);
   };
 
-  chai.should = loadShould;
-  chai.Should = loadShould;
+  /**
+   * ### .throw(function, [constructor/regexp], [message])
+   *
+   * Asserts that `function` will _not_ throw an error that is an instance of
+   * `constructor`, or alternately that it will not throw an error with message
+   * matching `regexp`.
+   *
+   *     should.not.throw(fn, Error, 'function does not throw');
+   *
+   * @name not.throw
+   * @alias not.Throw
+   * @param {Function} function
+   * @param {ErrorConstructor} constructor
+   * @param {RegExp} regexp
+   * @param {String} message
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+   * @namespace Should
+   * @api public
+   */
+
+  should.not.Throw = function (fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.not.Throw(errt, errs);
+  };
+
+  /**
+   * ### .not.exist
+   *
+   * Asserts that the target is neither `null` nor `undefined`.
+   *
+   *     var bar = null;
+   *
+   *     should.not.exist(bar, 'bar does not exist');
+   *
+   * @name not.exist
+   * @namespace Should
+   * @api public
+   */
+
+  should.not.exist = function (val, msg) {
+    new Assertion(val, msg).to.not.exist;
+  }
+
+  should['throw'] = should['Throw'];
+  should.not['throw'] = should.not['Throw'];
+
+  return should;
 };
+
+export const should = loadShould;
+export const Should = loadShould;

package/lib/chai/utils/addChainableMethod.js

@@ -8,11 +8,11 @@
  * Module dependencies
  */
 
-var addLengthGuard = require('./addLengthGuard');
-var chai = require('../../chai');
-var flag = require('./flag');
-var proxify = require('./proxify');
-var transferFlags = require('./transferFlags');
+import {Assertion} from '../assertion.js';
+import {addLengthGuard} from './addLengthGuard.js';
+import {flag} from './flag.js';
+import {proxify} from './proxify.js';
+import {transferFlags} from './transferFlags.js';
 
 /*!
  * Module variables
@@ -70,7 +70,7 @@ var call  = Function.prototype.call,
  * @api public
  */
 
-module.exports = function addChainableMethod(ctx, name, method, chainingBehavior) {
+export function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== 'function') {
     chainingBehavior = function () { };
   }
@@ -115,7 +115,7 @@ module.exports = function addChainableMethod(ctx, name, method, chainingBehavior
             return result;
           }
 
-          var newAssertion = new chai.Assertion();
+          var newAssertion = new Assertion();
           transferFlags(this, newAssertion);
           return newAssertion;
         };
@@ -149,4 +149,4 @@ module.exports = function addChainableMethod(ctx, name, method, chainingBehavior
       }
     , configurable: true
   });
-};
+}

package/lib/chai/utils/addLengthGuard.js

@@ -1,4 +1,4 @@
-var fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
+const fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
 
 /*!
  * Chai - addLengthGuard utility
@@ -40,7 +40,7 @@ var fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
  * @name addLengthGuard
  */
 
-module.exports = function addLengthGuard (fn, assertionName, isChainable) {
+export function addLengthGuard(fn, assertionName, isChainable) {
   if (!fnLengthDesc.configurable) return fn;
 
   Object.defineProperty(fn, 'length', {
@@ -57,4 +57,4 @@ module.exports = function addLengthGuard (fn, assertionName, isChainable) {
   });
 
   return fn;
-};
+}

package/lib/chai/utils/addMethod.js

@@ -4,11 +4,11 @@
  * MIT Licensed
  */
 
-var addLengthGuard = require('./addLengthGuard');
-var chai = require('../../chai');
-var flag = require('./flag');
-var proxify = require('./proxify');
-var transferFlags = require('./transferFlags');
+import {addLengthGuard} from './addLengthGuard.js';
+import {flag} from './flag.js';
+import {proxify} from './proxify.js';
+import {transferFlags} from './transferFlags.js';
+import {Assertion} from '../assertion.js';
 
 /**
  * ### .addMethod(ctx, name, method)
@@ -36,7 +36,7 @@ var transferFlags = require('./transferFlags');
  * @api public
  */
 
-module.exports = function addMethod(ctx, name, method) {
+export function addMethod(ctx, name, method) {
   var methodWrapper = function () {
     // Setting the `ssfi` flag to `methodWrapper` causes this function to be the
     // starting point for removing implementation frames from the stack trace of
@@ -58,11 +58,11 @@ module.exports = function addMethod(ctx, name, method) {
     if (result !== undefined)
       return result;
 
-    var newAssertion = new chai.Assertion();
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   };
 
   addLengthGuard(methodWrapper, name, false);
   ctx[name] = proxify(methodWrapper, name);
-};
+}

package/lib/chai/utils/addProperty.js

@@ -4,10 +4,10 @@
  * MIT Licensed
  */
 
-var chai = require('../../chai');
-var flag = require('./flag');
-var isProxyEnabled = require('./isProxyEnabled');
-var transferFlags = require('./transferFlags');
+import {Assertion} from '../assertion.js';
+import {flag} from './flag.js';
+import {isProxyEnabled} from './isProxyEnabled.js';
+import {transferFlags} from './transferFlags.js';
 
 /**
  * ### .addProperty(ctx, name, getter)
@@ -35,7 +35,7 @@ var transferFlags = require('./transferFlags');
  * @api public
  */
 
-module.exports = function addProperty(ctx, name, getter) {
+export function addProperty(ctx, name, getter) {
   getter = getter === undefined ? function () {} : getter;
 
   Object.defineProperty(ctx, name,
@@ -63,10 +63,10 @@ module.exports = function addProperty(ctx, name, getter) {
         if (result !== undefined)
           return result;
 
-        var newAssertion = new chai.Assertion();
+        var newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
       }
     , configurable: true
   });
-};
+}

package/lib/chai/utils/compareByInspect.js

@@ -8,7 +8,7 @@
  * Module dependencies
  */
 
-var inspect = require('./inspect');
+import {inspect} from './inspect.js';
 
 /**
  * ### .compareByInspect(mixed, mixed)
@@ -26,6 +26,6 @@ var inspect = require('./inspect');
  * @api public
  */
 
-module.exports = function compareByInspect(a, b) {
+export function compareByInspect(a, b) {
   return inspect(a) < inspect(b) ? -1 : 1;
-};
+}