chai 5.1.2 → 5.2.1

package/lib/chai/interface/expect.js

@@ -42,14 +42,18 @@ export {expect};
  */
 expect.fail = function (actual, expected, message, operator) {
   if (arguments.length < 2) {
-      message = actual;
-      actual = undefined;
+    message = actual;
+    actual = undefined;
   }
 
   message = message || 'expect.fail()';
-  throw new AssertionError(message, {
-      actual: actual
-    , expected: expected
-    , operator: operator
-  }, chai.expect.fail);
+  throw new AssertionError(
+    message,
+    {
+      actual: actual,
+      expected: expected,
+      operator: operator
+    },
+    chai.expect.fail
+  );
 };

package/lib/chai/interface/should.js

@@ -10,17 +10,19 @@ import {AssertionError} from 'assertion-error';
 /**
  * @returns {void}
  */
-function loadShould () {
+function loadShould() {
   // explicitly define this method as function as to have it's name to include as `ssfi`
   /**
    * @returns {Assertion}
    */
   function shouldGetter() {
-    if (this instanceof String
-        || this instanceof Number
-        || this instanceof Boolean
-        || typeof Symbol === 'function' && this instanceof Symbol
-        || typeof BigInt === 'function' && this instanceof BigInt) {
+    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);
@@ -44,12 +46,12 @@ function loadShould () {
   }
   // modify Object.prototype to have `should`
   Object.defineProperty(Object.prototype, 'should', {
-    set: shouldSetter
-    , get: shouldGetter
-    , configurable: true
+    set: shouldSetter,
+    get: shouldGetter,
+    configurable: true
   });
 
-  var should = {};
+  let should = {};
 
   /**
    * ### .fail([message])
@@ -74,16 +76,20 @@ function loadShould () {
    */
   should.fail = function (actual, expected, message, operator) {
     if (arguments.length < 2) {
-        message = actual;
-        actual = undefined;
+      message = actual;
+      actual = undefined;
     }
 
     message = message || 'should.fail()';
-    throw new AssertionError(message, {
-        actual: actual
-      , expected: expected
-      , operator: operator
-    }, should.fail);
+    throw new AssertionError(
+      message,
+      {
+        actual: actual,
+        expected: expected,
+        operator: operator
+      },
+      should.fail
+    );
   };
 
   /**
@@ -147,10 +153,10 @@ function loadShould () {
    */
   should.exist = function (val, msg) {
     new Assertion(val, msg).to.exist;
-  }
+  };
 
   // negation
-  should.not = {}
+  should.not = {};
 
   /**
    * ### .not.equal(actual, expected, [message])
@@ -209,13 +215,13 @@ function loadShould () {
    */
   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

@@ -15,27 +15,26 @@ import {transferFlags} from './transferFlags.js';
  */
 
 // Check whether `Object.setPrototypeOf` is supported
-var canSetPrototype = typeof Object.setPrototypeOf === 'function';
+let canSetPrototype = typeof Object.setPrototypeOf === 'function';
 
 // Without `Object.setPrototypeOf` support, this module will need to add properties to a function.
 // However, some of functions' own props are not configurable and should be skipped.
-var testFn = function() {};
-var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
-  var propDesc = Object.getOwnPropertyDescriptor(testFn, name);
+let testFn = function () {};
+let excludeNames = Object.getOwnPropertyNames(testFn).filter(function (name) {
+  let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
 
   // Note: PhantomJS 1.x includes `callee` as one of `testFn`'s own properties,
   // but then returns `undefined` as the property descriptor for `callee`. As a
   // workaround, we perform an otherwise unnecessary type-check for `propDesc`,
   // and then filter it out if it's not an object as it should be.
-  if (typeof propDesc !== 'object')
-    return true;
+  if (typeof propDesc !== 'object') return true;
 
   return !propDesc.configurable;
 });
 
 // Cache `Function` properties
-var call  = Function.prototype.call,
-    apply = Function.prototype.apply;
+let call = Function.prototype.call,
+  apply = Function.prototype.apply;
 
 /**
  * ### .addChainableMethod(ctx, name, method, chainingBehavior)
@@ -67,12 +66,12 @@ var call  = Function.prototype.call,
  */
 export function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== 'function') {
-    chainingBehavior = function () { };
+    chainingBehavior = function () {};
   }
 
-  var chainableBehavior = {
-      method: method
-    , chainingBehavior: chainingBehavior
+  let chainableBehavior = {
+    method: method,
+    chainingBehavior: chainingBehavior
   };
 
   // save the methods so we can overwrite them later, if we need to.
@@ -81,67 +80,67 @@ export function addChainableMethod(ctx, name, method, chainingBehavior) {
   }
   ctx.__methods[name] = chainableBehavior;
 
-  Object.defineProperty(ctx, name,
-    { get: function chainableMethodGetter() {
-        chainableBehavior.chainingBehavior.call(this);
-
-        var chainableMethodWrapper = function () {
-          // Setting the `ssfi` flag to `chainableMethodWrapper` causes this
-          // function to be the starting point for removing implementation
-          // frames from the stack trace of a failed assertion.
-          //
-          // However, we only want to use this function as the starting point if
-          // the `lockSsfi` flag isn't set.
-          //
-          // If the `lockSsfi` flag is set, then this assertion is being
-          // invoked from inside of another assertion. In this case, the `ssfi`
-          // flag has already been set by the outer assertion.
-          //
-          // Note that overwriting a chainable method merely replaces the saved
-          // methods in `ctx.__methods` instead of completely replacing the
-          // overwritten assertion. Therefore, an overwriting assertion won't
-          // set the `ssfi` or `lockSsfi` flags.
-          if (!flag(this, 'lockSsfi')) {
-            flag(this, 'ssfi', chainableMethodWrapper);
-          }
-
-          var result = chainableBehavior.method.apply(this, arguments);
-          if (result !== undefined) {
-            return result;
-          }
-
-          var newAssertion = new Assertion();
-          transferFlags(this, newAssertion);
-          return newAssertion;
-        };
-
-        addLengthGuard(chainableMethodWrapper, name, true);
-
-        // Use `Object.setPrototypeOf` if available
-        if (canSetPrototype) {
-          // Inherit all properties from the object by replacing the `Function` prototype
-          var prototype = Object.create(this);
-          // Restore the `call` and `apply` methods from `Function`
-          prototype.call = call;
-          prototype.apply = apply;
-          Object.setPrototypeOf(chainableMethodWrapper, prototype);
+  Object.defineProperty(ctx, name, {
+    get: function chainableMethodGetter() {
+      chainableBehavior.chainingBehavior.call(this);
+
+      let chainableMethodWrapper = function () {
+        // Setting the `ssfi` flag to `chainableMethodWrapper` causes this
+        // function to be the starting point for removing implementation
+        // frames from the stack trace of a failed assertion.
+        //
+        // However, we only want to use this function as the starting point if
+        // the `lockSsfi` flag isn't set.
+        //
+        // If the `lockSsfi` flag is set, then this assertion is being
+        // invoked from inside of another assertion. In this case, the `ssfi`
+        // flag has already been set by the outer assertion.
+        //
+        // Note that overwriting a chainable method merely replaces the saved
+        // methods in `ctx.__methods` instead of completely replacing the
+        // overwritten assertion. Therefore, an overwriting assertion won't
+        // set the `ssfi` or `lockSsfi` flags.
+        if (!flag(this, 'lockSsfi')) {
+          flag(this, 'ssfi', chainableMethodWrapper);
         }
-        // Otherwise, redefine all properties (slow!)
-        else {
-          var asserterNames = Object.getOwnPropertyNames(ctx);
-          asserterNames.forEach(function (asserterName) {
-            if (excludeNames.indexOf(asserterName) !== -1) {
-              return;
-            }
-
-            var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
-            Object.defineProperty(chainableMethodWrapper, asserterName, pd);
-          });
+
+        let result = chainableBehavior.method.apply(this, arguments);
+        if (result !== undefined) {
+          return result;
         }
 
-        transferFlags(this, chainableMethodWrapper);
-        return proxify(chainableMethodWrapper);
+        let newAssertion = new Assertion();
+        transferFlags(this, newAssertion);
+        return newAssertion;
+      };
+
+      addLengthGuard(chainableMethodWrapper, name, true);
+
+      // Use `Object.setPrototypeOf` if available
+      if (canSetPrototype) {
+        // Inherit all properties from the object by replacing the `Function` prototype
+        let prototype = Object.create(this);
+        // Restore the `call` and `apply` methods from `Function`
+        prototype.call = call;
+        prototype.apply = apply;
+        Object.setPrototypeOf(chainableMethodWrapper, prototype);
       }
-    , configurable: true
+      // Otherwise, redefine all properties (slow!)
+      else {
+        let asserterNames = Object.getOwnPropertyNames(ctx);
+        asserterNames.forEach(function (asserterName) {
+          if (excludeNames.indexOf(asserterName) !== -1) {
+            return;
+          }
+
+          let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+          Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+        });
+      }
+
+      transferFlags(this, chainableMethodWrapper);
+      return proxify(chainableMethodWrapper);
+    },
+    configurable: true
   });
 }

package/lib/chai/utils/addLengthGuard.js

@@ -46,13 +46,26 @@ export function addLengthGuard(fn, assertionName, isChainable) {
   Object.defineProperty(fn, 'length', {
     get: function () {
       if (isChainable) {
-        throw Error('Invalid Chai property: ' + assertionName + '.length. Due' +
-          ' to a compatibility issue, "length" cannot directly follow "' +
-          assertionName + '". Use "' + assertionName + '.lengthOf" instead.');
+        throw Error(
+          'Invalid Chai property: ' +
+            assertionName +
+            '.length. Due' +
+            ' to a compatibility issue, "length" cannot directly follow "' +
+            assertionName +
+            '". Use "' +
+            assertionName +
+            '.lengthOf" instead.'
+        );
       }
 
-      throw Error('Invalid Chai property: ' + assertionName + '.length. See' +
-        ' docs for proper usage of "' + assertionName + '".');
+      throw Error(
+        'Invalid Chai property: ' +
+          assertionName +
+          '.length. See' +
+          ' docs for proper usage of "' +
+          assertionName +
+          '".'
+      );
     }
   });
 

package/lib/chai/utils/addMethod.js

@@ -36,7 +36,7 @@ import {Assertion} from '../assertion.js';
  * @public
  */
 export function addMethod(ctx, name, method) {
-  var methodWrapper = function () {
+  let 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
     // a failed assertion.
@@ -53,11 +53,10 @@ export function addMethod(ctx, name, method) {
       flag(this, 'ssfi', methodWrapper);
     }
 
-    var result = method.apply(this, arguments);
-    if (result !== undefined)
-      return result;
+    let result = method.apply(this, arguments);
+    if (result !== undefined) return result;
 
-    var newAssertion = new Assertion();
+    let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   };

package/lib/chai/utils/addProperty.js

@@ -37,35 +37,34 @@ import {transferFlags} from './transferFlags.js';
 export function addProperty(ctx, name, getter) {
   getter = getter === undefined ? function () {} : getter;
 
-  Object.defineProperty(ctx, name,
-    { get: function propertyGetter() {
-        // Setting the `ssfi` flag to `propertyGetter` causes this function to
-        // be the starting point for removing implementation frames from the
-        // stack trace of a failed assertion.
-        //
-        // However, we only want to use this function as the starting point if
-        // the `lockSsfi` flag isn't set and proxy protection is disabled.
-        //
-        // If the `lockSsfi` flag is set, then either this assertion has been
-        // overwritten by another assertion, or this assertion is being invoked
-        // from inside of another assertion. In the first case, the `ssfi` flag
-        // has already been set by the overwriting assertion. In the second
-        // case, the `ssfi` flag has already been set by the outer assertion.
-        //
-        // If proxy protection is enabled, then the `ssfi` flag has already been
-        // set by the proxy getter.
-        if (!isProxyEnabled() && !flag(this, 'lockSsfi')) {
-          flag(this, 'ssfi', propertyGetter);
-        }
+  Object.defineProperty(ctx, name, {
+    get: function propertyGetter() {
+      // Setting the `ssfi` flag to `propertyGetter` causes this function to
+      // be the starting point for removing implementation frames from the
+      // stack trace of a failed assertion.
+      //
+      // However, we only want to use this function as the starting point if
+      // the `lockSsfi` flag isn't set and proxy protection is disabled.
+      //
+      // If the `lockSsfi` flag is set, then either this assertion has been
+      // overwritten by another assertion, or this assertion is being invoked
+      // from inside of another assertion. In the first case, the `ssfi` flag
+      // has already been set by the overwriting assertion. In the second
+      // case, the `ssfi` flag has already been set by the outer assertion.
+      //
+      // If proxy protection is enabled, then the `ssfi` flag has already been
+      // set by the proxy getter.
+      if (!isProxyEnabled() && !flag(this, 'lockSsfi')) {
+        flag(this, 'ssfi', propertyGetter);
+      }
 
-        var result = getter.call(this);
-        if (result !== undefined)
-          return result;
+      let result = getter.call(this);
+      if (result !== undefined) return result;
 
-        var newAssertion = new Assertion();
-        transferFlags(this, newAssertion);
-        return newAssertion;
-      }
-    , configurable: true
+      let newAssertion = new Assertion();
+      transferFlags(this, newAssertion);
+      return newAssertion;
+    },
+    configurable: true
   });
 }

package/lib/chai/utils/expectTypes.js

@@ -22,25 +22,33 @@ import {type} from './type-detect.js';
  * @public
  */
 export function expectTypes(obj, types) {
-  var flagMsg = flag(obj, 'message');
-  var ssfi = flag(obj, 'ssfi');
+  let flagMsg = flag(obj, 'message');
+  let ssfi = flag(obj, 'ssfi');
 
   flagMsg = flagMsg ? flagMsg + ': ' : '';
 
   obj = flag(obj, 'object');
-  types = types.map(function (t) { return t.toLowerCase(); });
+  types = types.map(function (t) {
+    return t.toLowerCase();
+  });
   types.sort();
 
   // Transforms ['lorem', 'ipsum'] into 'a lorem, or an ipsum'
-  var str = types.map(function (t, index) {
-    var art = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(t.charAt(0)) ? 'an' : 'a';
-    var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
-    return or + art + ' ' + t;
-  }).join(', ');
+  let str = types
+    .map(function (t, index) {
+      let art = ~['a', 'e', 'i', 'o', 'u'].indexOf(t.charAt(0)) ? 'an' : 'a';
+      let or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
+      return or + art + ' ' + t;
+    })
+    .join(', ');
 
-  var objType = type(obj).toLowerCase();
+  let objType = type(obj).toLowerCase();
 
-  if (!types.some(function (expected) { return objType === expected; })) {
+  if (
+    !types.some(function (expected) {
+      return objType === expected;
+    })
+  ) {
     throw new AssertionError(
       flagMsg + 'object tested must be ' + str + ', but ' + objType + ' given',
       undefined,

package/lib/chai/utils/flag.js

@@ -15,16 +15,17 @@
  *     utils.flag(this, 'foo', 'bar'); // setter
  *     utils.flag(this, 'foo'); // getter, returns `bar`
  *
- * @param {object} obj object constructed Assertion
+ * @template {{__flags?: {[key: PropertyKey]: unknown}}} T
+ * @param {T} obj object constructed Assertion
  * @param {string} key
- * @param {unknown} value (optional)
+ * @param {unknown} [value]
  * @namespace Utils
  * @name flag
  * @returns {unknown | undefined}
  * @private
  */
 export function flag(obj, key, value) {
-  var flags = obj.__flags || (obj.__flags = Object.create(null));
+  let flags = obj.__flags || (obj.__flags = Object.create(null));
   if (arguments.length === 3) {
     flags[key] = value;
   } else {

package/lib/chai/utils/getMessage.js

@@ -21,26 +21,32 @@ import {objDisplay} from './objDisplay.js';
  * - `#{exp}` expected value
  *
  * @param {object} obj object (constructed Assertion)
- * @param {unknown} args chai.Assertion.prototype.assert arguments
- * @returns {unknown}
+ * @param {IArguments} args chai.Assertion.prototype.assert arguments
+ * @returns {string}
  * @namespace Utils
  * @name getMessage
  * @public
  */
 export function getMessage(obj, args) {
-  var negate = flag(obj, 'negate')
-    , val = flag(obj, 'object')
-    , expected = args[3]
-    , actual = getActual(obj, args)
-    , msg = negate ? args[2] : args[1]
-    , flagMsg = flag(obj, 'message');
+  let negate = flag(obj, 'negate');
+  let val = flag(obj, 'object');
+  let expected = args[3];
+  let actual = getActual(obj, args);
+  let msg = negate ? args[2] : args[1];
+  let flagMsg = flag(obj, 'message');
 
-  if(typeof msg === "function") msg = msg();
+  if (typeof msg === 'function') msg = msg();
   msg = msg || '';
   msg = msg
-    .replace(/#\{this\}/g, function () { return objDisplay(val); })
-    .replace(/#\{act\}/g, function () { return objDisplay(actual); })
-    .replace(/#\{exp\}/g, function () { return objDisplay(expected); });
+    .replace(/#\{this\}/g, function () {
+      return objDisplay(val);
+    })
+    .replace(/#\{act\}/g, function () {
+      return objDisplay(actual);
+    })
+    .replace(/#\{exp\}/g, function () {
+      return objDisplay(expected);
+    });
 
   return flagMsg ? flagMsg + ': ' + msg : msg;
 }

package/lib/chai/utils/getOperator.js

@@ -6,8 +6,8 @@ import {type} from './type-detect.js';
  * @returns {boolean}
  */
 function isObjectType(obj) {
-  var objectType = type(obj);
-  var objectTypes = ['Array', 'Object', 'Function'];
+  let objectType = type(obj);
+  let objectTypes = ['Array', 'Object', 'Function'];
 
   return objectTypes.indexOf(objectType) !== -1;
 }
@@ -29,10 +29,10 @@ function isObjectType(obj) {
  * @public
  */
 export function getOperator(obj, args) {
-  var operator = flag(obj, 'operator');
-  var negate = flag(obj, 'negate');
-  var expected = args[3];
-  var msg = negate ? args[2] : args[1];
+  let operator = flag(obj, 'operator');
+  let negate = flag(obj, 'negate');
+  let expected = args[3];
+  let msg = negate ? args[2] : args[1];
 
   if (operator) {
     return operator;
@@ -49,7 +49,7 @@ export function getOperator(obj, args) {
     return undefined;
   }
 
-  var isObject = isObjectType(expected);
+  let isObject = isObjectType(expected);
   if (/\snot\s/.test(msg)) {
     return isObject ? 'notDeepStrictEqual' : 'notStrictEqual';
   }

package/lib/chai/utils/getProperties.js

@@ -17,7 +17,7 @@
  * @public
  */
 export function getProperties(object) {
-  var result = Object.getOwnPropertyNames(object);
+  let result = Object.getOwnPropertyNames(object);
 
   /**
    * @param {unknown} property
@@ -28,7 +28,7 @@ export function getProperties(object) {
     }
   }
 
-  var proto = Object.getPrototypeOf(object);
+  let proto = Object.getPrototypeOf(object);
   while (proto !== null) {
     Object.getOwnPropertyNames(proto).forEach(addProperty);
     proto = Object.getPrototypeOf(proto);

package/lib/chai/utils/index.js

@@ -48,7 +48,7 @@ export {getPathInfo, hasProperty} from 'pathval';
  * @returns {string}
  */
 export function getName(fn) {
-  return fn.name
+  return fn.name;
 }
 
 // add Property
@@ -107,6 +107,12 @@ export function isRegExp(obj) {
   return Object.prototype.toString.call(obj) === '[object RegExp]';
 }
 
+/**
+ * Determines if an object is numeric or not
+ *
+ * @param {unknown} obj Object to test
+ * @returns {boolean}
+ */
 export function isNumeric(obj) {
-  return ['Number', 'BigInt'].includes(type(obj))
+  return ['Number', 'BigInt'].includes(type(obj));
 }

package/lib/chai/utils/inspect.js

@@ -21,11 +21,11 @@ import {config} from '../config.js';
  * @name inspect
  */
 export function inspect(obj, showHidden, depth, colors) {
-  var options = {
+  let options = {
     colors: colors,
-    depth: (typeof depth === 'undefined' ? 2 : depth),
+    depth: typeof depth === 'undefined' ? 2 : depth,
     showHidden: showHidden,
-    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity,
+    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity
   };
   return _inspect(obj, options);
 }

package/lib/chai/utils/isNaN.js

@@ -4,23 +4,4 @@
  * MIT Licensed
  */
 
-/**
- * ### .isNaN(value)
- *
- * Checks if the given value is NaN or not.
- *
- *     utils.isNaN(NaN); // true
- *
- * @param {unknown} value The value which has to be checked if it is NaN
- * @returns {boolean}
- * @name isNaN
- * @private
- */
-function _isNaN(value) {
-  // Refer http://www.ecma-international.org/ecma-262/6.0/#sec-isnan-number
-  // section's NOTE.
-  return value !== value;
-}
-
-// If ECMAScript 6's Number.isNaN is present, prefer that.
-export const isNaN = Number.isNaN || _isNaN;
+export const isNaN = Number.isNaN;