tutuca 0.9.112 → 0.9.114

package/dist/chai.js

@@ -1,6 +1,6 @@
 // node_modules/chai/index.js
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -160,7 +160,7 @@ var _AssertionError = class _AssertionError2 extends Error {
       name: this.name,
       message: this.message,
       ok: false,
-      stack: stack !== false ? this.stack : undefined
+      stack: stack !== false ? this.stack : void 0
     };
   }
 };
@@ -184,7 +184,11 @@ function expectTypes(obj, types) {
   if (!types.some(function(expected) {
     return objType === expected;
   })) {
-    throw new AssertionError(flagMsg + "object tested must be " + str + ", but " + objType + " given", undefined, ssfi);
+    throw new AssertionError(
+      flagMsg + "object tested must be " + str + ", but " + objType + " given",
+      void 0,
+      ssfi
+    );
   }
 }
 __name(expectTypes, "expectTypes");
@@ -197,9 +201,12 @@ var ansiColors = {
   dim: ["2", "22"],
   italic: ["3", "23"],
   underline: ["4", "24"],
+  // 5 & 6 are blinking
   inverse: ["7", "27"],
   hidden: ["8", "28"],
   strike: ["9", "29"],
+  // 10-20 are fonts
+  // 21-29 are resets for 1-9
   black: ["30", "39"],
   red: ["31", "39"],
   green: ["32", "39"],
@@ -248,6 +255,7 @@ function normaliseOptions({
   maxArrayLength = Infinity,
   breakLength = Infinity,
   seen = [],
+  // eslint-disable-next-line no-shadow
   truncate: truncate2 = Infinity,
   stylize = String
 } = {}, inspect3) {
@@ -300,7 +308,7 @@ function inspectList(list, options, inspectItem, separator = ", ") {
   let output = "";
   let peek = "";
   let truncated = "";
-  for (let i = 0;i < size; i += 1) {
+  for (let i = 0; i < size; i += 1) {
     const last = i + 1 === list.length;
     const secondToLast = i + 2 === list.length;
     truncated = `${truncator}(${list.length - i})`;
@@ -378,7 +386,7 @@ function inspectTypedArray(array, options) {
   if (!array.length && !nonIndexProperties.length)
     return `${name}[]`;
   let output = "";
-  for (let i = 0;i < array.length; i++) {
+  for (let i = 0; i < array.length; i++) {
     const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
     options.truncate -= string.length;
     if (array[i] !== array.length && options.truncate <= 3) {
@@ -485,7 +493,7 @@ __name(inspectSet, "inspectSet");
 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": "\\t",
+  "	": "\\t",
   "\n": "\\n",
   "\f": "\\f",
   "\r": "\\r",
@@ -600,8 +608,7 @@ function inspectAttribute([key, value], options) {
 }
 __name(inspectAttribute, "inspectAttribute");
 function inspectNodeCollection(collection, options) {
-  return inspectList(collection, options, inspectNode, `
-`);
+  return inspectList(collection, options, inspectNode, "\n");
 }
 __name(inspectNodeCollection, "inspectNodeCollection");
 function inspectNode(node, options) {
@@ -639,7 +646,7 @@ __name(inspectHTML, "inspectHTML");
 var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
 var chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect";
 var nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-var constructorMap = /* @__PURE__ */ new WeakMap;
+var constructorMap = /* @__PURE__ */ new WeakMap();
 var stringTagMap = {};
 var baseTypesMap = {
   undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),
@@ -655,6 +662,7 @@ var baseTypesMap = {
   function: inspectFunction,
   Function: inspectFunction,
   symbol: inspectSymbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
   Symbol: inspectSymbol,
   Array: inspectArray,
   Date: inspectDate,
@@ -662,6 +670,7 @@ var baseTypesMap = {
   Set: inspectSet,
   RegExp: inspectRegExp,
   Promise: promise_default,
+  // WeakSet, WeakMap are totally opaque to us
   WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{…}", "special"), "WeakSet"),
   WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{…}", "special"), "WeakMap"),
   Arguments: inspectArguments,
@@ -738,11 +747,110 @@ function inspect(value, opts = {}) {
 }
 __name(inspect, "inspect");
 var config = {
+  /**
+   * ### config.includeStack
+   *
+   * User configurable property, influences whether stack trace
+   * is included in Assertion error message. Default of false
+   * suppresses stack trace in the error message.
+   *
+   *     chai.config.includeStack = true;  // enable stack on error
+   *
+   * @param {boolean}
+   * @public
+   */
   includeStack: false,
+  /**
+   * ### config.showDiff
+   *
+   * User configurable property, influences whether or not
+   * the `showDiff` flag should be included in the thrown
+   * AssertionErrors. `false` will always be `false`; `true`
+   * will be true when the assertion has requested a diff
+   * be shown.
+   *
+   * @param {boolean}
+   * @public
+   */
   showDiff: true,
+  /**
+   * ### config.truncateThreshold
+   *
+   * User configurable property, sets length threshold for actual and
+   * expected values in assertion errors. If this threshold is exceeded, for
+   * example for large data structures, the value is replaced with something
+   * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.
+   *
+   * Set it to zero if you want to disable truncating altogether.
+   *
+   * This is especially userful when doing assertions on arrays: having this
+   * set to a reasonable large value makes the failure messages readily
+   * inspectable.
+   *
+   *     chai.config.truncateThreshold = 0;  // disable truncating
+   *
+   * @param {number}
+   * @public
+   */
   truncateThreshold: 40,
+  /**
+   * ### config.useProxy
+   *
+   * User configurable property, defines if chai will use a Proxy to throw
+   * an error when a non-existent property is read, which protects users
+   * from typos when using property-based assertions.
+   *
+   * Set it to false if you want to disable this feature.
+   *
+   *     chai.config.useProxy = false;  // disable use of Proxy
+   *
+   * This feature is automatically disabled regardless of this config value
+   * in environments that don't support proxies.
+   *
+   * @param {boolean}
+   * @public
+   */
   useProxy: true,
+  /**
+   * ### config.proxyExcludedKeys
+   *
+   * User configurable property, defines which properties should be ignored
+   * instead of throwing an error if they do not exist on the assertion.
+   * This is only applied if the environment Chai is running in supports proxies and
+   * if the `useProxy` configuration setting is enabled.
+   * By default, `then` and `inspect` will not throw an error if they do not exist on the
+   * assertion object because the `.inspect` property is read by `util.inspect` (for example, when
+   * using `console.log` on the assertion object) and `.then` is necessary for promise type-checking.
+   *
+   *     // By default these keys will not throw an error if they do not exist on the assertion object
+   *     chai.config.proxyExcludedKeys = ['then', 'inspect'];
+   *
+   * @param {Array}
+   * @public
+   */
   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}
+   * @public
+   */
   deepEqual: null
 };
 function inspect2(obj, showHidden, depth, colors) {
@@ -780,8 +888,7 @@ function getMessage2(obj, args) {
   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);
@@ -862,7 +969,7 @@ function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {
   if (leftHandMap) {
     leftHandMap.set(rightHandOperand, result);
   } else {
-    leftHandMap = new MemoizeMap;
+    leftHandMap = new MemoizeMap();
     leftHandMap.set(rightHandOperand, result);
     memoizeMap.set(leftHandOperand, leftHandMap);
   }
@@ -884,7 +991,8 @@ function simpleEqual(leftHandOperand, rightHandOperand) {
   if (leftHandOperand === rightHandOperand) {
     return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;
   }
-  if (leftHandOperand !== leftHandOperand && rightHandOperand !== rightHandOperand) {
+  if (leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare
+  rightHandOperand !== rightHandOperand) {
     return true;
   }
   if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
@@ -895,7 +1003,7 @@ function simpleEqual(leftHandOperand, rightHandOperand) {
 __name(simpleEqual, "simpleEqual");
 function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {
   options = options || {};
-  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap;
+  options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();
   var comparator = options && options.comparator;
   var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);
   if (memoizeResultLeft !== null) {
@@ -1067,7 +1175,7 @@ __name(getEnumerableKeys, "getEnumerableKeys");
 function getEnumerableSymbols(target) {
   var keys = [];
   var allKeys = Object.getOwnPropertySymbols(target);
-  for (var i = 0;i < allKeys.length; i += 1) {
+  for (var i = 0; i < allKeys.length; i += 1) {
     var key = allKeys[i];
     if (Object.getOwnPropertyDescriptor(target, key).enumerable) {
       keys.push(key);
@@ -1081,7 +1189,7 @@ function keysEqual(leftHandOperand, rightHandOperand, keys, options) {
   if (length === 0) {
     return true;
   }
-  for (var i = 0;i < length; i += 1) {
+  for (var i = 0; i < length; i += 1) {
     if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) {
       return false;
     }
@@ -1158,7 +1266,7 @@ function internalGetPathValue(obj, parsed, pathDepth) {
   let temporaryValue = obj;
   let res = null;
   pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth;
-  for (let i = 0;i < pathDepth; i++) {
+  for (let i = 0; i < pathDepth; i++) {
     const part = parsed[i];
     if (temporaryValue) {
       if (typeof part.p === "undefined") {
@@ -1187,6 +1295,41 @@ function getPathInfo(obj, path) {
 }
 __name(getPathInfo, "getPathInfo");
 var _Assertion = class _Assertion2 {
+  /**
+   * Creates object for chaining.
+   * `Assertion` objects contain metadata in the form of flags. Three flags can
+   * be assigned during instantiation by passing arguments to this constructor:
+   *
+   * - `object`: This flag contains the target of the assertion. For example, in
+   * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
+   * contain `numKittens` so that the `equal` assertion can reference it when
+   * needed.
+   *
+   * - `message`: This flag contains an optional custom error message to be
+   * prepended to the error message that's generated by the assertion when it
+   * fails.
+   *
+   * - `ssfi`: This flag stands for "start stack function indicator". It
+   * contains a function reference that serves as the starting point for
+   * removing frames from the stack trace of the error that's created by the
+   * assertion when it fails. The goal is to provide a cleaner stack trace to
+   * end users by removing Chai's internal functions. Note that it only works
+   * in environments that support `Error.captureStackTrace`, and only when
+   * `Chai.config.includeStack` hasn't been set to `false`.
+   *
+   * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag
+   * should retain its current value, even as assertions are chained off of
+   * this object. This is usually set to `true` when creating a new assertion
+   * 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 {unknown} obj target of the assertion
+   * @param {string} [msg] (optional) custom error message
+   * @param {Function} [ssfi] (optional) starting point for removing stack frames
+   * @param {boolean} [lockSsfi] (optional) whether or not the ssfi flag is locked
+   */
   constructor(obj, msg, ssfi, lockSsfi) {
     __publicField(this, "__flags", {});
     flag(this, "ssfi", ssfi || _Assertion2);
@@ -1196,48 +1339,97 @@ var _Assertion = class _Assertion2 {
     flag(this, "eql", config.deepEqual || deep_eql_default);
     return proxify(this);
   }
+  /** @returns {boolean} */
   static get includeStack() {
-    console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+    console.warn(
+      "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
+    );
     return config.includeStack;
   }
+  /** @param {boolean} value */
   static set includeStack(value) {
-    console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+    console.warn(
+      "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
+    );
     config.includeStack = value;
   }
+  /** @returns {boolean} */
   static get showDiff() {
-    console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+    console.warn(
+      "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
+    );
     return config.showDiff;
   }
+  /** @param {boolean} value */
   static set showDiff(value) {
-    console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+    console.warn(
+      "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
+    );
     config.showDiff = value;
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   */
   static addProperty(name, fn) {
     addProperty(this.prototype, name, fn);
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   */
   static addMethod(name, fn) {
     addMethod(this.prototype, name, fn);
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   * @param {Function} chainingBehavior
+   */
   static addChainableMethod(name, fn, chainingBehavior) {
     addChainableMethod(this.prototype, name, fn, chainingBehavior);
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   */
   static overwriteProperty(name, fn) {
     overwriteProperty(this.prototype, name, fn);
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   */
   static overwriteMethod(name, fn) {
     overwriteMethod(this.prototype, name, fn);
   }
+  /**
+   * @param {string} name
+   * @param {Function} fn
+   * @param {Function} chainingBehavior
+   */
   static overwriteChainableMethod(name, fn, chainingBehavior) {
     overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
   }
+  /**
+   * ### .assert(expression, message, negateMessage, expected, actual, showDiff)
+   *
+   * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
+   *
+   * @name assert
+   * @param {unknown} _expr to be tested
+   * @param {string | Function} msg or function that returns message to display if expression fails
+   * @param {string | Function} _negateMsg or function that returns negatedMessage to display if negated expression fails
+   * @param {unknown} expected value (remember to check for negation)
+   * @param {unknown} _actual (optional) will default to `this.obj`
+   * @param {boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
+   * @returns {void}
+   */
   assert(_expr, msg, _negateMsg, expected, _actual, showDiff) {
     const ok = test(this, arguments);
-    if (showDiff !== false)
-      showDiff = true;
-    if (expected === undefined && _actual === undefined)
-      showDiff = false;
-    if (config.showDiff !== true)
-      showDiff = false;
+    if (false !== showDiff) showDiff = true;
+    if (void 0 === expected && void 0 === _actual) showDiff = false;
+    if (true !== config.showDiff) showDiff = false;
     if (!ok) {
       msg = getMessage2(this, arguments);
       const actual = getActual(this, arguments);
@@ -1250,19 +1442,34 @@ var _Assertion = class _Assertion2 {
       if (operator) {
         assertionErrorObjectProperties.operator = operator;
       }
-      throw new AssertionError(msg, assertionErrorObjectProperties, config.includeStack ? this.assert : flag(this, "ssfi"));
+      throw new AssertionError(
+        msg,
+        assertionErrorObjectProperties,
+        // @ts-expect-error Not sure what to do about these types yet
+        config.includeStack ? this.assert : flag(this, "ssfi")
+      );
     }
   }
+  /**
+   * Quick reference to stored `actual` value for plugin developers.
+   *
+   * @returns {unknown}
+   */
   get _obj() {
     return flag(this, "object");
   }
+  /**
+   * Quick reference to stored `actual` value for plugin developers.
+   *
+   * @param {unknown} val
+   */
   set _obj(val) {
     flag(this, "object", val);
   }
 };
 __name(_Assertion, "Assertion");
 var Assertion = _Assertion;
-var events = new EventTarget;
+var events = new EventTarget();
 var _PluginEvent = class _PluginEvent2 extends Event {
   constructor(type3, name, fn) {
     super(type3);
@@ -1277,16 +1484,16 @@ function isProxyEnabled() {
 }
 __name(isProxyEnabled, "isProxyEnabled");
 function addProperty(ctx, name, getter) {
-  getter = getter === undefined ? function() {} : getter;
+  getter = getter === void 0 ? function() {
+  } : getter;
   Object.defineProperty(ctx, name, {
     get: /* @__PURE__ */ __name(function propertyGetter() {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
         flag(this, "ssfi", propertyGetter);
       }
       let result = getter.call(this);
-      if (result !== undefined)
-        return result;
-      let newAssertion = new Assertion;
+      if (result !== void 0) return result;
+      let newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
     }, "propertyGetter"),
@@ -1295,16 +1502,20 @@ function addProperty(ctx, name, getter) {
   events.dispatchEvent(new PluginEvent("addProperty", name, getter));
 }
 __name(addProperty, "addProperty");
-var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {}, "length");
+var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
+}, "length");
 function addLengthGuard(fn, assertionName, isChainable) {
-  if (!fnLengthDesc.configurable)
-    return fn;
+  if (!fnLengthDesc.configurable) return fn;
   Object.defineProperty(fn, "length", {
     get: /* @__PURE__ */ __name(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 + '".'
+      );
     }, "get")
   });
   return fn;
@@ -1328,18 +1539,23 @@ function getProperties(object) {
 __name(getProperties, "getProperties");
 var builtins = ["__flags", "__methods", "_obj", "assert"];
 function proxify(obj, nonChainableMethodName) {
-  if (!isProxyEnabled())
-    return obj;
+  if (!isProxyEnabled()) return obj;
   return new Proxy(obj, {
     get: /* @__PURE__ */ __name(function proxyGetter(target, property) {
       if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
         if (nonChainableMethodName) {
-          throw Error("Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".');
+          throw Error(
+            "Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".'
+          );
         }
         let suggestion = null;
         let suggestionDistance = 4;
         getProperties(target).forEach(function(prop) {
-          if (!Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1) {
+          if (
+            // we actually mean to check `Object.prototype` here
+            // eslint-disable-next-line no-prototype-builtins
+            !Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1
+          ) {
             let dist = stringDistanceCapped(property, prop, suggestionDistance);
             if (dist < suggestionDistance) {
               suggestion = prop;
@@ -1348,7 +1564,9 @@ function proxify(obj, nonChainableMethodName) {
           }
         });
         if (suggestion !== null) {
-          throw Error("Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?');
+          throw Error(
+            "Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?'
+          );
         } else {
           throw Error("Invalid Chai property: " + property);
         }
@@ -1366,21 +1584,25 @@ function stringDistanceCapped(strA, strB, cap) {
     return cap;
   }
   let memo = [];
-  for (let i = 0;i <= strA.length; i++) {
+  for (let i = 0; i <= strA.length; i++) {
     memo[i] = Array(strB.length + 1).fill(0);
     memo[i][0] = i;
   }
-  for (let j = 0;j < strB.length; j++) {
+  for (let j = 0; j < strB.length; j++) {
     memo[0][j] = j;
   }
-  for (let i = 1;i <= strA.length; i++) {
+  for (let i = 1; i <= strA.length; i++) {
     let ch = strA.charCodeAt(i - 1);
-    for (let j = 1;j <= strB.length; j++) {
+    for (let j = 1; j <= strB.length; j++) {
       if (Math.abs(i - j) >= cap) {
         memo[i][j] = cap;
         continue;
       }
-      memo[i][j] = Math.min(memo[i - 1][j] + 1, memo[i][j - 1] + 1, memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1));
+      memo[i][j] = Math.min(
+        memo[i - 1][j] + 1,
+        memo[i][j - 1] + 1,
+        memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
+      );
     }
   }
   return memo[strA.length][strB.length];
@@ -1392,9 +1614,8 @@ function addMethod(ctx, name, method) {
       flag(this, "ssfi", methodWrapper);
     }
     let result = method.apply(this, arguments);
-    if (result !== undefined)
-      return result;
-    let newAssertion = new Assertion;
+    if (result !== void 0) return result;
+    let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "methodWrapper");
@@ -1404,9 +1625,9 @@ function addMethod(ctx, name, method) {
 }
 __name(addMethod, "addMethod");
 function overwriteProperty(ctx, name, getter) {
-  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {}, "_super");
-  if (_get && typeof _get.get === "function")
-    _super = _get.get;
+  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
+  }, "_super");
+  if (_get && "function" === typeof _get.get) _super = _get.get;
   Object.defineProperty(ctx, name, {
     get: /* @__PURE__ */ __name(function overwritingPropertyGetter() {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
@@ -1416,10 +1637,10 @@ function overwriteProperty(ctx, name, getter) {
       flag(this, "lockSsfi", true);
       let result = getter(_super).call(this);
       flag(this, "lockSsfi", origLockSsfi);
-      if (result !== undefined) {
+      if (result !== void 0) {
         return result;
       }
-      let newAssertion = new Assertion;
+      let newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
     }, "overwritingPropertyGetter"),
@@ -1431,8 +1652,7 @@ function overwriteMethod(ctx, name, method) {
   let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
     throw new Error(name + " is not a function");
   }, "_super");
-  if (_method && typeof _method === "function")
-    _super = _method;
+  if (_method && "function" === typeof _method) _super = _method;
   let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", overwritingMethodWrapper);
@@ -1441,10 +1661,10 @@ function overwriteMethod(ctx, name, method) {
     flag(this, "lockSsfi", true);
     let result = method(_super).apply(this, arguments);
     flag(this, "lockSsfi", origLockSsfi);
-    if (result !== undefined) {
+    if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion;
+    let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingMethodWrapper");
@@ -1453,11 +1673,11 @@ function overwriteMethod(ctx, name, method) {
 }
 __name(overwriteMethod, "overwriteMethod");
 var canSetPrototype = typeof Object.setPrototypeOf === "function";
-var testFn = /* @__PURE__ */ __name(function() {}, "testFn");
+var testFn = /* @__PURE__ */ __name(function() {
+}, "testFn");
 var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
   let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
-  if (typeof propDesc !== "object")
-    return true;
+  if (typeof propDesc !== "object") return true;
   return !propDesc.configurable;
 });
 var call = Function.prototype.call;
@@ -1472,7 +1692,8 @@ __name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent");
 var PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent;
 function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== "function") {
-    chainingBehavior = /* @__PURE__ */ __name(function() {}, "chainingBehavior");
+    chainingBehavior = /* @__PURE__ */ __name(function() {
+    }, "chainingBehavior");
   }
   let chainableBehavior = {
     method,
@@ -1490,10 +1711,10 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
           flag(this, "ssfi", chainableMethodWrapper);
         }
         let result = chainableBehavior.method.apply(this, arguments);
-        if (result !== undefined) {
+        if (result !== void 0) {
           return result;
         }
-        let newAssertion = new Assertion;
+        let newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
       }, "chainableMethodWrapper");
@@ -1518,7 +1739,14 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
     }, "chainableMethodGetter"),
     configurable: true
   });
-  events.dispatchEvent(new PluginAddChainableMethodEvent("addChainableMethod", name, method, chainingBehavior));
+  events.dispatchEvent(
+    new PluginAddChainableMethodEvent(
+      "addChainableMethod",
+      name,
+      method,
+      chainingBehavior
+    )
+  );
 }
 __name(addChainableMethod, "addChainableMethod");
 function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
@@ -1526,20 +1754,20 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   let _chainingBehavior = chainableBehavior.chainingBehavior;
   chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
     let result = chainingBehavior(_chainingBehavior).call(this);
-    if (result !== undefined) {
+    if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion;
+    let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingChainableMethodGetter");
   let _method = chainableBehavior.method;
   chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() {
     let result = method(_method).apply(this, arguments);
-    if (result !== undefined) {
+    if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion;
+    let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingChainableMethodWrapper");
@@ -1550,8 +1778,7 @@ function compareByInspect(a, b) {
 }
 __name(compareByInspect, "compareByInspect");
 function getOwnEnumerablePropertySymbols(obj) {
-  if (typeof Object.getOwnPropertySymbols !== "function")
-    return [];
+  if (typeof Object.getOwnPropertySymbols !== "function") return [];
   return Object.getOwnPropertySymbols(obj).filter(function(sym) {
     return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
   });
@@ -1576,14 +1803,13 @@ function getOperator(obj, args) {
   if (operator) {
     return operator;
   }
-  if (typeof msg === "function")
-    msg = msg();
+  if (typeof msg === "function") msg = msg();
   msg = msg || "";
   if (!msg) {
-    return;
+    return void 0;
   }
   if (/\shave\s/.test(msg)) {
-    return;
+    return void 0;
   }
   let isObject = isObjectType(expected);
   if (/\snot\s/.test(msg)) {
@@ -1661,15 +1887,22 @@ var functionTypes = {
   asyncgeneratorfunction: ["asyncgeneratorfunction"]
 };
 function an(type3, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   type3 = type3.toLowerCase();
   let obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a ";
   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);
+    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);
+    this.assert(
+      type3 === detectedType,
+      "expected #{this} to be " + article + type3,
+      "expected #{this} not to be " + article + type3
+    );
   }
 }
 __name(an, "an");
@@ -1684,8 +1917,7 @@ function includeChainingBehavior() {
 }
 __name(includeChainingBehavior, "includeChainingBehavior");
 function include(val, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let 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 + ": " : "";
   let included = false;
@@ -1695,7 +1927,11 @@ function include(val, msg) {
       break;
     case "weakset":
       if (isDeep) {
-        throw new AssertionError(flagMsg + "unable to use .deep.include with WeakSet", undefined, ssfi);
+        throw new AssertionError(
+          flagMsg + "unable to use .deep.include with WeakSet",
+          void 0,
+          ssfi
+        );
       }
       included = obj.has(val);
       break;
@@ -1724,7 +1960,11 @@ function include(val, msg) {
       break;
     default: {
       if (val !== Object(val)) {
-        throw new AssertionError(flagMsg + "the given combination of arguments (" + objType + " and " + type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + type(val).toLowerCase(), undefined, ssfi);
+        throw new AssertionError(
+          flagMsg + "the given combination of arguments (" + objType + " and " + type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + type(val).toLowerCase(),
+          void 0,
+          ssfi
+        );
       }
       let props = Object.keys(val);
       let firstErr = null;
@@ -1743,8 +1983,7 @@ function include(val, msg) {
           if (!check_error_exports.compatibleConstructor(err, AssertionError)) {
             throw err;
           }
-          if (firstErr === null)
-            firstErr = err;
+          if (firstErr === null) firstErr = err;
           numErrs++;
         }
       }, this);
@@ -1754,7 +1993,11 @@ function include(val, msg) {
       return;
     }
   }
-  this.assert(included, "expected #{this} to " + descriptor + "include " + inspect2(val), "expected #{this} to not " + descriptor + "include " + inspect2(val));
+  this.assert(
+    included,
+    "expected #{this} to " + descriptor + "include " + inspect2(val),
+    "expected #{this} to not " + descriptor + "include " + inspect2(val)
+  );
 }
 __name(include, "include");
 Assertion.addChainableMethod("include", include, includeChainingBehavior);
@@ -1762,14 +2005,28 @@ Assertion.addChainableMethod("contain", include, includeChainingBehavior);
 Assertion.addChainableMethod("contains", include, includeChainingBehavior);
 Assertion.addChainableMethod("includes", include, includeChainingBehavior);
 Assertion.addProperty("ok", function() {
-  this.assert(flag2(this, "object"), "expected #{this} to be truthy", "expected #{this} to be falsy");
+  this.assert(
+    flag2(this, "object"),
+    "expected #{this} to be truthy",
+    "expected #{this} to be falsy"
+  );
 });
 Assertion.addProperty("true", function() {
-  this.assert(flag2(this, "object") === true, "expected #{this} to be true", "expected #{this} to be false", flag2(this, "negate") ? false : true);
+  this.assert(
+    true === flag2(this, "object"),
+    "expected #{this} to be true",
+    "expected #{this} to be false",
+    flag2(this, "negate") ? false : true
+  );
 });
 Assertion.addProperty("numeric", function() {
   const object = flag2(this, "object");
-  this.assert(["Number", "BigInt"].includes(type(object)), "expected #{this} to be numeric", "expected #{this} to not be numeric", flag2(this, "negate") ? false : true);
+  this.assert(
+    ["Number", "BigInt"].includes(type(object)),
+    "expected #{this} to be numeric",
+    "expected #{this} to not be numeric",
+    flag2(this, "negate") ? false : true
+  );
 });
 Assertion.addProperty("callable", function() {
   const val = flag2(this, "object");
@@ -1785,24 +2042,45 @@ Assertion.addProperty("callable", function() {
     "AsyncGeneratorFunction"
   ].includes(type(val));
   if (isCallable && negate || !isCallable && !negate) {
-    throw new AssertionError(assertionMessage, undefined, ssfi);
+    throw new AssertionError(assertionMessage, void 0, ssfi);
   }
 });
 Assertion.addProperty("false", function() {
-  this.assert(flag2(this, "object") === false, "expected #{this} to be false", "expected #{this} to be true", flag2(this, "negate") ? true : false);
+  this.assert(
+    false === flag2(this, "object"),
+    "expected #{this} to be false",
+    "expected #{this} to be true",
+    flag2(this, "negate") ? true : false
+  );
 });
 Assertion.addProperty("null", function() {
-  this.assert(flag2(this, "object") === null, "expected #{this} to be null", "expected #{this} not to be null");
+  this.assert(
+    null === flag2(this, "object"),
+    "expected #{this} to be null",
+    "expected #{this} not to be null"
+  );
 });
 Assertion.addProperty("undefined", function() {
-  this.assert(flag2(this, "object") === undefined, "expected #{this} to be undefined", "expected #{this} not to be undefined");
+  this.assert(
+    void 0 === flag2(this, "object"),
+    "expected #{this} to be undefined",
+    "expected #{this} not to be undefined"
+  );
 });
 Assertion.addProperty("NaN", function() {
-  this.assert(isNaN2(flag2(this, "object")), "expected #{this} to be NaN", "expected #{this} not to be NaN");
+  this.assert(
+    isNaN2(flag2(this, "object")),
+    "expected #{this} to be NaN",
+    "expected #{this} not to be NaN"
+  );
 });
 function assertExist() {
   let val = flag2(this, "object");
-  this.assert(val !== null && val !== undefined, "expected #{this} to exist", "expected #{this} to not exist");
+  this.assert(
+    val !== null && val !== void 0,
+    "expected #{this} to exist",
+    "expected #{this} to not exist"
+  );
 }
 __name(assertExist, "assertExist");
 Assertion.addProperty("exist", assertExist);
@@ -1821,29 +2099,44 @@ Assertion.addProperty("empty", function() {
       break;
     case "weakmap":
     case "weakset":
-      throw new AssertionError(flagMsg + ".empty was passed a weak collection", undefined, ssfi);
+      throw new AssertionError(
+        flagMsg + ".empty was passed a weak collection",
+        void 0,
+        ssfi
+      );
     case "function": {
       const msg = flagMsg + ".empty was passed a function " + getName(val);
-      throw new AssertionError(msg.trim(), undefined, ssfi);
+      throw new AssertionError(msg.trim(), void 0, ssfi);
     }
     default:
       if (val !== Object(val)) {
-        throw new AssertionError(flagMsg + ".empty was passed non-string primitive " + inspect2(val), undefined, ssfi);
+        throw new AssertionError(
+          flagMsg + ".empty was passed non-string primitive " + inspect2(val),
+          void 0,
+          ssfi
+        );
       }
       itemsCount = Object.keys(val).length;
   }
-  this.assert(itemsCount === 0, "expected #{this} to be empty", "expected #{this} not to be empty");
+  this.assert(
+    0 === itemsCount,
+    "expected #{this} to be empty",
+    "expected #{this} not to be empty"
+  );
 });
 function checkArguments() {
   let obj = flag2(this, "object"), type3 = type(obj);
-  this.assert(type3 === "Arguments", "expected #{this} to be arguments but got " + type3, "expected #{this} to not be arguments");
+  this.assert(
+    "Arguments" === type3,
+    "expected #{this} to be arguments but got " + type3,
+    "expected #{this} to not be arguments"
+  );
 }
 __name(checkArguments, "checkArguments");
 Assertion.addProperty("arguments", checkArguments);
 Assertion.addProperty("Arguments", checkArguments);
 function assertEqual(val, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
   if (flag2(this, "deep")) {
     let prevLockSsfi = flag2(this, "lockSsfi");
@@ -1851,7 +2144,14 @@ function assertEqual(val, msg) {
     this.eql(val);
     flag2(this, "lockSsfi", prevLockSsfi);
   } else {
-    this.assert(val === obj, "expected #{this} to equal #{exp}", "expected #{this} to not equal #{exp}", val, this._obj, true);
+    this.assert(
+      val === obj,
+      "expected #{this} to equal #{exp}",
+      "expected #{this} to not equal #{exp}",
+      val,
+      this._obj,
+      true
+    );
   }
 }
 __name(assertEqual, "assertEqual");
@@ -1859,28 +2159,45 @@ Assertion.addMethod("equal", assertEqual);
 Assertion.addMethod("equals", assertEqual);
 Assertion.addMethod("eq", assertEqual);
 function assertEql(obj, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let eql = flag2(this, "eql");
-  this.assert(eql(obj, flag2(this, "object")), "expected #{this} to deeply equal #{exp}", "expected #{this} to not deeply equal #{exp}", obj, this._obj, true);
+  this.assert(
+    eql(obj, flag2(this, "object")),
+    "expected #{this} to deeply equal #{exp}",
+    "expected #{this} to not deeply equal #{exp}",
+    obj,
+    this._obj,
+    true
+  );
 }
 __name(assertEql, "assertEql");
 Assertion.addMethod("eql", assertEql);
 Assertion.addMethod("eqls", assertEql);
 function assertAbove(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase();
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
   }
   if (!doLength && objType === "date" && nType !== "date") {
-    throw new AssertionError(msgPrefix + "the argument to above must be a date", undefined, ssfi);
+    throw new AssertionError(
+      msgPrefix + "the argument to above must be a date",
+      void 0,
+      ssfi
+    );
   } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
-    throw new AssertionError(msgPrefix + "the argument to above must be a number", undefined, ssfi);
+    throw new AssertionError(
+      msgPrefix + "the argument to above must be a number",
+      void 0,
+      ssfi
+    );
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
     let printObj = objType === "string" ? "'" + obj + "'" : obj;
-    throw new AssertionError(msgPrefix + "expected " + printObj + " to be a number or a date", undefined, ssfi);
+    throw new AssertionError(
+      msgPrefix + "expected " + printObj + " to be a number or a date",
+      void 0,
+      ssfi
+    );
   }
   if (doLength) {
     let descriptor = "length", itemsCount;
@@ -1890,9 +2207,20 @@ function assertAbove(n, msg) {
     } else {
       itemsCount = obj.length;
     }
-    this.assert(itemsCount > n, "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " above #{exp}", n, itemsCount);
+    this.assert(
+      itemsCount > n,
+      "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}",
+      "expected #{this} to not have a " + descriptor + " above #{exp}",
+      n,
+      itemsCount
+    );
   } else {
-    this.assert(obj > n, "expected #{this} to be above #{exp}", "expected #{this} to be at most #{exp}", n);
+    this.assert(
+      obj > n,
+      "expected #{this} to be above #{exp}",
+      "expected #{this} to be at most #{exp}",
+      n
+    );
   }
 }
 __name(assertAbove, "assertAbove");
@@ -1900,8 +2228,7 @@ Assertion.addMethod("above", assertAbove);
 Assertion.addMethod("gt", assertAbove);
 Assertion.addMethod("greaterThan", assertAbove);
 function assertLeast(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
@@ -1917,7 +2244,7 @@ function assertLeast(n, msg) {
     shouldThrow = false;
   }
   if (shouldThrow) {
-    throw new AssertionError(errorMessage, undefined, ssfi);
+    throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
     let descriptor = "length", itemsCount;
@@ -1927,9 +2254,20 @@ function assertLeast(n, msg) {
     } else {
       itemsCount = obj.length;
     }
-    this.assert(itemsCount >= n, "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " below #{exp}", n, itemsCount);
+    this.assert(
+      itemsCount >= n,
+      "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}",
+      "expected #{this} to have a " + descriptor + " below #{exp}",
+      n,
+      itemsCount
+    );
   } else {
-    this.assert(obj >= n, "expected #{this} to be at least #{exp}", "expected #{this} to be below #{exp}", n);
+    this.assert(
+      obj >= n,
+      "expected #{this} to be at least #{exp}",
+      "expected #{this} to be below #{exp}",
+      n
+    );
   }
 }
 __name(assertLeast, "assertLeast");
@@ -1937,8 +2275,7 @@ Assertion.addMethod("least", assertLeast);
 Assertion.addMethod("gte", assertLeast);
 Assertion.addMethod("greaterThanOrEqual", assertLeast);
 function assertBelow(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
@@ -1954,7 +2291,7 @@ function assertBelow(n, msg) {
     shouldThrow = false;
   }
   if (shouldThrow) {
-    throw new AssertionError(errorMessage, undefined, ssfi);
+    throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
     let descriptor = "length", itemsCount;
@@ -1964,9 +2301,20 @@ function assertBelow(n, msg) {
     } else {
       itemsCount = obj.length;
     }
-    this.assert(itemsCount < n, "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " below #{exp}", n, itemsCount);
+    this.assert(
+      itemsCount < n,
+      "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}",
+      "expected #{this} to not have a " + descriptor + " below #{exp}",
+      n,
+      itemsCount
+    );
   } else {
-    this.assert(obj < n, "expected #{this} to be below #{exp}", "expected #{this} to be at least #{exp}", n);
+    this.assert(
+      obj < n,
+      "expected #{this} to be below #{exp}",
+      "expected #{this} to be at least #{exp}",
+      n
+    );
   }
 }
 __name(assertBelow, "assertBelow");
@@ -1974,8 +2322,7 @@ Assertion.addMethod("below", assertBelow);
 Assertion.addMethod("lt", assertBelow);
 Assertion.addMethod("lessThan", assertBelow);
 function assertMost(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
@@ -1991,7 +2338,7 @@ function assertMost(n, msg) {
     shouldThrow = false;
   }
   if (shouldThrow) {
-    throw new AssertionError(errorMessage, undefined, ssfi);
+    throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
     let descriptor = "length", itemsCount;
@@ -2001,9 +2348,20 @@ function assertMost(n, msg) {
     } else {
       itemsCount = obj.length;
     }
-    this.assert(itemsCount <= n, "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " above #{exp}", n, itemsCount);
+    this.assert(
+      itemsCount <= n,
+      "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}",
+      "expected #{this} to have a " + descriptor + " above #{exp}",
+      n,
+      itemsCount
+    );
   } else {
-    this.assert(obj <= n, "expected #{this} to be at most #{exp}", "expected #{this} to be above #{exp}", n);
+    this.assert(
+      obj <= n,
+      "expected #{this} to be at most #{exp}",
+      "expected #{this} to be above #{exp}",
+      n
+    );
   }
 }
 __name(assertMost, "assertMost");
@@ -2011,8 +2369,7 @@ Assertion.addMethod("most", assertMost);
 Assertion.addMethod("lte", assertMost);
 Assertion.addMethod("lessThanOrEqual", assertMost);
 Assertion.addMethod("within", function(start, finish, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), startType = type(start).toLowerCase(), finishType = type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
@@ -2028,7 +2385,7 @@ Assertion.addMethod("within", function(start, finish, msg) {
     shouldThrow = false;
   }
   if (shouldThrow) {
-    throw new AssertionError(errorMessage, undefined, ssfi);
+    throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
     let descriptor = "length", itemsCount;
@@ -2038,14 +2395,21 @@ Assertion.addMethod("within", function(start, finish, msg) {
     } else {
       itemsCount = obj.length;
     }
-    this.assert(itemsCount >= start && itemsCount <= finish, "expected #{this} to have a " + descriptor + " within " + range, "expected #{this} to not have a " + descriptor + " within " + range);
+    this.assert(
+      itemsCount >= start && itemsCount <= finish,
+      "expected #{this} to have a " + descriptor + " within " + range,
+      "expected #{this} to not have a " + descriptor + " within " + range
+    );
   } else {
-    this.assert(obj >= start && obj <= finish, "expected #{this} to be within " + range, "expected #{this} to not be within " + range);
+    this.assert(
+      obj >= start && obj <= finish,
+      "expected #{this} to be within " + range,
+      "expected #{this} to not be within " + range
+    );
   }
 });
 function assertInstanceOf(constructor, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let target = flag2(this, "object");
   let ssfi = flag2(this, "ssfi");
   let flagMsg = flag2(this, "message");
@@ -2055,7 +2419,11 @@ function assertInstanceOf(constructor, msg) {
   } catch (err) {
     if (err instanceof TypeError) {
       flagMsg = flagMsg ? flagMsg + ": " : "";
-      throw new AssertionError(flagMsg + "The instanceof assertion needs a constructor but " + type(constructor) + " was given.", undefined, ssfi);
+      throw new AssertionError(
+        flagMsg + "The instanceof assertion needs a constructor but " + type(constructor) + " was given.",
+        void 0,
+        ssfi
+      );
     }
     throw err;
   }
@@ -2063,52 +2431,75 @@ function assertInstanceOf(constructor, msg) {
   if (name == null) {
     name = "an unnamed constructor";
   }
-  this.assert(isInstanceOf, "expected #{this} to be an instance of " + name, "expected #{this} to not be an instance of " + name);
+  this.assert(
+    isInstanceOf,
+    "expected #{this} to be an instance of " + name,
+    "expected #{this} to not be an instance of " + name
+  );
 }
 __name(assertInstanceOf, "assertInstanceOf");
 Assertion.addMethod("instanceof", assertInstanceOf);
 Assertion.addMethod("instanceOf", assertInstanceOf);
 function assertProperty(name, val, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name;
   flagMsg = flagMsg ? flagMsg + ": " : "";
   if (isNested) {
     if (nameType !== "string") {
-      throw new AssertionError(flagMsg + "the argument to property must be a string when using nested syntax", undefined, ssfi);
+      throw new AssertionError(
+        flagMsg + "the argument to property must be a string when using nested syntax",
+        void 0,
+        ssfi
+      );
     }
   } else {
     if (nameType !== "string" && nameType !== "number" && nameType !== "symbol") {
-      throw new AssertionError(flagMsg + "the argument to property must be a string, number, or symbol", undefined, ssfi);
+      throw new AssertionError(
+        flagMsg + "the argument to property must be a string, number, or symbol",
+        void 0,
+        ssfi
+      );
     }
   }
   if (isNested && isOwn) {
-    throw new AssertionError(flagMsg + 'The "nested" and "own" flags cannot be combined.', undefined, ssfi);
-  }
-  if (obj === null || obj === undefined) {
-    throw new AssertionError(flagMsg + "Target cannot be null or undefined.", undefined, ssfi);
+    throw new AssertionError(
+      flagMsg + 'The "nested" and "own" flags cannot be combined.',
+      void 0,
+      ssfi
+    );
+  }
+  if (obj === null || obj === void 0) {
+    throw new AssertionError(
+      flagMsg + "Target cannot be null or undefined.",
+      void 0,
+      ssfi
+    );
   }
   let 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;
   let descriptor = "";
-  if (isDeep)
-    descriptor += "deep ";
-  if (isOwn)
-    descriptor += "own ";
-  if (isNested)
-    descriptor += "nested ";
+  if (isDeep) descriptor += "deep ";
+  if (isOwn) descriptor += "own ";
+  if (isNested) descriptor += "nested ";
   descriptor += "property ";
   let hasProperty2;
-  if (isOwn)
-    hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
-  else if (isNested)
-    hasProperty2 = pathInfo.exists;
-  else
-    hasProperty2 = hasProperty(obj, name);
+  if (isOwn) hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
+  else if (isNested) hasProperty2 = pathInfo.exists;
+  else hasProperty2 = hasProperty(obj, name);
   if (!negate || arguments.length === 1) {
-    this.assert(hasProperty2, "expected #{this} to have " + descriptor + inspect2(name), "expected #{this} to not have " + descriptor + inspect2(name));
+    this.assert(
+      hasProperty2,
+      "expected #{this} to have " + descriptor + inspect2(name),
+      "expected #{this} to not have " + descriptor + inspect2(name)
+    );
   }
   if (arguments.length > 1) {
-    this.assert(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, value);
+    this.assert(
+      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,
+      value
+    );
   }
   flag2(this, "object", value);
 }
@@ -2126,15 +2517,25 @@ function assertOwnPropertyDescriptor(name, descriptor, msg) {
     msg = descriptor;
     descriptor = null;
   }
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
   let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
   let eql = flag2(this, "eql");
   if (actualDescriptor && descriptor) {
-    this.assert(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, actualDescriptor, true);
+    this.assert(
+      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,
+      actualDescriptor,
+      true
+    );
   } else {
-    this.assert(actualDescriptor, "expected #{this} to have an own property descriptor for " + inspect2(name), "expected #{this} to not have an own property descriptor for " + inspect2(name));
+    this.assert(
+      actualDescriptor,
+      "expected #{this} to have an own property descriptor for " + inspect2(name),
+      "expected #{this} to not have an own property descriptor for " + inspect2(name)
+    );
   }
   flag2(this, "object", actualDescriptor);
 }
@@ -2146,8 +2547,7 @@ function assertLengthChain() {
 }
 __name(assertLengthChain, "assertLengthChain");
 function assertLength(n, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
   switch (objType) {
     case "map":
@@ -2159,26 +2559,38 @@ function assertLength(n, msg) {
       new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
       itemsCount = obj.length;
   }
-  this.assert(itemsCount == n, "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " of #{act}", n, itemsCount);
+  this.assert(
+    itemsCount == n,
+    "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}",
+    "expected #{this} to not have a " + descriptor + " of #{act}",
+    n,
+    itemsCount
+  );
 }
 __name(assertLength, "assertLength");
 Assertion.addChainableMethod("length", assertLength, assertLengthChain);
 Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
 function assertMatch(re, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
-  this.assert(re.exec(obj), "expected #{this} to match " + re, "expected #{this} not to match " + re);
+  this.assert(
+    re.exec(obj),
+    "expected #{this} to match " + re,
+    "expected #{this} not to match " + re
+  );
 }
 __name(assertMatch, "assertMatch");
 Assertion.addMethod("match", assertMatch);
 Assertion.addMethod("matches", assertMatch);
 Assertion.addMethod("string", function(str, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(obj, flagMsg, ssfi, true).is.a("string");
-  this.assert(~obj.indexOf(str), "expected #{this} to contain " + inspect2(str), "expected #{this} to not contain " + inspect2(str));
+  this.assert(
+    ~obj.indexOf(str),
+    "expected #{this} to contain " + inspect2(str),
+    "expected #{this} to not contain " + inspect2(str)
+  );
 });
 function assertKeys(keys) {
   let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
@@ -2198,12 +2610,12 @@ function assertKeys(keys) {
     switch (keysType) {
       case "Array":
         if (arguments.length > 1) {
-          throw new AssertionError(mixedArgsMsg, undefined, ssfi);
+          throw new AssertionError(mixedArgsMsg, void 0, ssfi);
         }
         break;
       case "Object":
         if (arguments.length > 1) {
-          throw new AssertionError(mixedArgsMsg, undefined, ssfi);
+          throw new AssertionError(mixedArgsMsg, void 0, ssfi);
         }
         keys = Object.keys(keys);
         break;
@@ -2215,7 +2627,7 @@ function assertKeys(keys) {
     });
   }
   if (!keys.length) {
-    throw new AssertionError(flagMsg + "keys required", undefined, ssfi);
+    throw new AssertionError(flagMsg + "keys required", void 0, ssfi);
   }
   let 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) {
@@ -2254,14 +2666,20 @@ function assertKeys(keys) {
   }
   str = (len > 1 ? "keys " : "key ") + str;
   str = (flag2(this, "contains") ? "contain " : "have ") + str;
-  this.assert(ok, "expected #{this} to " + deepStr + str, "expected #{this} to not " + deepStr + str, expected.slice(0).sort(compareByInspect), actual.sort(compareByInspect), true);
+  this.assert(
+    ok,
+    "expected #{this} to " + deepStr + str,
+    "expected #{this} to not " + deepStr + str,
+    expected.slice(0).sort(compareByInspect),
+    actual.sort(compareByInspect),
+    true
+  );
 }
 __name(assertKeys, "assertKeys");
 Assertion.addMethod("keys", assertKeys);
 Assertion.addMethod("key", assertKeys);
 function assertThrows(errorLike, errMsgMatcher, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
   new Assertion(obj, flagMsg, ssfi, true).is.a("function");
   if (isRegExp2(errorLike) || typeof errorLike === "string") {
@@ -2276,7 +2694,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     errorWasThrown = true;
     caughtErr = err;
   }
-  let everyArgIsUndefined = errorLike === undefined && errMsgMatcher === undefined;
+  let everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
   let everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
   let errorLikeFail = false;
   let errMsgMatcherFail = false;
@@ -2295,46 +2713,86 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) {
       try {
         actual = check_error_exports.getConstructorName(caughtErr);
-      } catch (_err) {}
+      } catch (_err) {
+      }
     }
-    this.assert(errorWasThrown, "expected #{this} to throw " + errorLikeString, "expected #{this} to not throw an error but #{act} was thrown", errorLike && errorLike.toString(), actual);
+    this.assert(
+      errorWasThrown,
+      "expected #{this} to throw " + errorLikeString,
+      "expected #{this} to not throw an error but #{act} was thrown",
+      errorLike && errorLike.toString(),
+      actual
+    );
   }
   if (errorLike && caughtErr) {
     if (errorLike instanceof Error) {
-      let isCompatibleInstance = check_error_exports.compatibleInstance(caughtErr, errorLike);
+      let isCompatibleInstance = check_error_exports.compatibleInstance(
+        caughtErr,
+        errorLike
+      );
       if (isCompatibleInstance === negate) {
         if (everyArgIsDefined && negate) {
           errorLikeFail = true;
         } else {
-          this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""), errorLike.toString(), caughtErr.toString());
+          this.assert(
+            negate,
+            "expected #{this} to throw #{exp} but #{act} was thrown",
+            "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""),
+            errorLike.toString(),
+            caughtErr.toString()
+          );
         }
       }
     }
-    let isCompatibleConstructor = check_error_exports.compatibleConstructor(caughtErr, errorLike);
+    let isCompatibleConstructor = check_error_exports.compatibleConstructor(
+      caughtErr,
+      errorLike
+    );
     if (isCompatibleConstructor === negate) {
       if (everyArgIsDefined && negate) {
         errorLikeFail = true;
       } else {
-        this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+        this.assert(
+          negate,
+          "expected #{this} to throw #{exp} but #{act} was thrown",
+          "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""),
+          errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike),
+          caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr)
+        );
       }
     }
   }
-  if (caughtErr && errMsgMatcher !== undefined && errMsgMatcher !== null) {
+  if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
     let placeholder = "including";
     if (isRegExp2(errMsgMatcher)) {
       placeholder = "matching";
     }
-    let isCompatibleMessage = check_error_exports.compatibleMessage(caughtErr, errMsgMatcher);
+    let isCompatibleMessage = check_error_exports.compatibleMessage(
+      caughtErr,
+      errMsgMatcher
+    );
     if (isCompatibleMessage === negate) {
       if (everyArgIsDefined && negate) {
         errMsgMatcherFail = true;
       } else {
-        this.assert(negate, "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}", "expected #{this} to throw error not " + placeholder + " #{exp}", errMsgMatcher, check_error_exports.getMessage(caughtErr));
+        this.assert(
+          negate,
+          "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}",
+          "expected #{this} to throw error not " + placeholder + " #{exp}",
+          errMsgMatcher,
+          check_error_exports.getMessage(caughtErr)
+        );
       }
     }
   }
   if (errorLikeFail && errMsgMatcherFail) {
-    this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+    this.assert(
+      negate,
+      "expected #{this} to throw #{exp} but #{act} was thrown",
+      "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""),
+      errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike),
+      caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr)
+    );
   }
   flag2(this, "object", caughtErr);
 }
@@ -2343,10 +2801,13 @@ Assertion.addMethod("throw", assertThrows);
 Assertion.addMethod("throws", assertThrows);
 Assertion.addMethod("Throw", assertThrows);
 function respondTo(method, msg) {
-  if (msg)
-    flag2(this, "message", msg);
-  let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = typeof obj === "function" && !itself ? obj.prototype[method] : obj[method];
-  this.assert(typeof context === "function", "expected #{this} to respond to " + inspect2(method), "expected #{this} to not respond to " + inspect2(method));
+  if (msg) flag2(this, "message", msg);
+  let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method];
+  this.assert(
+    "function" === typeof context,
+    "expected #{this} to respond to " + inspect2(method),
+    "expected #{this} to not respond to " + inspect2(method)
+  );
 }
 __name(respondTo, "respondTo");
 Assertion.addMethod("respondTo", respondTo);
@@ -2355,33 +2816,49 @@ Assertion.addProperty("itself", function() {
   flag2(this, "itself", true);
 });
 function satisfy(matcher, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
   let result = matcher(obj);
-  this.assert(result, "expected #{this} to satisfy " + objDisplay(matcher), "expected #{this} to not satisfy" + objDisplay(matcher), flag2(this, "negate") ? false : true, result);
+  this.assert(
+    result,
+    "expected #{this} to satisfy " + objDisplay(matcher),
+    "expected #{this} to not satisfy" + objDisplay(matcher),
+    flag2(this, "negate") ? false : true,
+    result
+  );
 }
 __name(satisfy, "satisfy");
 Assertion.addMethod("satisfy", satisfy);
 Assertion.addMethod("satisfies", satisfy);
 function closeTo(expected, delta, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(obj, flagMsg, ssfi, true).is.numeric;
   let message = "A `delta` value is required for `closeTo`";
-  if (delta == undefined) {
-    throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, undefined, ssfi);
+  if (delta == void 0) {
+    throw new AssertionError(
+      flagMsg ? `${flagMsg}: ${message}` : message,
+      void 0,
+      ssfi
+    );
   }
   new Assertion(delta, flagMsg, ssfi, true).is.numeric;
   message = "A `expected` value is required for `closeTo`";
-  if (expected == undefined) {
-    throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, undefined, ssfi);
+  if (expected == void 0) {
+    throw new AssertionError(
+      flagMsg ? `${flagMsg}: ${message}` : message,
+      void 0,
+      ssfi
+    );
   }
   new Assertion(expected, flagMsg, ssfi, true).is.numeric;
   const abs = /* @__PURE__ */ __name((x) => x < 0 ? -x : x, "abs");
   const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
-  this.assert(strip(abs(obj - expected)) <= delta, "expected #{this} to be close to " + expected + " +/- " + delta, "expected #{this} not to be close to " + expected + " +/- " + delta);
+  this.assert(
+    strip(abs(obj - expected)) <= delta,
+    "expected #{this} to be close to " + expected + " +/- " + delta,
+    "expected #{this} not to be close to " + expected + " +/- " + delta
+  );
 }
 __name(closeTo, "closeTo");
 Assertion.addMethod("closeTo", closeTo);
@@ -2390,34 +2867,27 @@ function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
   let superset = Array.from(_superset);
   let subset = Array.from(_subset);
   if (!contains) {
-    if (subset.length !== superset.length)
-      return false;
+    if (subset.length !== superset.length) return false;
     superset = superset.slice();
   }
   return subset.every(function(elem, idx) {
-    if (ordered)
-      return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
+    if (ordered) return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
     if (!cmp) {
       let matchIdx = superset.indexOf(elem);
-      if (matchIdx === -1)
-        return false;
-      if (!contains)
-        superset.splice(matchIdx, 1);
+      if (matchIdx === -1) return false;
+      if (!contains) superset.splice(matchIdx, 1);
       return true;
     }
     return superset.some(function(elem2, matchIdx) {
-      if (!cmp(elem, elem2))
-        return false;
-      if (!contains)
-        superset.splice(matchIdx, 1);
+      if (!cmp(elem, elem2)) return false;
+      if (!contains) superset.splice(matchIdx, 1);
       return true;
     });
   });
 }
 __name(isSubsetOf, "isSubsetOf");
 Assertion.addMethod("members", function(subset, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(obj, flagMsg, ssfi, true).to.be.iterable;
   new Assertion(subset, flagMsg, ssfi, true).to.be.iterable;
@@ -2433,39 +2903,66 @@ 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}";
   }
-  let cmp = flag2(this, "deep") ? flag2(this, "eql") : undefined;
-  this.assert(isSubsetOf(subset, obj, cmp, contains, ordered), failMsg, failNegateMsg, subset, obj, true);
+  let cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
+  this.assert(
+    isSubsetOf(subset, obj, cmp, contains, ordered),
+    failMsg,
+    failNegateMsg,
+    subset,
+    obj,
+    true
+  );
 });
 Assertion.addProperty("iterable", function(msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
-  this.assert(obj != null && obj[Symbol.iterator], "expected #{this} to be an iterable", "expected #{this} to not be an iterable", obj);
+  this.assert(
+    obj != void 0 && obj[Symbol.iterator],
+    "expected #{this} to be an iterable",
+    "expected #{this} to not be an iterable",
+    obj
+  );
 });
 function oneOf(list, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let 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(list.some(function(possibility) {
-      return expected.indexOf(possibility) > -1;
-    }), "expected #{this} to contain one of #{exp}", "expected #{this} to not contain one of #{exp}", list, expected);
+    this.assert(
+      list.some(function(possibility) {
+        return expected.indexOf(possibility) > -1;
+      }),
+      "expected #{this} to contain one of #{exp}",
+      "expected #{this} to not contain one of #{exp}",
+      list,
+      expected
+    );
   } else {
     if (isDeep) {
-      this.assert(list.some(function(possibility) {
-        return eql(expected, possibility);
-      }), "expected #{this} to deeply equal one of #{exp}", "expected #{this} to deeply equal one of #{exp}", list, expected);
+      this.assert(
+        list.some(function(possibility) {
+          return eql(expected, possibility);
+        }),
+        "expected #{this} to deeply equal one of #{exp}",
+        "expected #{this} to deeply equal one of #{exp}",
+        list,
+        expected
+      );
     } else {
-      this.assert(list.indexOf(expected) > -1, "expected #{this} to be one of #{exp}", "expected #{this} to not be one of #{exp}", list, expected);
+      this.assert(
+        list.indexOf(expected) > -1,
+        "expected #{this} to be one of #{exp}",
+        "expected #{this} to not be one of #{exp}",
+        list,
+        expected
+      );
     }
   }
 }
 __name(oneOf, "oneOf");
 Assertion.addMethod("oneOf", oneOf);
 function assertChanges(subject, prop, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn, flagMsg, ssfi, true).is.a("function");
   let initial;
@@ -2477,21 +2974,24 @@ function assertChanges(subject, prop, msg) {
     initial = subject[prop];
   }
   fn();
-  let final = prop === undefined || prop === null ? subject() : subject[prop];
-  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
   flag2(this, "deltaBehavior", "change");
   flag2(this, "realDelta", final !== initial);
-  this.assert(initial !== final, "expected " + msgObj + " to change", "expected " + msgObj + " to not change");
+  this.assert(
+    initial !== final,
+    "expected " + msgObj + " to change",
+    "expected " + msgObj + " to not change"
+  );
 }
 __name(assertChanges, "assertChanges");
 Assertion.addMethod("change", assertChanges);
 Assertion.addMethod("changes", assertChanges);
 function assertIncreases(subject, prop, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn, flagMsg, ssfi, true).is.a("function");
   let initial;
@@ -2504,21 +3004,24 @@ function assertIncreases(subject, prop, msg) {
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn();
-  let final = prop === undefined || prop === null ? subject() : subject[prop];
-  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
   flag2(this, "deltaBehavior", "increase");
   flag2(this, "realDelta", final - initial);
-  this.assert(final - initial > 0, "expected " + msgObj + " to increase", "expected " + msgObj + " to not increase");
+  this.assert(
+    final - initial > 0,
+    "expected " + msgObj + " to increase",
+    "expected " + msgObj + " to not increase"
+  );
 }
 __name(assertIncreases, "assertIncreases");
 Assertion.addMethod("increase", assertIncreases);
 Assertion.addMethod("increases", assertIncreases);
 function assertDecreases(subject, prop, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn, flagMsg, ssfi, true).is.a("function");
   let initial;
@@ -2531,21 +3034,24 @@ function assertDecreases(subject, prop, msg) {
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn();
-  let final = prop === undefined || prop === null ? subject() : subject[prop];
-  let msgObj = prop === undefined || prop === null ? initial : "." + prop;
+  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
   flag2(this, "deltaBehavior", "decrease");
   flag2(this, "realDelta", initial - final);
-  this.assert(final - initial < 0, "expected " + msgObj + " to decrease", "expected " + msgObj + " to not decrease");
+  this.assert(
+    final - initial < 0,
+    "expected " + msgObj + " to decrease",
+    "expected " + msgObj + " to not decrease"
+  );
 }
 __name(assertDecreases, "assertDecreases");
 Assertion.addMethod("decrease", assertDecreases);
 Assertion.addMethod("decreases", assertDecreases);
 function assertDelta(delta, msg) {
-  if (msg)
-    flag2(this, "message", msg);
+  if (msg) flag2(this, "message", msg);
   let msgObj = flag2(this, "deltaMsgObj");
   let initial = flag2(this, "initialDeltaValue");
   let final = flag2(this, "finalDeltaValue");
@@ -2557,28 +3063,48 @@ function assertDelta(delta, msg) {
   } else {
     expression = realDelta === Math.abs(delta);
   }
-  this.assert(expression, "expected " + msgObj + " to " + behavior + " by " + delta, "expected " + msgObj + " to not " + behavior + " by " + delta);
+  this.assert(
+    expression,
+    "expected " + msgObj + " to " + behavior + " by " + delta,
+    "expected " + msgObj + " to not " + behavior + " by " + delta
+  );
 }
 __name(assertDelta, "assertDelta");
 Assertion.addMethod("by", assertDelta);
 Assertion.addProperty("extensible", function() {
   let obj = flag2(this, "object");
   let isExtensible = obj === Object(obj) && Object.isExtensible(obj);
-  this.assert(isExtensible, "expected #{this} to be extensible", "expected #{this} to not be extensible");
+  this.assert(
+    isExtensible,
+    "expected #{this} to be extensible",
+    "expected #{this} to not be extensible"
+  );
 });
 Assertion.addProperty("sealed", function() {
   let obj = flag2(this, "object");
   let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
-  this.assert(isSealed, "expected #{this} to be sealed", "expected #{this} to not be sealed");
+  this.assert(
+    isSealed,
+    "expected #{this} to be sealed",
+    "expected #{this} to not be sealed"
+  );
 });
 Assertion.addProperty("frozen", function() {
   let obj = flag2(this, "object");
   let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
-  this.assert(isFrozen, "expected #{this} to be frozen", "expected #{this} to not be frozen");
+  this.assert(
+    isFrozen,
+    "expected #{this} to be frozen",
+    "expected #{this} to not be frozen"
+  );
 });
 Assertion.addProperty("finite", function(_msg) {
   let obj = flag2(this, "object");
-  this.assert(typeof obj === "number" && isFinite(obj), "expected #{this} to be a finite number", "expected #{this} to not be a finite number");
+  this.assert(
+    typeof obj === "number" && isFinite(obj),
+    "expected #{this} to be a finite number",
+    "expected #{this} to not be a finite number"
+  );
 });
 function compareSubset(expected, actual) {
   if (expected === actual) {
@@ -2626,7 +3152,14 @@ __name(compareSubset, "compareSubset");
 Assertion.addMethod("containSubset", function(expected) {
   const actual = flag(this, "object");
   const showDiff = config.showDiff;
-  this.assert(compareSubset(expected, actual), "expected #{act} to contain subset #{exp}", "expected #{act} to not contain subset #{exp}", expected, actual, showDiff);
+  this.assert(
+    compareSubset(expected, actual),
+    "expected #{act} to contain subset #{exp}",
+    "expected #{act} to not contain subset #{exp}",
+    expected,
+    actual,
+    showDiff
+  );
 });
 function expect(val, message) {
   return new Assertion(val, message);
@@ -2635,14 +3168,18 @@ __name(expect, "expect");
 expect.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
-    actual = undefined;
+    actual = void 0;
   }
   message = message || "expect.fail()";
-  throw new AssertionError(message, {
-    actual,
-    expected,
-    operator
-  }, expect.fail);
+  throw new AssertionError(
+    message,
+    {
+      actual,
+      expected,
+      operator
+    },
+    expect.fail
+  );
 };
 var should_exports = {};
 __export(should_exports, {
@@ -2675,14 +3212,18 @@ function loadShould() {
   should2.fail = function(actual, expected, message, operator) {
     if (arguments.length < 2) {
       message = actual;
-      actual = undefined;
+      actual = void 0;
     }
     message = message || "should.fail()";
-    throw new AssertionError(message, {
-      actual,
-      expected,
-      operator
-    }, should2.fail);
+    throw new AssertionError(
+      message,
+      {
+        actual,
+        expected,
+        operator
+      },
+      should2.fail
+    );
   };
   should2.equal = function(actual, expected, message) {
     new Assertion(actual, message).to.equal(expected);
@@ -2718,14 +3259,18 @@ __name(assert, "assert");
 assert.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
-    actual = undefined;
+    actual = void 0;
   }
   message = message || "assert.fail()";
-  throw new AssertionError(message, {
-    actual,
-    expected,
-    operator
-  }, assert.fail);
+  throw new AssertionError(
+    message,
+    {
+      actual,
+      expected,
+      operator
+    },
+    assert.fail
+  );
 };
 assert.isOk = function(val, msg) {
   new Assertion(val, msg, assert.isOk, true).is.ok;
@@ -2735,11 +3280,25 @@ assert.isNotOk = function(val, msg) {
 };
 assert.equal = function(act, exp, msg) {
   let test2 = new Assertion(act, msg, assert.equal, true);
-  test2.assert(exp == flag(test2, "object"), "expected #{this} to equal #{exp}", "expected #{this} to not equal #{act}", exp, act, true);
+  test2.assert(
+    exp == flag(test2, "object"),
+    "expected #{this} to equal #{exp}",
+    "expected #{this} to not equal #{act}",
+    exp,
+    act,
+    true
+  );
 };
 assert.notEqual = function(act, exp, msg) {
   let test2 = new Assertion(act, msg, assert.notEqual, true);
-  test2.assert(exp != flag(test2, "object"), "expected #{this} to not equal #{exp}", "expected #{this} to equal #{act}", exp, act, true);
+  test2.assert(
+    exp != flag(test2, "object"),
+    "expected #{this} to not equal #{exp}",
+    "expected #{this} to equal #{act}",
+    exp,
+    act,
+    true
+  );
 };
 assert.strictEqual = function(act, exp, msg) {
   new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
@@ -2796,10 +3355,10 @@ assert.notExists = function(val, msg) {
   new Assertion(val, msg, assert.notExists, true).to.not.exist;
 };
 assert.isUndefined = function(val, msg) {
-  new Assertion(val, msg, assert.isUndefined, true).to.equal(undefined);
+  new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
 };
 assert.isDefined = function(val, msg) {
-  new Assertion(val, msg, assert.isDefined, true).to.not.equal(undefined);
+  new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
 };
 assert.isCallable = function(value, message) {
   new Assertion(value, message, assert.isCallable, true).is.callable;
@@ -2856,7 +3415,9 @@ assert.instanceOf = function(val, type3, msg) {
   new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
 };
 assert.notInstanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(type3);
+  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
+    type3
+  );
 };
 assert.include = function(exp, inc, msg) {
   new Assertion(exp, msg, assert.include, true).include(inc);
@@ -2874,13 +3435,22 @@ assert.nestedInclude = function(exp, inc, msg) {
   new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
 };
 assert.notNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(inc);
+  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
+    inc
+  );
 };
 assert.deepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(inc);
+  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
+    inc
+  );
 };
 assert.notDeepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepNestedInclude, true).not.deep.nested.include(inc);
+  new Assertion(
+    exp,
+    msg,
+    assert.notDeepNestedInclude,
+    true
+  ).not.deep.nested.include(inc);
 };
 assert.ownInclude = function(exp, inc, msg) {
   new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
@@ -2892,7 +3462,9 @@ assert.deepOwnInclude = function(exp, inc, msg) {
   new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
 };
 assert.notDeepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(inc);
+  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
+    inc
+  );
 };
 assert.match = function(exp, re, msg) {
   new Assertion(exp, msg, assert.match, true).to.match(re);
@@ -2910,49 +3482,107 @@ assert.propertyVal = function(obj, prop, val, msg) {
   new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
 };
 assert.notPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(prop, val);
+  new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(
+    prop,
+    val
+  );
 };
 assert.deepPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(prop, val);
+  new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(
+    prop,
+    val
+  );
 };
 assert.notDeepPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notDeepPropertyVal, true).to.not.have.deep.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepPropertyVal,
+    true
+  ).to.not.have.deep.property(prop, val);
 };
 assert.ownProperty = function(obj, prop, msg) {
   new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
 };
 assert.notOwnProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(prop);
+  new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(
+    prop
+  );
 };
 assert.ownPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(prop, value);
+  new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(
+    prop,
+    value
+  );
 };
 assert.notOwnPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.notOwnPropertyVal, true).to.not.have.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.notOwnPropertyVal,
+    true
+  ).to.not.have.own.property(prop, value);
 };
 assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.deepOwnPropertyVal, true).to.have.deep.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.deepOwnPropertyVal,
+    true
+  ).to.have.deep.own.property(prop, value);
 };
 assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.notDeepOwnPropertyVal, true).to.not.have.deep.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepOwnPropertyVal,
+    true
+  ).to.not.have.deep.own.property(prop, value);
 };
 assert.nestedProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(prop);
+  new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(
+    prop
+  );
 };
 assert.notNestedProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.notNestedProperty, true).to.not.have.nested.property(prop);
+  new Assertion(
+    obj,
+    msg,
+    assert.notNestedProperty,
+    true
+  ).to.not.have.nested.property(prop);
 };
 assert.nestedPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.nestedPropertyVal, true).to.have.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.nestedPropertyVal,
+    true
+  ).to.have.nested.property(prop, val);
 };
 assert.notNestedPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notNestedPropertyVal, true).to.not.have.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.notNestedPropertyVal,
+    true
+  ).to.not.have.nested.property(prop, val);
 };
 assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.deepNestedPropertyVal, true).to.have.deep.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.deepNestedPropertyVal,
+    true
+  ).to.have.deep.nested.property(prop, val);
 };
 assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notDeepNestedPropertyVal, true).to.not.have.deep.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepNestedPropertyVal,
+    true
+  ).to.not.have.deep.nested.property(prop, val);
 };
 assert.lengthOf = function(exp, len, msg) {
   new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
@@ -2964,43 +3594,74 @@ assert.hasAllKeys = function(obj, keys, msg) {
   new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys);
 };
 assert.containsAllKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(keys);
+  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
+    keys
+  );
 };
 assert.doesNotHaveAnyKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(keys);
+  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
+    keys
+  );
 };
 assert.doesNotHaveAllKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(keys);
