chai 5.0.0 → 5.0.3

package/README.md

@@ -71,32 +71,12 @@ You can also use it within the browser; install via npm and use the `chai.js` fi
 Import the library in your code, and then pick one of the styles you'd like to use - either `assert`, `expect` or `should`:
 
 ```js
-var chai = require('chai');  
-var assert = chai.assert;    // Using Assert style
-var expect = chai.expect;    // Using Expect style
-var should = chai.should();  // Using Should style
-```
-
-### Pre-Native Modules Usage (_registers the chai testing style globally_)
-
-```js
-require('chai/register-assert');  // Using Assert style
-require('chai/register-expect');  // Using Expect style
-require('chai/register-should');  // Using Should style
-```
-
-### Pre-Native Modules Usage (_as local variables_)
-
-```js
-const { assert } = require('chai');  // Using Assert style
-const { expect } = require('chai');  // Using Expect style
-const { should } = require('chai');  // Using Should style
-should();  // Modifies `Object.prototype`
-
-const { expect, use } = require('chai');  // Creates local variables `expect` and `use`; useful for plugin use
+import { assert } from 'chai';  // Using Assert style
+import { expect } from 'chai';  // Using Expect style
+import { should } from 'chai';  // Using Should style
 ```
 
-### Native Modules Usage (_registers the chai testing style globally_)
+### Register the chai testing style globally
 
 ```js
 import 'chai/register-assert';  // Using Assert style
@@ -104,13 +84,15 @@ import 'chai/register-expect';  // Using Expect style
 import 'chai/register-should';  // Using Should style
 ```
 
-### Native Modules Usage (_local import only_)
+### Import assertion styles as local variables
 
 ```js
 import { assert } from 'chai';  // Using Assert style
 import { expect } from 'chai';  // Using Expect style
 import { should } from 'chai';  // Using Should style
 should();  // Modifies `Object.prototype`
+
+import { expect, use } from 'chai';  // Creates local variables `expect` and `use`; useful for plugin use
 ```
 
 ### Usage with Mocha

package/chai.js

@@ -142,7 +142,10 @@ __name(type, "type");
 
 // node_modules/assertion-error/index.js
 var canElideFrames = "captureStackTrace" in Error;