+  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
+    keys
+  );
 };
 assert.hasAnyDeepKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(keys);
+  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
+    keys
+  );
 };
 assert.hasAllDeepKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(keys);
+  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
+    keys
+  );
 };
 assert.containsAllDeepKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.containsAllDeepKeys, true).to.contain.all.deep.keys(keys);
+  new Assertion(
+    obj,
+    msg,
+    assert.containsAllDeepKeys,
+    true
+  ).to.contain.all.deep.keys(keys);
 };
 assert.doesNotHaveAnyDeepKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyDeepKeys, true).to.not.have.any.deep.keys(keys);
+  new Assertion(
+    obj,
+    msg,
+    assert.doesNotHaveAnyDeepKeys,
+    true
+  ).to.not.have.any.deep.keys(keys);
 };
 assert.doesNotHaveAllDeepKeys = function(obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllDeepKeys, true).to.not.have.all.deep.keys(keys);
+  new Assertion(
+    obj,
+    msg,
+    assert.doesNotHaveAllDeepKeys,
+    true
+  ).to.not.have.all.deep.keys(keys);
 };
 assert.throws = function(fn, errorLike, errMsgMatcher, msg) {
-  if (typeof errorLike === "string" || errorLike instanceof RegExp) {
+  if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  let assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(errorLike, errMsgMatcher);
+  let assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(
+    errorLike,
+    errMsgMatcher
+  );
   return flag(assertErr, "object");
 };
 assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) {
-  if (typeof errorLike === "string" || errorLike instanceof RegExp) {
+  if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
+  new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(
+    errorLike,
+    errMsgMatcher
+  );
 };
 assert.operator = function(val, operator, val2, msg) {
   let ok;
@@ -3031,72 +3692,155 @@ assert.operator = function(val, operator, val2, msg) {
       break;
     default:
       msg = msg ? msg + ": " : msg;
-      throw new AssertionError(msg + 'Invalid operator "' + operator + '"', undefined, assert.operator);
+      throw new AssertionError(
+        msg + 'Invalid operator "' + operator + '"',
+        void 0,
+        assert.operator
+      );
   }
   let test2 = new Assertion(ok, msg, assert.operator, true);
-  test2.assert(flag(test2, "object") === true, "expected " + inspect2(val) + " to be " + operator + " " + inspect2(val2), "expected " + inspect2(val) + " to not be " + operator + " " + inspect2(val2));
+  test2.assert(
+    true === flag(test2, "object"),
+    "expected " + inspect2(val) + " to be " + operator + " " + inspect2(val2),
+    "expected " + inspect2(val) + " to not be " + operator + " " + inspect2(val2)
+  );
 };
 assert.closeTo = function(act, exp, delta, msg) {
   new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
 };
 assert.approximately = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert.approximately, true).to.be.approximately(exp, delta);
+  new Assertion(act, msg, assert.approximately, true).to.be.approximately(
+    exp,
+    delta
+  );
 };
 assert.sameMembers = function(set1, set2, msg) {
   new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set2);
 };
 assert.notSameMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameMembers, true).to.not.have.same.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameMembers,
+    true
+  ).to.not.have.same.members(set2);
 };
 assert.sameDeepMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameDeepMembers, true).to.have.same.deep.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.sameDeepMembers,
+    true
+  ).to.have.same.deep.members(set2);
 };
 assert.notSameDeepMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameDeepMembers, true).to.not.have.same.deep.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameDeepMembers,
+    true
+  ).to.not.have.same.deep.members(set2);
 };
 assert.sameOrderedMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameOrderedMembers, true).to.have.same.ordered.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.sameOrderedMembers,
+    true
+  ).to.have.same.ordered.members(set2);
 };
 assert.notSameOrderedMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameOrderedMembers, true).to.not.have.same.ordered.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameOrderedMembers,
+    true
+  ).to.not.have.same.ordered.members(set2);
 };
 assert.sameDeepOrderedMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameDeepOrderedMembers, true).to.have.same.deep.ordered.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.sameDeepOrderedMembers,
+    true
+  ).to.have.same.deep.ordered.members(set2);
 };
 assert.notSameDeepOrderedMembers = function(set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameDeepOrderedMembers, true).to.not.have.same.deep.ordered.members(set2);
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameDeepOrderedMembers,
+    true
+  ).to.not.have.same.deep.ordered.members(set2);
 };
 assert.includeMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(subset);