-var AssertionError = class extends Error {
+var AssertionError = class _AssertionError extends Error {
+  static {
+    __name(this, "AssertionError");
+  }
   message;
   get name() {
     return "AssertionError";
@@ -154,7 +157,7 @@ var AssertionError = class extends Error {
     super(message);
     this.message = message;
     if (canElideFrames) {
-      Error.captureStackTrace(this, ssf || AssertionError);
+      Error.captureStackTrace(this, ssf || _AssertionError);
     }
     for (const key in props) {
       if (!(key in this)) {
@@ -172,7 +175,6 @@ var AssertionError = class extends Error {
     };
   }
 };
-__name(AssertionError, "AssertionError");
 
 // lib/chai/utils/expectTypes.js
 function expectTypes(obj, types) {
@@ -372,11 +374,7 @@ function inspectArray(array, options) {
   options.truncate -= listContents.length;
   let propertyContents = "";
   if (nonIndexProperties.length) {
-    propertyContents = inspectList(
-      nonIndexProperties.map((key) => [key, array[key]]),
-      options,
-      inspectProperty
-    );
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
   }
   return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
 }
@@ -410,11 +408,7 @@ function inspectTypedArray(array, options) {
   }
   let propertyContents = "";
   if (nonIndexProperties.length) {
-    propertyContents = inspectList(
-      nonIndexProperties.map((key) => [key, array[key]]),
-      options,
-      inspectProperty
-    );
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
   }
   return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
 }
@@ -434,11 +428,12 @@ __name(inspectDate, "inspectDate");
 
 // node_modules/loupe/lib/function.js
 function inspectFunction(func, options) {
+  const functionType = func[Symbol.toStringTag] || "Function";
   const name = func.name;
   if (!name) {
-    return options.stylize("[Function]", "special");
+    return options.stylize(`[${functionType}]`, "special");
   }
-  return options.stylize(`[Function ${truncate(name, options.truncate - 11)}]`, "special");
+  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
 }
 __name(inspectFunction, "inspectFunction");
 
@@ -524,10 +519,7 @@ function inspectSet(set2, options) {
 __name(inspectSet, "inspectSet");
 
 // node_modules/loupe/lib/string.js
-var stringEscapeChars = new RegExp(
-  "['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]",
-  "g"
-);
+var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
 var escapeCharacters = {
   "\b": "\\b",
   "	": "\\t",
@@ -590,16 +582,8 @@ function inspectObject(object, options) {
     return "[Circular]";
   }
   options.seen.push(object);
-  const propertyContents = inspectList(
-    properties.map((key) => [key, object[key]]),
-    options,
-    inspectProperty
-  );
-  const symbolContents = inspectList(
-    symbols.map((key) => [key, object[key]]),
-    options,
-    inspectProperty
-  );
+  const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+  const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
   options.seen.pop();
   let sep = "";
   if (propertyContents && symbolContents) {
@@ -659,11 +643,7 @@ function inspectObject2(error, options) {
   }
   message = message ? `: ${message}` : "";
   options.truncate -= message.length + 5;
-  const propertyContents = inspectList(
-    properties.map((key) => [key, error[key]]),
-    options,
-    inspectProperty
-  );
+  const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
   return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
 }
 __name(inspectObject2, "inspectObject");
@@ -691,12 +671,7 @@ function inspectHTML(element, options) {
   let propertyContents = "";
   if (properties.length > 0) {
     propertyContents += " ";
-    propertyContents += inspectList(
-      properties.map((key) => [key, element.getAttribute(key)]),
-      options,
-      inspectAttribute,
-      " "
-    );
+    propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ");
   }
   options.truncate -= propertyContents.length;
   const truncate2 = options.truncate;
@@ -902,7 +877,30 @@ var config = {
    * @param {Array}
    * @api public
    */
-  proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"]
+  proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],
+  /**
+   * ### config.deepEqual
+   *
+   * User configurable property, defines which a custom function to use for deepEqual
+   * comparisons.
+   * By default, the function used is the one from the `deep-eql` package without custom comparator.
+   *
+   *     // use a custom comparator
+   *     chai.config.deepEqual = (expected, actual) => {
+   *        return chai.util.eql(expected, actual, {
+   *           comparator: (expected, actual) => {
+   *              // for non number comparison, use the default behavior
+   *              if(typeof expected !== 'number') return null;
+   *              // allow a difference of 10 between compared numbers
+   *              return typeof actual === 'number' && Math.abs(actual - expected) < 10
+   *           }
+   *        })
+   *     };
+   *
+   * @param {Function}
+   * @api public
+   */
+  deepEqual: null
 };
 
 // lib/chai/utils/inspect.js
@@ -1356,6 +1354,7 @@ function Assertion(obj, msg, ssfi, lockSsfi) {
   flag(this, "lockSsfi", lockSsfi);
   flag(this, "object", obj);
   flag(this, "message", msg);
+  flag(this, "eql", config.deepEqual || deep_eql_default);
   return proxify(this);
 }
 __name(Assertion, "Assertion");
@@ -1857,16 +1856,31 @@ Assertion.addProperty("all", function() {
   flag2(this, "all", true);
   flag2(this, "any", false);
 });
+var functionTypes = {
+  "function": ["function", "asyncfunction", "generatorfunction", "asyncgeneratorfunction"],
+  "asyncfunction": ["asyncfunction", "asyncgeneratorfunction"],
+  "generatorfunction": ["generatorfunction", "asyncgeneratorfunction"],
+  "asyncgeneratorfunction": ["asyncgeneratorfunction"]
+};
 function an(type3, msg) {
   if (msg)
     flag2(this, "message", msg);
   type3 = type3.toLowerCase();
   var obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a ";
-  this.assert(
-    type3 === type(obj).toLowerCase(),
-    "expected #{this} to be " + article + type3,
-    "expected #{this} not to be " + article + type3
-  );
+  const detectedType = type(obj).toLowerCase();
+  if (functionTypes["function"].includes(type3)) {
+    this.assert(
+      functionTypes[type3].includes(detectedType),
+      "expected #{this} to be " + article + type3,
+      "expected #{this} not to be " + article + type3
+    );
+  } else {
+    this.assert(
+      type3 === detectedType,
+      "expected #{this} to be " + article + type3,
+      "expected #{this} not to be " + article + type3
+    );
+  }
 }
 __name(an, "an");
 Assertion.addChainableMethod("an", an);
@@ -1882,7 +1896,7 @@ __name(includeChainingBehavior, "includeChainingBehavior");
 function include(val, msg) {
   if (msg)
     flag2(this, "message", msg);
-  var obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "";
+  var obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
   flagMsg = flagMsg ? flagMsg + ": " : "";
   var included = false;
   switch (objType) {
@@ -1900,7 +1914,6 @@ function include(val, msg) {
       included = obj.has(val);
       break;
     case "map":
-      var isEql = isDeep ? deep_eql_default : SameValueZero;
       obj.forEach(function(item) {
         included = included || isEql(item, val);
       });
@@ -1908,7 +1921,7 @@ function include(val, msg) {
     case "set":
       if (isDeep) {
         obj.forEach(function(item) {
-          included = included || deep_eql_default(item, val);
+          included = included || isEql(item, val);
         });
       } else {
         included = obj.has(val);
@@ -1917,7 +1930,7 @@ function include(val, msg) {
     case "array":
       if (isDeep) {
         included = obj.some(function(item) {
-          return deep_eql_default(item, val);
+          return isEql(item, val);
         });
       } else {
         included = obj.indexOf(val) !== -1;
@@ -1982,6 +1995,22 @@ Assertion.addProperty("true", function() {
     flag2(this, "negate") ? false : true
   );
 });
+Assertion.addProperty("callable", function() {
+  const val = flag2(this, "object");
+  const ssfi = flag2(this, "ssfi");
+  const message = flag2(this, "message");
+  const msg = message ? `${message}: ` : "";
+  const negate = flag2(this, "negate");
+  const assertionMessage = negate ? `${msg}expected ${inspect2(val)} not to be a callable function` : `${msg}expected ${inspect2(val)} to be a callable function`;
+  const isCallable = ["Function", "AsyncFunction", "GeneratorFunction", "AsyncGeneratorFunction"].includes(type(val));
+  if (isCallable && negate || !isCallable && !negate) {
+    throw new AssertionError(
+      assertionMessage,
+      void 0,
+      ssfi
+    );
+  }
+});
 Assertion.addProperty("false", function() {
   this.assert(
     false === flag2(this, "object"),
@@ -2098,8 +2127,9 @@ Assertion.addMethod("eq", assertEqual);
 function assertEql(obj, msg) {
   if (msg)
     flag2(this, "message", msg);
+  var eql = flag2(this, "eql");
   this.assert(
-    deep_eql_default(obj, flag2(this, "object")),
+    eql(obj, flag2(this, "object")),
     "expected #{this} to deeply equal #{exp}",
     "expected #{this} to not deeply equal #{exp}",
     obj,
@@ -2411,7 +2441,7 @@ function assertProperty(name, val, msg) {
       ssfi
     );
   }
-  var isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name];
+  var isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
   var descriptor = "";
   if (isDeep)
     descriptor += "deep ";
@@ -2436,7 +2466,7 @@ function assertProperty(name, val, msg) {
   }
   if (arguments.length > 1) {
     this.assert(
-      hasProperty2 && (isDeep ? deep_eql_default(val, value) : val === value),
+      hasProperty2 && isEql(val, value),
       "expected #{this} to have " + descriptor + inspect2(name) + " of #{exp}, but got #{act}",
       "expected #{this} to not have " + descriptor + inspect2(name) + " of #{act}",
       val,
@@ -2463,9 +2493,10 @@ function assertOwnPropertyDescriptor(name, descriptor, msg) {
     flag2(this, "message", msg);
   var obj = flag2(this, "object");
   var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
+  var eql = flag2(this, "eql");
   if (actualDescriptor && descriptor) {
     this.assert(
-      deep_eql_default(descriptor, actualDescriptor),
+      eql(descriptor, actualDescriptor),
       "expected the own property descriptor for " + inspect2(name) + " on #{this} to match " + inspect2(descriptor) + ", got " + inspect2(actualDescriptor),
       "expected the own property descriptor for " + inspect2(name) + " on #{this} to not match " + inspect2(descriptor),
       descriptor,
@@ -2574,29 +2605,21 @@ function assertKeys(keys) {
   if (!keys.length) {
     throw new AssertionError(flagMsg + "keys required", void 0, ssfi);
   }
-  var len = keys.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys;
+  var len = keys.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
   if (!any && !all) {
     all = true;
   }
   if (any) {
     ok = expected.some(function(expectedKey) {
       return actual.some(function(actualKey) {
-        if (isDeep) {
-          return deep_eql_default(expectedKey, actualKey);
-        } else {
-          return expectedKey === actualKey;
-        }
+        return isEql(expectedKey, actualKey);
       });
     });
   }
   if (all) {
     ok = expected.every(function(expectedKey) {
       return actual.some(function(actualKey) {
-        if (isDeep) {
-          return deep_eql_default(expectedKey, actualKey);
-        } else {
-          return expectedKey === actualKey;
-        }
+        return isEql(expectedKey, actualKey);
       });
     });
     if (!flag2(this, "contains")) {
@@ -2832,7 +2855,7 @@ Assertion.addMethod("members", function(subset, msg) {
     failMsg = "expected #{this} to have the same " + subject + " as #{exp}";
     failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}";
   }
-  var cmp = flag2(this, "deep") ? deep_eql_default : void 0;
+  var cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
   this.assert(
     isSubsetOf(subset, obj, cmp, contains, ordered),
     failMsg,
@@ -2845,7 +2868,7 @@ Assertion.addMethod("members", function(subset, msg) {
 function oneOf(list, msg) {
   if (msg)
     flag2(this, "message", msg);
-  var expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep");
+  var expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql");
   new Assertion(list, flagMsg, ssfi, true).to.be.an("array");
   if (contains) {
     this.assert(
@@ -2861,7 +2884,7 @@ function oneOf(list, msg) {
     if (isDeep) {
       this.assert(
         list.some(function(possibility) {
-          return deep_eql_default(expected, possibility);
+          return eql(expected, possibility);
         }),
         "expected #{this} to deeply equal one of #{exp}",
         "expected #{this} to deeply equal one of #{exp}",
@@ -3227,11 +3250,11 @@ assert.isUndefined = function(val, msg) {
 assert.isDefined = function(val, msg) {
   new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
 };
-assert.isFunction = function(val, msg) {
-  new Assertion(val, msg, assert.isFunction, true).to.be.a("function");
+assert.isCallable = function(val, msg) {
+  new Assertion(val, msg, assert.isCallable, true).is.callable;
 };
-assert.isNotFunction = function(val, msg) {
-  new Assertion(val, msg, assert.isNotFunction, true).to.not.be.a("function");
+assert.isNotCallable = function(val, msg) {
+  new Assertion(val, msg, assert.isNotCallable, true).is.not.callable;
 };
 assert.isObject = function(val, msg) {
   new Assertion(val, msg, assert.isObject, true).to.be.a("object");
@@ -3672,7 +3695,7 @@ assert.isNotEmpty = function(val, msg) {
 (/* @__PURE__ */ __name(function alias(name, as) {
   assert[as] = assert[name];
   return alias;
-}, "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");
+}, "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")("isCallable", "isFunction")("isNotCallable", "isNotFunction");
 
 // lib/chai.js
 var used = [];
@@ -3774,6 +3797,8 @@ export {
  *   from within another assertion. It's also temporarily set to `true` before
  *   an overwritten assertion gets called by the overwriting assertion.
  *
+ * - `eql`: This flag contains the deepEqual function to be used by the assertion.
+ *
  * @param {Mixed} obj target of the assertion
  * @param {String} msg (optional) custom error message
  * @param {Function} ssfi (optional) starting point for removing stack frames

package/lib/chai/assertion.js

@@ -54,7 +54,7 @@ export function Assertion (obj, msg, ssfi, lockSsfi) {
   util.flag(this, 'lockSsfi', lockSsfi);
   util.flag(this, 'object', obj);
   util.flag(this, 'message', msg);
-  util.flag(this, 'eql', config.deepEqual ?? util.eql);
+  util.flag(this, 'eql', config.deepEqual || util.eql);
 
   return util.proxify(this);
 }

package/lib/chai/core/assertions.js

@@ -239,6 +239,13 @@ Assertion.addProperty('all', function () {
   flag(this, 'any', false);
 });
 
+const functionTypes = {
+  'function': ['function', 'asyncfunction', 'generatorfunction', 'asyncgeneratorfunction'],
+  'asyncfunction': ['asyncfunction', 'asyncgeneratorfunction'],
+  'generatorfunction': ['generatorfunction', 'asyncgeneratorfunction'],
+  'asyncgeneratorfunction': ['asyncgeneratorfunction']
+}
+
 /**
  * ### .a(type[, msg])
  *
@@ -298,18 +305,27 @@ Assertion.addProperty('all', function () {
  * @namespace BDD
  * @api public
  */
-
 function an (type, msg) {
   if (msg) flag(this, 'message', msg);
   type = type.toLowerCase();
   var obj = flag(this, 'object')
     , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';
 
-  this.assert(
-      type === _.type(obj).toLowerCase()
-    , 'expected #{this} to be ' + article + type
-    , 'expected #{this} not to be ' + article + type
-  );
+  const detectedType = _.type(obj).toLowerCase();
+
+  if (functionTypes['function'].includes(type)) {
+    this.assert(
+        functionTypes[type].includes(detectedType)
+      , 'expected #{this} to be ' + article + type
+      , 'expected #{this} not to be ' + article + type
+    );
+  } else {
+    this.assert(
+      type === detectedType
+      , 'expected #{this} to be ' + article + type
+      , 'expected #{this} not to be ' + article + type
+    );
+  }
 }
 
 Assertion.addChainableMethod('an', an);
@@ -672,6 +688,43 @@ Assertion.addProperty('true', function () {
   );
 });
 
+/**
+ * ### .callable
+ *
+ * Asserts that the target a callable function.
+ *
+ *     expect(console.log).to.be.callable;
+ *
+ * A custom error message can be given as the second argument to `expect`.
+ *
+ *     expect('not a function', 'nooo why fail??').to.be.callable;
+ *
+ * @name callable
+ * @namespace BDD
+ * @api public
+ */
+Assertion.addProperty('callable', function () {
+  const val = flag(this, 'object')
+  const ssfi = flag(this, 'ssfi')
+  const message = flag(this, 'message')
+  const msg = message ? `${message}: ` : ''
+  const negate = flag(this, 'negate');
+
+  const assertionMessage = negate ?
+    `${msg}expected ${_.inspect(val)} not to be a callable function` : 
+    `${msg}expected ${_.inspect(val)} to be a callable function`;
+
+  const isCallable = ['Function', 'AsyncFunction', 'GeneratorFunction', 'AsyncGeneratorFunction'].includes(_.type(val));
+
+  if ((isCallable && negate) || (!isCallable && !negate)) {
+    throw new AssertionError(
+      assertionMessage,
+      undefined,
+      ssfi
+    );
+  }
+});
+
 /**
  * ### .false
  *

package/lib/chai/interface/assert.js

@@ -8,6 +8,7 @@ import * as chai from '../../../index.js';
 import {Assertion} from '../assertion.js';
 import {flag, inspect} from '../utils/index.js';
 import {AssertionError} from 'assertion-error';
+import {type} from '../utils/type-detect.js';
 
 /**
  * ### assert(expression, message)
@@ -553,41 +554,39 @@ assert.isDefined = function (val, msg) {
 };
 
 /**
- * ### .isFunction(value, [message])
+ * ### .isCallable(value, [message])
  *
- * Asserts that `value` is a function.
+ * Asserts that `value` is a callable function.
  *
  *     function serveTea() { return 'cup of tea'; };
- *     assert.isFunction(serveTea, 'great, we can have tea now');
+ *     assert.isCallable(serveTea, 'great, we can have tea now');
  *
- * @name isFunction
+ * @name isCallable
  * @param {Mixed} value
  * @param {String} message
  * @namespace Assert
  * @api public
  */
-
-assert.isFunction = function (val, msg) {
-  new Assertion(val, msg, assert.isFunction, true).to.be.a('function');
-};
+assert.isCallable = function (val, msg) {
+  new Assertion(val, msg, assert.isCallable, true).is.callable;
+}
 
 /**
- * ### .isNotFunction(value, [message])
+ * ### .isNotCallable(value, [message])
  *
- * Asserts that `value` is _not_ a function.
+ * Asserts that `value` is _not_ a callable function.
  *
  *     var serveTea = [ 'heat', 'pour', 'sip' ];
- *     assert.isNotFunction(serveTea, 'great, we have listed the steps');
+ *     assert.isNotCallable(serveTea, 'great, we have listed the steps');
  *
- * @name isNotFunction
+ * @name isNotCallable
  * @param {Mixed} value
  * @param {String} message
  * @namespace Assert
  * @api public
  */
-
-assert.isNotFunction = function (val, msg) {
-  new Assertion(val, msg, assert.isNotFunction, true).to.not.be.a('function');
+assert.isNotCallable = function (val, msg) {
+  new Assertion(val, msg, assert.isNotCallable, true).is.not.callable;
 };
 
 /**
@@ -3104,4 +3103,6 @@ assert.isNotEmpty = function(val, msg) {
 ('isFrozen', 'frozen')
 ('isNotFrozen', 'notFrozen')
 ('isEmpty', 'empty')
-('isNotEmpty', 'notEmpty');
+('isNotEmpty', 'notEmpty')
+('isCallable', 'isFunction')
+('isNotCallable', 'isNotFunction')

package/package.json

@@ -18,7 +18,7 @@
     "Veselin Todorov <hi@vesln.com>",
     "John Firebaugh <john.firebaugh@gmail.com>"
   ],
-  "version": "5.0.0",
+  "version": "5.0.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/chaijs/chai"
@@ -44,16 +44,15 @@
     "assertion-error": "^2.0.1",
     "check-error": "^2.0.0",
     "deep-eql": "^5.0.1",
-    "loupe": "^3.0.0",
+    "loupe": "^3.1.0",
     "pathval": "^2.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
-    "@web/dev-server-rollup": "^0.5.4",
-    "@web/test-runner": "^0.17.2",
-    "@web/test-runner-playwright": "^0.10.2",
-    "bump-cli": "^1.1.3",
-    "esbuild": "^0.17.3",
-    "mocha": "^8.3.0"
+    "@web/dev-server-rollup": "^0.6.1",
+    "@web/test-runner": "^0.18.0",
+    "@web/test-runner-playwright": "^0.11.0",
+    "esbuild": "^0.19.10",
+    "mocha": "^10.2.0"
   }
 }

package/bower.json

@@ -1,26 +0,0 @@
-{
-  "name": "chai",
-  "description": "BDD/TDD assertion library for node.js and the browser. Test framework agnostic.",
-  "license": "MIT",
-  "keywords": [
-    "test",
-    "assertion",
-    "assert",
-    "testing",
-    "chai"
-  ],
-  "main": "chai.js",
-  "ignore": [
-    "build",
-    "components",
-    "lib",
-    "node_modules",
-    "support",
-    "test",
-    "index.js",
-    "Makefile",
-    ".*"
-  ],
-  "dependencies": {},
-  "devDependencies": {}
-}

package/karma.conf.cjs

@@ -1,35 +0,0 @@
-module.exports = function(config) {
-  config.set({
-      frameworks: [ 'mocha' ]
-    , files: [
-        { pattern: 'chai.js', type: 'module', included: false, served: true }
-      , { pattern: 'test/bootstrap/index.js', type: 'module'}
-      , { pattern: 'test/*.js', type: 'module' }
-      , { pattern: 'test/type-detect/*.js', type: 'module' }
-      ]
-    , reporters: [ 'progress' ]
-    , colors: true
-    , logLevel: config.LOG_INFO
-    , autoWatch: false
-    , browsers: [ 'HeadlessChrome' ]
-    , customLaunchers: {
-      HeadlessChrome: {
-      base: 'ChromeHeadless'
-    , flags: [ '--no-sandbox',]
-    , }
-    , }
-    , browserDisconnectTimeout: 10000
-    , browserDisconnectTolerance: 2
-    , browserNoActivityTimeout: 20000
-    , singleRun: true
-  });
-
-  switch (process.env.CHAI_TEST_ENV) {
-    case 'sauce':
-      require('./karma.sauce')(config);
-      break;
-    default:
-      // ...
-      break;
-  };
-};

package/karma.sauce.js

@@ -1,41 +0,0 @@
-var version = require('./package.json').version;
-var ts = new Date().getTime();
-
-module.exports = function(config) {
-  var auth;
-
-  try {
-    auth = require('./test/auth/index');
-  } catch(ex) {
-    auth = {};
-    auth.SAUCE_USERNAME = process.env.SAUCE_USERNAME || null;
-    auth.SAUCE_ACCESS_KEY = process.env.SAUCE_ACCESS_KEY || null;
-  }
-
-  if (!auth.SAUCE_USERNAME || !auth.SAUCE_ACCESS_KEY) return;
-  if (process.env.SKIP_SAUCE) return;
-
-  var branch = process.env.TRAVIS_BRANCH || 'local'
-  var browserConfig = require('./sauce.browsers');
-  var browsers = Object.keys(browserConfig);
-  var tags = [ 'chaijs_' + version, auth.SAUCE_USERNAME + '@' + branch ];
-  var tunnel = process.env.TRAVIS_JOB_NUMBER || ts;
-
-  if (process.env.TRAVIS_JOB_NUMBER) {
-    tags.push('travis@' + process.env.TRAVIS_JOB_NUMBER);
-  }
-
-  config.browsers = config.browsers.concat(browsers);
-  Object.assign(config.customLaunchers, browserConfig);
-  config.reporters.push('saucelabs');
-  config.captureTimeout = 300000;
-
-  config.sauceLabs = {
-      username: auth.SAUCE_USERNAME
-    , accessKey: auth.SAUCE_ACCESS_KEY
-    , startConnect: ('TRAVIS' in process.env) === false
-    , tags: tags
-    , testName: 'ChaiJS'
-    , tunnelIdentifier: tunnel
-  };
-};

package/sauce.browsers.js

@@ -1,106 +0,0 @@
-
-/*!
- * Chrome
- */
-
-exports['SL_Chrome'] = {
-    base: 'SauceLabs'
-  , browserName: 'chrome'
-};
-
-/*!
- * Firefox
- */
-
- exports['SL_Firefox'] = {
-     base: 'SauceLabs'
-   , browserName: 'firefox'
- };
-
- exports['SL_Firefox_ESR'] = {
-     base: 'SauceLabs'
-   , browserName: 'firefox'
-   , version: 38
- };
-
-/*!
- * Internet Explorer
- */
-
-exports['SL_IE'] = {
-    base: 'SauceLabs'
-  , browserName: 'internet explorer'
-};
-
-/*!
- * TODO: fails because of Uint8Array support
- *
-exports['SL_IE_Old'] = {
-    base: 'SauceLabs'
-  , browserName: 'internet explorer'
-  , version: 10
-};
-*/
-
-exports['SL_Edge'] = {
-    base: 'SauceLabs'
-  , browserName: 'microsoftedge'
-};
-
-/*!
- * Safari
- */
-
-exports['SL_Safari'] = {
-    base: 'SauceLabs'
-  , browserName: 'safari'
-  , platform: 'Mac 10.11'
-};
-
-/*!
- * iPhone
- */
-
-/*!
- * TODO: These take forever to boot or shut down. Causes timeout.
- *
-
-exports['SL_iPhone_6'] = {
-    base: 'SauceLabs'
-  , browserName: 'iphone'
-  , platform: 'Mac 10.8'
-  , version: '6'
-};
-
-exports['SL_iPhone_5-1'] = {
-    base: 'SauceLabs'
-  , browserName: 'iphone'
-  , platform: 'Mac 10.8'
-  , version: '5.1'
-};
-
-exports['SL_iPhone_5'] = {
-    base: 'SauceLabs'
-  , browserName: 'iphone'
-  , platform: 'Mac 10.6'
-  , version: '5'
-};
-
-*/
-
-/*!
- * Android
- */
-
-/*!
- * TODO: fails because of error serialization
- *
-
-exports['SL_Android_4'] = {
-    base: 'SauceLabs'
-  , browserName: 'android'
-  , platform: 'Linux'
-  , version: '4'
-};
-
-*/