+  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
+    subset
+  );
 };
 assert.notIncludeMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeMembers, true).to.not.include.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeMembers,
+    true
+  ).to.not.include.members(subset);
 };
 assert.includeDeepMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeDeepMembers, true).to.include.deep.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.includeDeepMembers,
+    true
+  ).to.include.deep.members(subset);
 };
 assert.notIncludeDeepMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeDeepMembers, true).to.not.include.deep.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeDeepMembers,
+    true
+  ).to.not.include.deep.members(subset);
 };
 assert.includeOrderedMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeOrderedMembers, true).to.include.ordered.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.includeOrderedMembers,
+    true
+  ).to.include.ordered.members(subset);
 };
 assert.notIncludeOrderedMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeOrderedMembers, true).to.not.include.ordered.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeOrderedMembers,
+    true
+  ).to.not.include.ordered.members(subset);
 };
 assert.includeDeepOrderedMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeDeepOrderedMembers, true).to.include.deep.ordered.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.includeDeepOrderedMembers,
+    true
+  ).to.include.deep.ordered.members(subset);
 };
 assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeDeepOrderedMembers, true).to.not.include.deep.ordered.members(subset);
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeDeepOrderedMembers,
+    true
+  ).to.not.include.deep.ordered.members(subset);
 };
 assert.oneOf = function(inList, list, msg) {
   new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
 };
 assert.isIterable = function(obj, msg) {
-  if (obj == undefined || !obj[Symbol.iterator]) {
+  if (obj == void 0 || !obj[Symbol.iterator]) {
     msg = msg ? `${msg} expected ${inspect2(obj)} to be an iterable` : `expected ${inspect2(obj)} to be an iterable`;
-    throw new AssertionError(msg, undefined, assert.isIterable);
+    throw new AssertionError(msg, void 0, assert.isIterable);
   }
 };
 assert.changes = function(fn, obj, prop, msg) {
@@ -3122,7 +3866,10 @@ assert.doesNotChange = function(fn, obj, prop, msg) {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change(obj, prop);
+  return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change(
+    obj,
+    prop
+  );
 };
 assert.changesButNotBy = function(fn, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
@@ -3158,7 +3905,10 @@ assert.doesNotIncrease = function(fn, obj, prop, msg) {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase(obj, prop);
+  return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase(
+    obj,
+    prop
+  );
 };
 assert.increasesButNotBy = function(fn, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
@@ -3194,7 +3944,10 @@ assert.doesNotDecrease = function(fn, obj, prop, msg) {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease(obj, prop);
+  return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease(
+    obj,
+    prop
+  );
 };
 assert.doesNotDecreaseBy = function(fn, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
@@ -3298,31 +4051,69 @@ function jestMatchers(chai, utils) {
   const A = chai.Assertion;
   const m = (name, fn) => A.addMethod(name, fn);
   m("toBe", function(expected) {
-    this.assert(Object.is(this._obj, expected), "expected #{this} to be #{exp}", "expected #{this} not to be #{exp}", expected, this._obj);
+    this.assert(
+      Object.is(this._obj, expected),
+      "expected #{this} to be #{exp}",
+      "expected #{this} not to be #{exp}",
+      expected,
+      this._obj
+    );
   });
   m("toEqual", function(expected) {
-    this.assert(utils.eql(this._obj, expected), "expected #{this} to deeply equal #{exp}", "expected #{this} not to deeply equal #{exp}", expected, this._obj, true);
+    this.assert(
+      utils.eql(this._obj, expected),
+      "expected #{this} to deeply equal #{exp}",
+      "expected #{this} not to deeply equal #{exp}",
+      expected,
+      this._obj,
+      true
+    );
   });
   m("toBeTruthy", function() {
-    this.assert(Boolean(this._obj), "expected #{this} to be truthy", "expected #{this} not to be truthy");
+    this.assert(
+      Boolean(this._obj),
+      "expected #{this} to be truthy",
+      "expected #{this} not to be truthy"
+    );
   });
   m("toBeFalsy", function() {
     this.assert(!this._obj, "expected #{this} to be falsy", "expected #{this} not to be falsy");
   });
   m("toBeNull", function() {
-    this.assert(this._obj === null, "expected #{this} to be null", "expected #{this} not to be null");
+    this.assert(
+      this._obj === null,
+      "expected #{this} to be null",
+      "expected #{this} not to be null"
+    );
   });
   m("toBeUndefined", function() {
-    this.assert(this._obj === undefined, "expected #{this} to be undefined", "expected #{this} not to be undefined");
+    this.assert(
+      this._obj === void 0,
+      "expected #{this} to be undefined",
+      "expected #{this} not to be undefined"
+    );
   });
   m("toBeDefined", function() {
-    this.assert(this._obj !== undefined, "expected #{this} to be defined", "expected #{this} to be undefined");
+    this.assert(
+      this._obj !== void 0,
+      "expected #{this} to be defined",
+      "expected #{this} to be undefined"
+    );
   });
   m("toBeNaN", function() {
-    this.assert(Number.isNaN(this._obj), "expected #{this} to be NaN", "expected #{this} not to be NaN");
+    this.assert(
+      Number.isNaN(this._obj),
+      "expected #{this} to be NaN",
+      "expected #{this} not to be NaN"
+    );
   });
   const compare = (name, op, word) => m(name, function(expected) {
-    this.assert(op(this._obj, expected), `expected #{this} to be ${word} #{exp}`, `expected #{this} not to be ${word} #{exp}`, expected);
+    this.assert(
+      op(this._obj, expected),
+      `expected #{this} to be ${word} #{exp}`,
+      `expected #{this} not to be ${word} #{exp}`,
+      expected
+    );
   });
   compare("toBeGreaterThan", (a, b) => a > b, "greater than");
   compare("toBeGreaterThanOrEqual", (a, b) => a >= b, "greater than or equal to");
@@ -3330,46 +4121,76 @@ function jestMatchers(chai, utils) {
   compare("toBeLessThanOrEqual", (a, b) => a <= b, "less than or equal to");
   m("toBeCloseTo", function(expected, numDigits = 2) {
     const pass = Math.abs(expected - this._obj) < 10 ** -numDigits / 2;
-    this.assert(pass, `expected #{this} to be close to #{exp} (${numDigits} digits)`, `expected #{this} not to be close to #{exp} (${numDigits} digits)`, expected);
+    this.assert(
+      pass,
+      `expected #{this} to be close to #{exp} (${numDigits} digits)`,
+      `expected #{this} not to be close to #{exp} (${numDigits} digits)`,
+      expected
+    );
   });
   m("toContain", function(item) {
     const obj = this._obj;
     const ok = typeof obj === "string" ? obj.includes(item) : Array.from(obj).includes(item);
-    this.assert(ok, "expected #{this} to contain #{exp}", "expected #{this} not to contain #{exp}", item);
+    this.assert(
+      ok,
+      "expected #{this} to contain #{exp}",
+      "expected #{this} not to contain #{exp}",
+      item
+    );
   });
   m("toHaveLength", function(length) {
-    const actual = this._obj == null ? undefined : this._obj.length;
-    this.assert(actual === length, "expected #{this} to have length #{exp}", "expected #{this} not to have length #{exp}", length, actual);
+    const actual = this._obj == null ? void 0 : this._obj.length;
+    this.assert(
+      actual === length,
+      "expected #{this} to have length #{exp}",
+      "expected #{this} not to have length #{exp}",
+      length,
+      actual
+    );
   });
   m("toMatch", function(expected) {
     const obj = this._obj;
     const ok = expected instanceof RegExp ? expected.test(obj) : String(obj).includes(expected);
-    this.assert(ok, "expected #{this} to match #{exp}", "expected #{this} not to match #{exp}", expected);
+    this.assert(
+      ok,
+      "expected #{this} to match #{exp}",
+      "expected #{this} not to match #{exp}",
+      expected
+    );
   });
   m("toHaveProperty", function(path, ...rest) {
     const keys = Array.isArray(path) ? path : String(path).split(".");
     let cur = this._obj;
     let found = true;
     for (const k of keys) {
-      if (cur != null && k in Object(cur))
-        cur = cur[k];
+      if (cur != null && k in Object(cur)) cur = cur[k];
       else {
         found = false;
         break;
       }
     }
     const pass = found && (rest.length === 0 || utils.eql(cur, rest[0]));
-    this.assert(pass, "expected #{this} to have property #{exp}", "expected #{this} not to have property #{exp}", path);
+    this.assert(
+      pass,
+      "expected #{this} to have property #{exp}",
+      "expected #{this} not to have property #{exp}",
+      path
+    );
   });
   m("toBeInstanceOf", function(ctor) {
-    this.assert(this._obj instanceof ctor, "expected #{this} to be an instance of #{exp}", "expected #{this} not to be an instance of #{exp}", ctor.name ?? ctor);
+    this.assert(
+      this._obj instanceof ctor,
+      "expected #{this} to be an instance of #{exp}",
+      "expected #{this} not to be an instance of #{exp}",
+      ctor.name ?? ctor
+    );
   });
   m("toThrow", function(expected) {
     const a = new chai.Assertion(this._obj);
     if (utils.flag(this, "negate")) {
-      expected === undefined ? a.to.not.throw() : a.to.not.throw(expected);
+      expected === void 0 ? a.to.not.throw() : a.to.not.throw(expected);
     } else {
-      expected === undefined ? a.to.throw() : a.to.throw(expected);
+      expected === void 0 ? a.to.throw() : a.to.throw(expected);
     }
   });
 }
@@ -3377,13 +4198,13 @@ function jestMatchers(chai, utils) {
 // deps/chai.js
 use(jestMatchers);
 export {
-  utils_exports as util,
-  use,
-  should,
-  expect,
-  config,
-  assert,
-  Should,
+  Assertion,
   AssertionError,
-  Assertion
+  Should,
+  assert,
+  config,
+  expect,
+  should,
+  use,
+  utils_exports as util
 };