@prisma/get-platform 6.20.0-integration-next.17 → 6.20.0-integration-next.19

package/dist/test-utils/vitestContext.js

@@ -35,7 +35,7 @@ __export(vitestContext_exports, {
   vitestStdoutContext: () => vitestStdoutContext
 });
 module.exports = __toCommonJS(vitestContext_exports);
-var import_chunk_OJINGNLI = require("../chunk-OJINGNLI.js");
+var import_chunk_3UEKS5W6 = require("../chunk-3UEKS5W6.js");
 var import_chunk_2ESYSVXG = require("../chunk-2ESYSVXG.js");
 var import_node_path = __toESM(require("node:path"));
 var import_tty = require("tty");
@@ -504,18 +504,18 @@ var require_utils = (0, import_chunk_2ESYSVXG.__commonJS)({
 var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/index.js"(exports) {
     "use strict";
-    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k2, k22) {
-      if (k22 === void 0) k22 = k2;
-      var desc = Object.getOwnPropertyDescriptor(m2, k2);
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
       if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
         desc = { enumerable: true, get: function() {
-          return m2[k2];
+          return m2[k];
         } };
       }
-      Object.defineProperty(o, k22, desc);
-    } : function(o, m2, k2, k22) {
-      if (k22 === void 0) k22 = k2;
-      o[k22] = m2[k2];
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m2[k];
     });
     var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
       for (var p3 in m2) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p3)) __createBinding(exports2, m2, p3);
@@ -579,8 +579,8 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
     exports.expectTypeOf = expectTypeOf2;
   }
 });
-var import_fs_jetpack = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_OJINGNLI.require_main)());
-var import_tempy = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_OJINGNLI.require_tempy)());
+var import_fs_jetpack = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_3UEKS5W6.require_main)());
+var import_tempy = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_3UEKS5W6.require_tempy)());
 var f = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
@@ -636,39 +636,39 @@ function C(n = false) {
 }
 function p(n = false) {
   let e = C(n), i = (r2, t, c, o) => {
-    let l2 = "", s2 = 0;
+    let l = "", s2 = 0;
     do
-      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l2 + r2.substring(s2);
+    return l + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    let o = (l2) => {
-      let s2 = String(l2), b2 = s2.indexOf(t, r2.length);
-      return ~b2 ? r2 + i(s2, t, c, b2) + t : r2 + s2 + t;
+    let o = (l) => {
+      let s2 = String(l), b = s2.indexOf(t, r2.length);
+      return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
     };
     return o.open = r2, o.close = t, o;
-  }, u3 = {
+  }, u2 = {
     isColorSupported: e
   }, d = (r2) => `\x1B[${r2}m`;
   for (let [r2, t] of h)
-    u3[r2] = e ? g(
+    u2[r2] = e ? g(
       d(t[0]),
       d(t[1]),
       t[2]
     ) : a;
-  return u3;
+  return u2;
 }
 var r = process.env.FORCE_TTY !== void 0 || (0, import_tty.isatty)(1);
 var u = p(r);
 function _mergeNamespaces(n, m2) {
   m2.forEach(function(e) {
-    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k2) {
-      if (k2 !== "default" && !(k2 in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k2);
-        Object.defineProperty(n, k2, d.get ? d : {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+      if (k !== "default" && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
           enumerable: true,
           get: function() {
-            return e[k2];
+            return e[k];
           }
         });
       }
@@ -743,7 +743,7 @@ function printIteratorValues(iterator, config2, indentation, depth, refs, printe
 function printListItems(list, config2, indentation, depth, refs, printer2) {
   let result = "";
   list = list instanceof ArrayBuffer ? new DataView(list) : list;
-  const isDataView = (l2) => l2 instanceof DataView;
+  const isDataView = (l) => l instanceof DataView;
   const length = isDataView(list) ? list.byteLength : list.length;
   if (length > 0) {
     result += config2.spacingOuter;
@@ -1004,8 +1004,8 @@ var plugin$2 = {
   serialize: serialize$2,
   test: test$2
 };
-function getDefaultExportFromCjs(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var reactIs$1 = { exports: {} };
 var reactIs_production = {};
@@ -1217,25 +1217,25 @@ var hasRequiredReactIs_production_min;
 function requireReactIs_production_min() {
   if (hasRequiredReactIs_production_min) return reactIs_production_min;
   hasRequiredReactIs_production_min = 1;
-  var b2 = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f4 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h4 = Symbol.for("react.context"), k2 = Symbol.for("react.server_context"), l2 = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u3;
-  u3 = Symbol.for("react.module.reference");
-  function v2(a3) {
+  var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f3 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h3 = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u2;
+  u2 = Symbol.for("react.module.reference");
+  function v(a3) {
     if ("object" === typeof a3 && null !== a3) {
       var r2 = a3.$$typeof;
       switch (r2) {
-        case b2:
+        case b:
           switch (a3 = a3.type, a3) {
             case d:
-            case f4:
+            case f3:
             case e:
             case m2:
             case n:
               return a3;
             default:
               switch (a3 = a3 && a3.$$typeof, a3) {
-                case k2:
-                case h4:
-                case l2:
+                case k:
+                case h3:
+                case l:
                 case q:
                 case p3:
                 case g:
@@ -1249,15 +1249,15 @@ function requireReactIs_production_min() {
       }
     }
   }
-  reactIs_production_min.ContextConsumer = h4;
+  reactIs_production_min.ContextConsumer = h3;
   reactIs_production_min.ContextProvider = g;
-  reactIs_production_min.Element = b2;
-  reactIs_production_min.ForwardRef = l2;
+  reactIs_production_min.Element = b;
+  reactIs_production_min.ForwardRef = l;
   reactIs_production_min.Fragment = d;
   reactIs_production_min.Lazy = q;
   reactIs_production_min.Memo = p3;
   reactIs_production_min.Portal = c;
-  reactIs_production_min.Profiler = f4;
+  reactIs_production_min.Profiler = f3;
   reactIs_production_min.StrictMode = e;
   reactIs_production_min.Suspense = m2;
   reactIs_production_min.SuspenseList = n;
@@ -1268,45 +1268,45 @@ function requireReactIs_production_min() {
     return false;
   };
   reactIs_production_min.isContextConsumer = function(a3) {
-    return v2(a3) === h4;
+    return v(a3) === h3;
   };
   reactIs_production_min.isContextProvider = function(a3) {
-    return v2(a3) === g;
+    return v(a3) === g;
   };
   reactIs_production_min.isElement = function(a3) {
-    return "object" === typeof a3 && null !== a3 && a3.$$typeof === b2;
+    return "object" === typeof a3 && null !== a3 && a3.$$typeof === b;
   };
   reactIs_production_min.isForwardRef = function(a3) {
-    return v2(a3) === l2;
+    return v(a3) === l;
   };
   reactIs_production_min.isFragment = function(a3) {
-    return v2(a3) === d;
+    return v(a3) === d;
   };
   reactIs_production_min.isLazy = function(a3) {
-    return v2(a3) === q;
+    return v(a3) === q;
   };
   reactIs_production_min.isMemo = function(a3) {
-    return v2(a3) === p3;
+    return v(a3) === p3;
   };
   reactIs_production_min.isPortal = function(a3) {
-    return v2(a3) === c;
+    return v(a3) === c;
   };
   reactIs_production_min.isProfiler = function(a3) {
-    return v2(a3) === f4;
+    return v(a3) === f3;
   };
   reactIs_production_min.isStrictMode = function(a3) {
-    return v2(a3) === e;
+    return v(a3) === e;
   };
   reactIs_production_min.isSuspense = function(a3) {
-    return v2(a3) === m2;
+    return v(a3) === m2;
   };
   reactIs_production_min.isSuspenseList = function(a3) {
-    return v2(a3) === n;
+    return v(a3) === n;
   };
   reactIs_production_min.isValidElementType = function(a3) {
-    return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f4 || a3 === e || a3 === m2 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h4 || a3.$$typeof === l2 || a3.$$typeof === u3 || void 0 !== a3.getModuleId) ? true : false;
+    return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f3 || a3 === e || a3 === m2 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h3 || a3.$$typeof === l || a3.$$typeof === u2 || void 0 !== a3.getModuleId) ? true : false;
   };
-  reactIs_production_min.typeOf = v2;
+  reactIs_production_min.typeOf = v;
   return reactIs_production_min;
 }
 var reactIs_development = {};
@@ -1524,7 +1524,7 @@ var reactIsMethods = [
   "isSuspenseList",
   "isValidElementType"
 ];
-var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v2) => ReactIs18[m2](v2) || ReactIs19[m2](v2)]));
+var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v) => ReactIs18[m2](v) || ReactIs19[m2](v)]));
 function getChildren(arg, children = []) {
   if (Array.isArray(arg)) {
     for (const item of arg) {
@@ -2193,6 +2193,19 @@ function inspectSymbol(value) {
   return value.toString();
 }
 var getPromiseValue = () => "Promise{\u2026}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
 var promise_default = getPromiseValue;
 function inspectObject(object2, options) {
   const properties = Object.getOwnPropertyNames(object2);
@@ -2354,12 +2367,12 @@ var baseTypesMap = {
   HTMLCollection: inspectNodeCollection,
   NodeList: inspectNodeCollection
 };
-var inspectCustom = (value, options, type3, inspectFn) => {
+var inspectCustom = (value, options, type3) => {
   if (chaiInspect in value && typeof value[chaiInspect] === "function") {
     return value[chaiInspect](options);
   }
   if (nodeInspect in value && typeof value[nodeInspect] === "function") {
-    return value[nodeInspect](options.depth, options, inspectFn);
+    return value[nodeInspect](options.depth, options);
   }
   if ("inspect" in value && typeof value.inspect === "function") {
     return value.inspect(options.depth, options);
@@ -2384,7 +2397,7 @@ function inspect(value, opts = {}) {
     return baseTypesMap[type3](value, options);
   }
   if (customInspect && value) {
-    const output = inspectCustom(value, options, type3, inspect);
+    const output = inspectCustom(value, options, type3);
     if (output) {
       if (typeof output === "string")
         return output;
@@ -2457,14 +2470,14 @@ function format2(...args) {
   const len = args.length;
   let i = 1;
   const template = args[0];
-  let str = String(template).replace(formatRegExp, (x2) => {
-    if (x2 === "%%") {
+  let str = String(template).replace(formatRegExp, (x) => {
+    if (x === "%%") {
       return "%";
     }
     if (i >= len) {
-      return x2;
+      return x;
     }
-    switch (x2) {
+    switch (x) {
       case "%s": {
         const value = args[i++];
         if (typeof value === "bigint") {
@@ -2522,14 +2535,14 @@ function format2(...args) {
           throw err;
         }
       default:
-        return x2;
+        return x;
     }
   });
-  for (let x2 = args[i]; i < len; x2 = args[++i]) {
-    if (x2 === null || typeof x2 !== "object") {
-      str += ` ${x2}`;
+  for (let x = args[i]; i < len; x = args[++i]) {
+    if (x === null || typeof x !== "object") {
+      str += ` ${x}`;
     } else {
-      str += ` ${inspect2(x2)}`;
+      str += ` ${inspect2(x)}`;
     }
   }
   return str;
@@ -2562,8 +2575,8 @@ function objDisplay(obj, options = {}) {
   }
   return str;
 }
-function getDefaultExportFromCjs2(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs2(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 function createSimpleStackTrace(options) {
   const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
@@ -2621,15 +2634,15 @@ function deepClone(val, options = defaultCloneOptions) {
   return clone(val, seen, options);
 }
 function clone(val, seen, options = defaultCloneOptions) {
-  let k2, out;
+  let k, out;
   if (seen.has(val)) {
     return seen.get(val);
   }
   if (Array.isArray(val)) {
-    out = Array.from({ length: k2 = val.length });
+    out = Array.from({ length: k = val.length });
     seen.set(val, out);
-    while (k2--) {
-      out[k2] = clone(val[k2], seen, options);
+    while (k--) {
+      out[k] = clone(val[k], seen, options);
     }
     return out;
   }
@@ -2637,28 +2650,28 @@ function clone(val, seen, options = defaultCloneOptions) {
     out = Object.create(Object.getPrototypeOf(val));
     seen.set(val, out);
     const props = getOwnProperties(val);
-    for (const k3 of props) {
-      const descriptor = Object.getOwnPropertyDescriptor(val, k3);
+    for (const k2 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
       if (!descriptor) {
         continue;
       }
-      const cloned = clone(val[k3], seen, options);
+      const cloned = clone(val[k2], seen, options);
       if (options.forceWritable) {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           enumerable: descriptor.enumerable,
           configurable: true,
           writable: true,
           value: cloned
         });
       } else if ("get" in descriptor) {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           ...descriptor,
           get() {
             return cloned;
           }
         });
       } else {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           ...descriptor,
           value: cloned
         });
@@ -4043,19 +4056,19 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   let aEnd = 0;
   let bEnd = 0;
   const pushCommonLine = (line) => {
-    const j2 = lines.length;
-    lines.push(printCommonLine(line, j2 === 0 || j2 === jLast, options));
+    const j = lines.length;
+    lines.push(printCommonLine(line, j === 0 || j === jLast, options));
     aEnd += 1;
     bEnd += 1;
   };
   const pushDeleteLine = (line) => {
-    const j2 = lines.length;
-    lines.push(printDeleteLine(line, j2 === 0 || j2 === jLast, options));
+    const j = lines.length;
+    lines.push(printDeleteLine(line, j === 0 || j === jLast, options));
     aEnd += 1;
   };
   const pushInsertLine = (line) => {
-    const j2 = lines.length;
-    lines.push(printInsertLine(line, j2 === 0 || j2 === jLast, options));
+    const j = lines.length;
+    lines.push(printInsertLine(line, j === 0 || j === jLast, options));
     bEnd += 1;
   };
   i = 0;
@@ -4182,20 +4195,20 @@ function isEmptyString(lines) {
 }
 function countChanges(diffs) {
   let a3 = 0;
-  let b2 = 0;
+  let b = 0;
   diffs.forEach((diff2) => {
     switch (diff2[0]) {
       case DIFF_DELETE:
         a3 += 1;
         break;
       case DIFF_INSERT:
-        b2 += 1;
+        b += 1;
         break;
     }
   });
   return {
     a: a3,
-    b: b2
+    b
   };
 }
 function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
@@ -4217,9 +4230,9 @@ function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor,
     bRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;
   }
   const a3 = `${aIndicator} ${aAnnotation}${aRest}`;
-  const b2 = `${bIndicator} ${bAnnotation}${bRest}`;
+  const b = `${bIndicator} ${bAnnotation}${bRest}`;
   return `${aColor(a3)}
-${bColor(b2)}
+${bColor(b)}
 
 `;
 }
@@ -4333,25 +4346,25 @@ function getType3(value) {
 function getNewLineSymbol(string2) {
   return string2.includes("\r\n") ? "\r\n" : "\n";
 }
-function diffStrings(a3, b2, options) {
+function diffStrings(a3, b, options) {
   const truncate3 = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
   const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? 0), 0);
   let aLength = a3.length;
-  let bLength = b2.length;
+  let bLength = b.length;
   if (truncate3) {
     const aMultipleLines = a3.includes("\n");
-    const bMultipleLines = b2.includes("\n");
+    const bMultipleLines = b.includes("\n");
     const aNewLineSymbol = getNewLineSymbol(a3);
-    const bNewLineSymbol = getNewLineSymbol(b2);
+    const bNewLineSymbol = getNewLineSymbol(b);
     const _a = aMultipleLines ? `${a3.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
 ` : a3;
-    const _b = bMultipleLines ? `${b2.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
-` : b2;
+    const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
+` : b;
     aLength = _a.length;
     bLength = _b.length;
   }
-  const truncated = aLength !== a3.length || bLength !== b2.length;
-  const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b2[bIndex2];
+  const truncated = aLength !== a3.length || bLength !== b.length;
+  const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b[bIndex2];
   let aIndex = 0;
   let bIndex = 0;
   const diffs = [];
@@ -4360,18 +4373,18 @@ function diffStrings(a3, b2, options) {
       diffs.push(new Diff(DIFF_DELETE, a3.slice(aIndex, aCommon)));
     }
     if (bIndex !== bCommon) {
-      diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex, bCommon)));
+      diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
     }
     aIndex = aCommon + nCommon;
     bIndex = bCommon + nCommon;
-    diffs.push(new Diff(DIFF_EQUAL, b2.slice(bCommon, bIndex)));
+    diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
   };
   diffSequences(aLength, bLength, isCommon, foundSubsequence);
   if (aIndex !== aLength) {
     diffs.push(new Diff(DIFF_DELETE, a3.slice(aIndex)));
   }
   if (bIndex !== bLength) {
-    diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex)));
+    diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
   }
   return [diffs, truncated];
 }
@@ -4513,22 +4526,22 @@ function hasCommonDiff(diffs, isMultiline) {
   }
   return diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
 }
-function diffStringsUnified(a3, b2, options) {
-  if (a3 !== b2 && a3.length !== 0 && b2.length !== 0) {
-    const isMultiline = a3.includes("\n") || b2.includes("\n");
+function diffStringsUnified(a3, b, options) {
+  if (a3 !== b && a3.length !== 0 && b.length !== 0) {
+    const isMultiline = a3.includes("\n") || b.includes("\n");
     const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a3}
-` : a3, isMultiline ? `${b2}
-` : b2, true, options);
+` : a3, isMultiline ? `${b}
+` : b, true, options);
     if (hasCommonDiff(diffs, isMultiline)) {
       const optionsNormalized = normalizeDiffOptions(options);
       const lines = getAlignedDiffs(diffs, optionsNormalized.changeColor);
       return printDiffLines(lines, truncated, optionsNormalized);
     }
   }
-  return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
+  return diffLinesUnified(a3.split("\n"), b.split("\n"), options);
 }
-function diffStringsRaw(a3, b2, cleanup, options) {
-  const [diffs, truncated] = diffStrings(a3, b2, options);
+function diffStringsRaw(a3, b, cleanup, options) {
+  const [diffs, truncated] = diffStrings(a3, b, options);
   if (cleanup) {
     diff_cleanupSemantic(diffs);
   }
@@ -4557,8 +4570,8 @@ var FALLBACK_FORMAT_OPTIONS = {
   maxDepth: 8,
   plugins: PLUGINS2
 };
-function diff(a3, b2, options) {
-  if (Object.is(a3, b2)) {
+function diff(a3, b, options) {
+  if (Object.is(a3, b)) {
     return "";
   }
   const aType = getType3(a3);
@@ -4574,7 +4587,7 @@ function diff(a3, b2, options) {
     expectedType = a3.getExpectedType();
     omitDifference = expectedType === "string";
   }
-  if (expectedType !== getType3(b2)) {
+  if (expectedType !== getType3(b)) {
     let truncate4 = function(s2) {
       return s2.length <= MAX_LENGTH ? s2 : `${s2.slice(0, MAX_LENGTH)}...`;
     };
@@ -4582,7 +4595,7 @@ function diff(a3, b2, options) {
     const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
     let aDisplay = format(a3, formatOptions);
-    let bDisplay = format(b2, formatOptions);
+    let bDisplay = format(b, formatOptions);
     const MAX_LENGTH = 1e5;
     aDisplay = truncate4(aDisplay);
     bDisplay = truncate4(bDisplay);
@@ -4599,21 +4612,21 @@ ${bDiff}`;
   }
   switch (aType) {
     case "string":
-      return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
+      return diffLinesUnified(a3.split("\n"), b.split("\n"), options);
     case "boolean":
     case "number":
-      return comparePrimitive(a3, b2, options);
+      return comparePrimitive(a3, b, options);
     case "map":
-      return compareObjects(sortMap(a3), sortMap(b2), options);
+      return compareObjects(sortMap(a3), sortMap(b), options);
     case "set":
-      return compareObjects(sortSet(a3), sortSet(b2), options);
+      return compareObjects(sortSet(a3), sortSet(b), options);
     default:
-      return compareObjects(a3, b2, options);
+      return compareObjects(a3, b, options);
   }
 }
-function comparePrimitive(a3, b2, options) {
+function comparePrimitive(a3, b, options) {
   const aFormat = format(a3, FORMAT_OPTIONS);
-  const bFormat = format(b2, FORMAT_OPTIONS);
+  const bFormat = format(b, FORMAT_OPTIONS);
   return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
 }
 function sortMap(map2) {
@@ -4622,19 +4635,19 @@ function sortMap(map2) {
 function sortSet(set3) {
   return new Set(Array.from(set3.values()).sort());
 }
-function compareObjects(a3, b2, options) {
+function compareObjects(a3, b, options) {
   let difference;
   let hasThrown = false;
   try {
     const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a3, b2, formatOptions, options);
+    difference = getObjectsDifference(a3, b, formatOptions, options);
   } catch {
     hasThrown = true;
   }
   const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
   if (difference === void 0 || difference === noDiffMessage) {
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a3, b2, formatOptions, options);
+    difference = getObjectsDifference(a3, b, formatOptions, options);
     if (difference !== noDiffMessage && !hasThrown) {
       difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
 
@@ -4652,18 +4665,18 @@ function getFormatOptions(formatOptions, options) {
     maxDepth: maxDepth ?? formatOptions.maxDepth
   };
 }
-function getObjectsDifference(a3, b2, formatOptions, options) {
+function getObjectsDifference(a3, b, formatOptions, options) {
   const formatOptionsZeroIndent = {
     ...formatOptions,
     indent: 0
   };
   const aCompare = format(a3, formatOptionsZeroIndent);
-  const bCompare = format(b2, formatOptionsZeroIndent);
+  const bCompare = format(b, formatOptionsZeroIndent);
   if (aCompare === bCompare) {
     return getCommonMessage(NO_DIFF_MESSAGE, options);
   } else {
     const aDisplay = format(a3, formatOptions);
-    const bDisplay = format(b2, formatOptions);
+    const bDisplay = format(b, formatOptions);
     return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
   }
 }
@@ -4758,163 +4771,163 @@ function printExpected(value) {
 function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
   return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? u.inverse(diff2[1]) : diff2[1] : ""), "");
 }
-function S(e, t) {
-  if (!e)
-    throw new Error(t);
+function assert(condition, message) {
+  if (!condition)
+    throw new Error(message);
 }
-function f2(e, t) {
-  return typeof t === e;
+function isType(type3, value) {
+  return typeof value === type3;
 }
-function w(e) {
-  return e instanceof Promise;
+function isPromise(value) {
+  return value instanceof Promise;
 }
-function u2(e, t, r2) {
-  Object.defineProperty(e, t, r2);
+function define(obj, key, descriptor) {
+  Object.defineProperty(obj, key, descriptor);
 }
-function l(e, t, r2) {
-  u2(e, t, { value: r2, configurable: true, writable: true });
+function defineValue(obj, key, value) {
+  define(obj, key, { value, configurable: true, writable: true });
 }
-var y = Symbol.for("tinyspy:spy");
-var x = /* @__PURE__ */ new Set();
-var h2 = (e) => {
-  e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.resolves = [], e.next = [];
+var SYMBOL_STATE = Symbol.for("tinyspy:spy");
+var spies = /* @__PURE__ */ new Set();
+var reset = (state) => {
+  state.called = false, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
 };
-var k = (e) => (u2(e, y, {
-  value: { reset: () => h2(e[y]) }
-}), e[y]);
-var T = (e) => e[y] || k(e);
-function R(e) {
-  S(
-    f2("function", e) || f2("undefined", e),
+var defineState = (spy2) => (define(spy2, SYMBOL_STATE, {
+  value: { reset: () => reset(spy2[SYMBOL_STATE]) }
+}), spy2[SYMBOL_STATE]);
+var getInternalState = (spy2) => spy2[SYMBOL_STATE] || defineState(spy2);
+function createInternalSpy(cb) {
+  assert(
+    isType("function", cb) || isType("undefined", cb),
     "cannot spy on a non-function value"
   );
-  let t = function(...s2) {
-    let n = T(t);
-    n.called = true, n.callCount++, n.calls.push(s2);
-    let d = n.next.shift();
-    if (d) {
-      n.results.push(d);
-      let [a3, i] = d;
-      if (a3 === "ok")
-        return i;
-      throw i;
-    }
-    let o, c = "ok", p3 = n.results.length;
-    if (n.impl)
+  let fn2 = function(...args) {
+    let state2 = getInternalState(fn2);
+    state2.called = true, state2.callCount++, state2.calls.push(args);
+    let next = state2.next.shift();
+    if (next) {
+      state2.results.push(next);
+      let [type22, result2] = next;
+      if (type22 === "ok")
+        return result2;
+      throw result2;
+    }
+    let result, type3 = "ok", resultIndex = state2.results.length;
+    if (state2.impl)
       try {
-        new.target ? o = Reflect.construct(n.impl, s2, new.target) : o = n.impl.apply(this, s2), c = "ok";
-      } catch (a3) {
-        throw o = a3, c = "error", n.results.push([c, a3]), a3;
-      }
-    let g = [c, o];
-    return w(o) && o.then(
-      (a3) => n.resolves[p3] = ["ok", a3],
-      (a3) => n.resolves[p3] = ["error", a3]
-    ), n.results.push(g), o;
+        new.target ? result = Reflect.construct(state2.impl, args, new.target) : result = state2.impl.apply(this, args), type3 = "ok";
+      } catch (err) {
+        throw result = err, type3 = "error", state2.results.push([type3, err]), err;
+      }
+    let resultTuple = [type3, result];
+    return isPromise(result) && result.then(
+      (r2) => state2.resolves[resultIndex] = ["ok", r2],
+      (e) => state2.resolves[resultIndex] = ["error", e]
+    ), state2.results.push(resultTuple), result;
   };
-  l(t, "_isMockFunction", true), l(t, "length", e ? e.length : 0), l(t, "name", e && e.name || "spy");
-  let r2 = T(t);
-  return r2.reset(), r2.impl = e, t;
-}
-function v(e) {
-  return !!e && e._isMockFunction === true;
-}
-var b = (e, t) => {
-  let r2 = Object.getOwnPropertyDescriptor(e, t);
-  if (r2)
-    return [e, r2];
-  let s2 = Object.getPrototypeOf(e);
-  for (; s2 !== null; ) {
-    let n = Object.getOwnPropertyDescriptor(s2, t);
-    if (n)
-      return [s2, n];
-    s2 = Object.getPrototypeOf(s2);
+  defineValue(fn2, "_isMockFunction", true), defineValue(fn2, "length", cb ? cb.length : 0), defineValue(fn2, "name", cb && cb.name || "spy");
+  let state = getInternalState(fn2);
+  return state.reset(), state.impl = cb, fn2;
+}
+function isMockFunction(obj) {
+  return !!obj && obj._isMockFunction === true;
+}
+var getDescriptor = (obj, method) => {
+  let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+  if (objDescriptor)
+    return [obj, objDescriptor];
+  let currentProto = Object.getPrototypeOf(obj);
+  for (; currentProto !== null; ) {
+    let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+    if (descriptor)
+      return [currentProto, descriptor];
+    currentProto = Object.getPrototypeOf(currentProto);
   }
 };
-var P = (e, t) => {
-  t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
+var setPototype = (fn2, val) => {
+  val != null && typeof val == "function" && val.prototype != null && Object.setPrototypeOf(fn2.prototype, val.prototype);
 };
-function M(e, t, r2) {
-  S(
-    !f2("undefined", e),
+function internalSpyOn(obj, methodName, mock) {
+  assert(
+    !isType("undefined", obj),
     "spyOn could not find an object to spy upon"
-  ), S(
-    f2("object", e) || f2("function", e),
+  ), assert(
+    isType("object", obj) || isType("function", obj),
     "cannot spyOn on a primitive value"
   );
-  let [s2, n] = (() => {
-    if (!f2("object", t))
-      return [t, "value"];
-    if ("getter" in t && "setter" in t)
+  let [accessName, accessType] = (() => {
+    if (!isType("object", methodName))
+      return [methodName, "value"];
+    if ("getter" in methodName && "setter" in methodName)
       throw new Error("cannot spy on both getter and setter");
-    if ("getter" in t)
-      return [t.getter, "get"];
-    if ("setter" in t)
-      return [t.setter, "set"];
+    if ("getter" in methodName)
+      return [methodName.getter, "get"];
+    if ("setter" in methodName)
+      return [methodName.setter, "set"];
     throw new Error("specify getter or setter to spy on");
-  })(), [d, o] = b(e, s2) || [];
-  S(
-    o || s2 in e,
-    `${String(s2)} does not exist`
+  })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
+  assert(
+    originalDescriptor || accessName in obj,
+    `${String(accessName)} does not exist`
   );
-  let c = false;
-  n === "value" && o && !o.value && o.get && (n = "get", c = true, r2 = o.get());
-  let p3;
-  o ? p3 = o[n] : n !== "value" ? p3 = () => e[s2] : p3 = e[s2], p3 && j(p3) && (p3 = p3[y].getOriginal());
-  let g = (I) => {
-    let { value: F, ...O } = o || {
+  let ssr = false;
+  accessType === "value" && originalDescriptor && !originalDescriptor.value && originalDescriptor.get && (accessType = "get", ssr = true, mock = originalDescriptor.get());
+  let original;
+  originalDescriptor ? original = originalDescriptor[accessType] : accessType !== "value" ? original = () => obj[accessName] : original = obj[accessName], original && isSpyFunction(original) && (original = original[SYMBOL_STATE].getOriginal());
+  let reassign = (cb) => {
+    let { value, ...desc } = originalDescriptor || {
       configurable: true,
       writable: true
     };
-    n !== "value" && delete O.writable, O[n] = I, u2(e, s2, O);
-  }, a3 = () => {
-    d !== e ? Reflect.deleteProperty(e, s2) : o && !p3 ? u2(e, s2, o) : g(p3);
+    accessType !== "value" && delete desc.writable, desc[accessType] = cb, define(obj, accessName, desc);
+  }, restore = () => {
+    originalDescriptorObject !== obj ? Reflect.deleteProperty(obj, accessName) : originalDescriptor && !original ? define(obj, accessName, originalDescriptor) : reassign(original);
   };
-  r2 || (r2 = p3);
-  let i = E(R(r2), r2);
-  n === "value" && P(i, p3);
-  let m2 = i[y];
-  return l(m2, "restore", a3), l(m2, "getOriginal", () => c ? p3() : p3), l(m2, "willCall", (I) => (m2.impl = I, i)), g(
-    c ? () => (P(i, r2), i) : i
-  ), x.add(i), i;
-}
-var K = /* @__PURE__ */ new Set([
+  mock || (mock = original);
+  let spy2 = wrap(createInternalSpy(mock), mock);
+  accessType === "value" && setPototype(spy2, original);
+  let state = spy2[SYMBOL_STATE];
+  return defineValue(state, "restore", restore), defineValue(state, "getOriginal", () => ssr ? original() : original), defineValue(state, "willCall", (newCb) => (state.impl = newCb, spy2)), reassign(
+    ssr ? () => (setPototype(spy2, mock), spy2) : spy2
+  ), spies.add(spy2), spy2;
+}
+var ignoreProperties = /* @__PURE__ */ new Set([
   "length",
   "name",
   "prototype"
 ]);
-function D(e) {
-  let t = /* @__PURE__ */ new Set(), r2 = {};
-  for (; e && e !== Object.prototype && e !== Function.prototype; ) {
-    let s2 = [
-      ...Object.getOwnPropertyNames(e),
-      ...Object.getOwnPropertySymbols(e)
+function getAllProperties(original) {
+  let properties = /* @__PURE__ */ new Set(), descriptors2 = {};
+  for (; original && original !== Object.prototype && original !== Function.prototype; ) {
+    let ownProperties = [
+      ...Object.getOwnPropertyNames(original),
+      ...Object.getOwnPropertySymbols(original)
     ];
-    for (let n of s2)
-      r2[n] || K.has(n) || (t.add(n), r2[n] = Object.getOwnPropertyDescriptor(e, n));
-    e = Object.getPrototypeOf(e);
+    for (let prop of ownProperties)
+      descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
+    original = Object.getPrototypeOf(original);
   }
   return {
-    properties: t,
-    descriptors: r2
+    properties,
+    descriptors: descriptors2
   };
 }
-function E(e, t) {
-  if (!t || // the original is already a spy, so it has all the properties
-  y in t)
-    return e;
-  let { properties: r2, descriptors: s2 } = D(t);
-  for (let n of r2) {
-    let d = s2[n];
-    b(e, n) || u2(e, n, d);
+function wrap(mock, original) {
+  if (!original || // the original is already a spy, so it has all the properties
+  SYMBOL_STATE in original)
+    return mock;
+  let { properties, descriptors: descriptors2 } = getAllProperties(original);
+  for (let key of properties) {
+    let descriptor = descriptors2[key];
+    getDescriptor(mock, key) || define(mock, key, descriptor);
   }
-  return e;
+  return mock;
 }
-function j(e) {
-  return v(e) && "getOriginal" in e[y];
+function isSpyFunction(obj) {
+  return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
 }
 var mocks = /* @__PURE__ */ new Set();
-function isMockFunction(fn2) {
+function isMockFunction2(fn2) {
   return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
 }
 function spyOn(obj, method, accessType) {
@@ -4924,13 +4937,13 @@ function spyOn(obj, method, accessType) {
   };
   const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
   let state;
-  const descriptor = getDescriptor(obj, method);
+  const descriptor = getDescriptor2(obj, method);
   const fn2 = descriptor && descriptor[accessType || "value"];
-  if (isMockFunction(fn2)) {
+  if (isMockFunction2(fn2)) {
     state = fn2.mock._state();
   }
   try {
-    const stub = M(obj, objMethod);
+    const stub = internalSpyOn(obj, objMethod);
     const spy = enhanceSpy(stub);
     if (state) {
       spy.mock._state(state);
@@ -4952,7 +4965,7 @@ function enhanceSpy(spy) {
   let instances = [];
   let contexts = [];
   let invocations = [];
-  const state = T(spy);
+  const state = getInternalState(spy);
   const mockContext = {
     get calls() {
       return state.calls;
@@ -5050,18 +5063,18 @@ function enhanceSpy(spy) {
     implementation = fn2;
     state.willCall(mockCall);
     implementationChangedTemporarily = true;
-    const reset = () => {
+    const reset2 = () => {
       implementation = originalImplementation;
       implementationChangedTemporarily = false;
     };
     const result = cb();
     if (typeof result === "object" && result && typeof result.then === "function") {
       return result.then(() => {
-        reset();
+        reset2();
         return stub;
       });
     }
-    reset();
+    reset2();
     return stub;
   }
   stub.withImplementation = withImplementation;
@@ -5080,14 +5093,14 @@ function enhanceSpy(spy) {
   return stub;
 }
 function fn(implementation) {
-  const enhancedSpy = enhanceSpy(M({ spy: implementation || function() {
+  const enhancedSpy = enhanceSpy(internalSpyOn({ spy: implementation || function() {
   } }, "spy"));
   if (implementation) {
     enhancedSpy.mockImplementation(implementation);
   }
   return enhancedSpy;
 }
-function getDescriptor(obj, method) {
+function getDescriptor2(obj, method) {
   const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
   if (objDescriptor) {
     return objDescriptor;
@@ -5103,8 +5116,8 @@ function getDescriptor(obj, method) {
 }
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
-function isImmutable(v2) {
-  return v2 && (v2[IS_COLLECTION_SYMBOL] || v2[IS_RECORD_SYMBOL]);
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
 }
 var OBJECT_PROTO = Object.getPrototypeOf({});
 function getUnserializableMessage(err) {
@@ -5250,11 +5263,19 @@ Inner error message: ${err === null || err === void 0 ? void 0 : err.message}`))
   }
 }
 var __defProp2 = Object.defineProperty;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+var __commonJS2 = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, { get: all[name], enumerable: true });
 };
+var require_util = __commonJS2({
+  "(disabled):util"() {
+  }
+});
 var utils_exports = {};
 __export2(utils_exports, {
   addChainableMethod: () => addChainableMethod,
@@ -5352,7 +5373,7 @@ function getMessage(errorLike) {
 }
 __name(getMessage, "getMessage");
 function flag(obj, key, value) {
-  let flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));
+  var flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null));
   if (arguments.length === 3) {
     flags[key] = value;
   } else {
@@ -5361,7 +5382,7 @@ function flag(obj, key, value) {
 }
 __name(flag, "flag");
 function test2(obj, args) {
-  let negate = flag(obj, "negate"), expr = args[0];
+  var negate = flag(obj, "negate"), expr = args[0];
   return negate ? !expr : expr;
 }
 __name(test2, "test");
@@ -5415,20 +5436,20 @@ var AssertionError = class _AssertionError extends Error {
   }
 };
 function expectTypes(obj, types) {
-  let flagMsg = flag(obj, "message");
-  let ssfi = flag(obj, "ssfi");
+  var flagMsg = flag(obj, "message");
+  var ssfi = flag(obj, "ssfi");
   flagMsg = flagMsg ? flagMsg + ": " : "";
   obj = flag(obj, "object");
   types = types.map(function(t) {
     return t.toLowerCase();
   });
   types.sort();
-  let str = types.map(function(t, index2) {
-    let art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";
-    let or = types.length > 1 && index2 === types.length - 1 ? "or " : "";
+  var str = types.map(function(t, index2) {
+    var art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a";
+    var or = types.length > 1 && index2 === types.length - 1 ? "or " : "";
     return or + art + " " + t;
   }).join(", ");
-  let objType = type(obj).toLowerCase();
+  var objType = type(obj).toLowerCase();
   if (!types.some(function(expected) {
     return objType === expected;
   })) {
@@ -5686,8 +5707,10 @@ function mapToEntries2(map2) {
 }
 __name(mapToEntries2, "mapToEntries");
 function inspectMap2(map2, options) {
-  if (map2.size === 0)
+  const size = map2.size - 1;
+  if (size <= 0) {
     return "Map{}";
+  }
   options.truncate -= 7;
   return `Map{ ${inspectList2(mapToEntries2(map2), options, inspectMapEntry2)} }`;
 }
@@ -5769,6 +5792,19 @@ function inspectSymbol2(value) {
 }
 __name(inspectSymbol2, "inspectSymbol");
 var getPromiseValue2 = /* @__PURE__ */ __name(() => "Promise{\u2026}", "getPromiseValue");
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue2 = /* @__PURE__ */ __name((value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    }, "getPromiseValue");
+  }
+} catch (notNode) {
+}
 var promise_default2 = getPromiseValue2;
 function inspectObject3(object2, options) {
   const properties = Object.getOwnPropertyNames(object2);
@@ -5855,21 +5891,10 @@ function inspectAttribute2([key, value], options) {
   return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
 }
 __name(inspectAttribute2, "inspectAttribute");
-function inspectNodeCollection2(collection, options) {
-  return inspectList2(collection, options, inspectNode2, "\n");
-}
-__name(inspectNodeCollection2, "inspectNodeCollection");
-function inspectNode2(node, options) {
-  switch (node.nodeType) {
-    case 1:
-      return inspectHTML2(node, options);
-    case 3:
-      return options.inspect(node.data, options);
-    default:
-      return options.inspect(node, options);
-  }
+function inspectHTMLCollection(collection, options) {
+  return inspectList2(collection, options, inspectHTML2, "\n");
 }
-__name(inspectNode2, "inspectNode");
+__name(inspectHTMLCollection, "inspectHTMLCollection");
 function inspectHTML2(element, options) {
   const properties = element.getAttributeNames();
   const name = element.tagName.toLowerCase();
@@ -5884,7 +5909,7 @@ function inspectHTML2(element, options) {
   }
   options.truncate -= propertyContents.length;
   const truncate22 = options.truncate;
-  let children = inspectNodeCollection2(element.children, options);
+  let children = inspectHTMLCollection(element.children, options);
   if (children && children.length > truncate22) {
     children = `${truncator2}(${element.children.length})`;
   }
@@ -5893,14 +5918,20 @@ function inspectHTML2(element, options) {
 __name(inspectHTML2, "inspectHTML");
 var symbolsSupported2 = typeof Symbol === "function" && typeof Symbol.for === "function";
 var chaiInspect2 = symbolsSupported2 ? Symbol.for("chai/inspect") : "@@chai/inspect";
-var nodeInspect2 = Symbol.for("nodejs.util.inspect.custom");
+var nodeInspect2 = false;
+try {
+  const nodeUtil = require_util();
+  nodeInspect2 = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect2 = false;
+}
 var constructorMap2 = /* @__PURE__ */ new WeakMap();
 var stringTagMap2 = {};
 var baseTypesMap2 = {
-  undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"),
-  null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"),
-  boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"),
-  Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"),
+  undefined: (value, options) => options.stylize("undefined", "undefined"),
+  null: (value, options) => options.stylize("null", "null"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
   number: inspectNumber2,
   Number: inspectNumber2,
   bigint: inspectBigInt2,
@@ -5919,8 +5950,8 @@ var baseTypesMap2 = {
   RegExp: inspectRegExp2,
   Promise: promise_default2,
   // WeakSet, WeakMap are totally opaque to us
-  WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
-  WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
+  WeakSet: (value, options) => options.stylize("WeakSet{\u2026}", "special"),
+  WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "special"),
   Arguments: inspectArguments2,
   Int8Array: inspectTypedArray2,
   Uint8Array: inspectTypedArray2,
@@ -5931,18 +5962,18 @@ var baseTypesMap2 = {
   Uint32Array: inspectTypedArray2,
   Float32Array: inspectTypedArray2,
   Float64Array: inspectTypedArray2,
-  Generator: /* @__PURE__ */ __name(() => "", "Generator"),
-  DataView: /* @__PURE__ */ __name(() => "", "DataView"),
-  ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"),
+  Generator: () => "",
+  DataView: () => "",
+  ArrayBuffer: () => "",
   Error: inspectObject22,
-  HTMLCollection: inspectNodeCollection2,
-  NodeList: inspectNodeCollection2
+  HTMLCollection: inspectHTMLCollection,
+  NodeList: inspectHTMLCollection
 };
 var inspectCustom2 = /* @__PURE__ */ __name((value, options, type3) => {
   if (chaiInspect2 in value && typeof value[chaiInspect2] === "function") {
     return value[chaiInspect2](options);
   }
-  if (nodeInspect2 in value && typeof value[nodeInspect2] === "function") {
+  if (nodeInspect2 && nodeInspect2 in value && typeof value[nodeInspect2] === "function") {
     return value[nodeInspect2](options.depth, options);
   }
   if ("inspect" in value && typeof value.inspect === "function") {
@@ -6102,7 +6133,7 @@ var config = {
   deepEqual: null
 };
 function inspect22(obj, showHidden, depth, colors) {
-  let options = {
+  var options = {
     colors,
     depth: typeof depth === "undefined" ? 2 : depth,
     showHidden,
@@ -6112,14 +6143,14 @@ function inspect22(obj, showHidden, depth, colors) {
 }
 __name(inspect22, "inspect");
 function objDisplay2(obj) {
-  let str = inspect22(obj), type3 = Object.prototype.toString.call(obj);
+  var str = inspect22(obj), type3 = Object.prototype.toString.call(obj);
   if (config.truncateThreshold && str.length >= config.truncateThreshold) {
     if (type3 === "[object Function]") {
       return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";
     } else if (type3 === "[object Array]") {
       return "[ Array(" + obj.length + ") ]";
     } else if (type3 === "[object Object]") {
-      let keys2 = Object.keys(obj), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
+      var keys2 = Object.keys(obj), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
       return "{ Object (" + kstr + ") }";
     } else {
       return str;
@@ -6130,13 +6161,9 @@ function objDisplay2(obj) {
 }
 __name(objDisplay2, "objDisplay");
 function getMessage2(obj, args) {
-  let negate = flag(obj, "negate");
-  let val = flag(obj, "object");
-  let expected = args[3];
-  let actual = getActual(obj, args);
-  let msg = negate ? args[2] : args[1];
-  let flagMsg = flag(obj, "message");
-  if (typeof msg === "function") msg = msg();
+  var negate = flag(obj, "negate"), val = flag(obj, "object"), expected = args[3], actual = getActual(obj, args), msg = negate ? args[2] : args[1], flagMsg = flag(obj, "message");
+  if (typeof msg === "function")
+    msg = msg();
   msg = msg || "";
   msg = msg.replace(/#\{this\}/g, function() {
     return objDisplay2(val);
@@ -6149,12 +6176,12 @@ function getMessage2(obj, args) {
 }
 __name(getMessage2, "getMessage");
 function transferFlags(assertion, object2, includeAll) {
-  let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
+  var flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
   if (!object2.__flags) {
     object2.__flags = /* @__PURE__ */ Object.create(null);
   }
   includeAll = arguments.length === 3 ? includeAll : true;
-  for (let flag3 in flags) {
+  for (var flag3 in flags) {
     if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {
       object2.__flags[flag3] = flags[flag3];
     }
@@ -6542,183 +6569,96 @@ function getPathInfo(obj, path2) {
   return info;
 }
 __name(getPathInfo, "getPathInfo");
-var Assertion = class _Assertion {
-  static {
-    __name(this, "Assertion");
-  }
-  /** @type {{}} */
-  __flags = {};
-  /**
-   * 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) {
-    flag(this, "ssfi", ssfi || _Assertion);
-    flag(this, "lockSsfi", lockSsfi);
-    flag(this, "object", obj);
-    flag(this, "message", msg);
-    flag(this, "eql", config.deepEqual || deep_eql_default);
-    return proxify(this);
-  }
-  /** @returns {boolean} */
-  static get includeStack() {
+function Assertion(obj, msg, ssfi, lockSsfi) {
+  flag(this, "ssfi", ssfi || Assertion);
+  flag(this, "lockSsfi", lockSsfi);
+  flag(this, "object", obj);
+  flag(this, "message", msg);
+  flag(this, "eql", config.deepEqual || deep_eql_default);
+  return proxify(this);
+}
+__name(Assertion, "Assertion");
+Object.defineProperty(Assertion, "includeStack", {
+  get: function() {
     console.warn(
       "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
     );
     return config.includeStack;
-  }
-  /** @param {boolean} value */
-  static set includeStack(value) {
+  },
+  set: function(value) {
     console.warn(
       "Assertion.includeStack is deprecated, use chai.config.includeStack instead."
     );
     config.includeStack = value;
   }
-  /** @returns {boolean} */
-  static get showDiff() {
+});
+Object.defineProperty(Assertion, "showDiff", {
+  get: function() {
     console.warn(
       "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
     );
     return config.showDiff;
-  }
-  /** @param {boolean} value */
-  static set showDiff(value) {
+  },
+  set: function(value) {
     console.warn(
       "Assertion.showDiff is deprecated, use chai.config.showDiff instead."
     );
     config.showDiff = value;
   }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   */
-  static addProperty(name, fn2) {
-    addProperty(this.prototype, name, fn2);
-  }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   */
-  static addMethod(name, fn2) {
-    addMethod(this.prototype, name, fn2);
-  }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   * @param {Function} chainingBehavior
-   */
-  static addChainableMethod(name, fn2, chainingBehavior) {
-    addChainableMethod(this.prototype, name, fn2, chainingBehavior);
-  }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   */
-  static overwriteProperty(name, fn2) {
-    overwriteProperty(this.prototype, name, fn2);
-  }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   */
-  static overwriteMethod(name, fn2) {
-    overwriteMethod(this.prototype, name, fn2);
-  }
-  /**
-   * @param {string} name
-   * @param {Function} fn
-   * @param {Function} chainingBehavior
-   */
-  static overwriteChainableMethod(name, fn2, chainingBehavior) {
-    overwriteChainableMethod(this.prototype, name, fn2, 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 = test2(this, arguments);
-    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);
-      const assertionErrorObjectProperties = {
-        actual,
-        expected,
-        showDiff
-      };
-      const operator = getOperator(this, arguments);
-      if (operator) {
-        assertionErrorObjectProperties.operator = operator;
-      }
-      throw new AssertionError(
-        msg,
-        assertionErrorObjectProperties,
-        // @ts-expect-error Not sure what to do about these types yet
-        config.includeStack ? this.assert : flag(this, "ssfi")
-      );
+});
+Assertion.addProperty = function(name, fn2) {
+  addProperty(this.prototype, name, fn2);
+};
+Assertion.addMethod = function(name, fn2) {
+  addMethod(this.prototype, name, fn2);
+};
+Assertion.addChainableMethod = function(name, fn2, chainingBehavior) {
+  addChainableMethod(this.prototype, name, fn2, chainingBehavior);
+};
+Assertion.overwriteProperty = function(name, fn2) {
+  overwriteProperty(this.prototype, name, fn2);
+};
+Assertion.overwriteMethod = function(name, fn2) {
+  overwriteMethod(this.prototype, name, fn2);
+};
+Assertion.overwriteChainableMethod = function(name, fn2, chainingBehavior) {
+  overwriteChainableMethod(this.prototype, name, fn2, chainingBehavior);
+};
+Assertion.prototype.assert = function(expr, msg, negateMsg, expected, _actual, showDiff) {
+  var ok = test2(this, arguments);
+  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);
+    var actual = getActual(this, arguments);
+    var assertionErrorObjectProperties = {
+      actual,
+      expected,
+      showDiff
+    };
+    var operator = getOperator(this, arguments);
+    if (operator) {
+      assertionErrorObjectProperties.operator = operator;
     }
+    throw new AssertionError(
+      msg,
+      assertionErrorObjectProperties,
+      config.includeStack ? this.assert : flag(this, "ssfi")
+    );
   }
-  /**
-   * Quick reference to stored `actual` value for plugin developers.
-   *
-   * @returns {unknown}
-   */
-  get _obj() {
+};
+Object.defineProperty(Assertion.prototype, "_obj", {
+  get: function() {
     return flag(this, "object");
-  }
-  /**
-   * Quick reference to stored `actual` value for plugin developers.
-   *
-   * @param {unknown} val
-   */
-  set _obj(val) {
+  },
+  set: function(val) {
     flag(this, "object", val);
   }
-};
+});
 function isProxyEnabled() {
   return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
 }
@@ -6731,9 +6671,10 @@ function addProperty(ctx, name, getter) {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
         flag(this, "ssfi", propertyGetter);
       }
-      let result = getter.call(this);
-      if (result !== void 0) return result;
-      let newAssertion = new Assertion();
+      var result = getter.call(this);
+      if (result !== void 0)
+        return result;
+      var newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
     }, "propertyGetter"),
@@ -6744,9 +6685,10 @@ __name(addProperty, "addProperty");
 var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
 }, "length");
 function addLengthGuard(fn2, assertionName, isChainable) {
-  if (!fnLengthDesc.configurable) return fn2;
+  if (!fnLengthDesc.configurable)
+    return fn2;
   Object.defineProperty(fn2, "length", {
-    get: /* @__PURE__ */ __name(function() {
+    get: function() {
       if (isChainable) {
         throw Error(
           "Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.'
@@ -6755,20 +6697,20 @@ function addLengthGuard(fn2, assertionName, isChainable) {
       throw Error(
         "Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".'
       );
-    }, "get")
+    }
   });
   return fn2;
 }
 __name(addLengthGuard, "addLengthGuard");
 function getProperties(object2) {
-  let result = Object.getOwnPropertyNames(object2);
+  var result = Object.getOwnPropertyNames(object2);
   function addProperty2(property) {
     if (result.indexOf(property) === -1) {
       result.push(property);
     }
   }
   __name(addProperty2, "addProperty");
-  let proto = Object.getPrototypeOf(object2);
+  var proto = Object.getPrototypeOf(object2);
   while (proto !== null) {
     Object.getOwnPropertyNames(proto).forEach(addProperty2);
     proto = Object.getPrototypeOf(proto);
@@ -6778,7 +6720,8 @@ function getProperties(object2) {
 __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)) {
@@ -6787,15 +6730,15 @@ function proxify(obj, nonChainableMethodName) {
             "Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".'
           );
         }
-        let suggestion = null;
-        let suggestionDistance = 4;
+        var suggestion = null;
+        var suggestionDistance = 4;
         getProperties(target).forEach(function(prop) {
           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);
+            var dist = stringDistanceCapped(property, prop, suggestionDistance);
             if (dist < suggestionDistance) {
               suggestion = prop;
               suggestionDistance = dist;
@@ -6822,25 +6765,25 @@ function stringDistanceCapped(strA, strB, cap) {
   if (Math.abs(strA.length - strB.length) >= cap) {
     return cap;
   }
-  let memo = [];
+  var memo = [];
   for (let i = 0; i <= strA.length; i++) {
     memo[i] = Array(strB.length + 1).fill(0);
     memo[i][0] = i;
   }
-  for (let j2 = 0; j2 < strB.length; j2++) {
-    memo[0][j2] = j2;
+  for (let j = 0; j < strB.length; j++) {
+    memo[0][j] = j;
   }
   for (let i = 1; i <= strA.length; i++) {
-    let ch = strA.charCodeAt(i - 1);
-    for (let j2 = 1; j2 <= strB.length; j2++) {
-      if (Math.abs(i - j2) >= cap) {
-        memo[i][j2] = cap;
+    var ch = strA.charCodeAt(i - 1);
+    for (let j = 1; j <= strB.length; j++) {
+      if (Math.abs(i - j) >= cap) {
+        memo[i][j] = cap;
         continue;
       }
-      memo[i][j2] = Math.min(
-        memo[i - 1][j2] + 1,
-        memo[i][j2 - 1] + 1,
-        memo[i - 1][j2 - 1] + (ch === strB.charCodeAt(j2 - 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)
       );
     }
   }
@@ -6848,13 +6791,14 @@ function stringDistanceCapped(strA, strB, cap) {
 }
 __name(stringDistanceCapped, "stringDistanceCapped");
 function addMethod(ctx, name, method) {
-  let methodWrapper = /* @__PURE__ */ __name(function() {
+  var methodWrapper = /* @__PURE__ */ __name(function() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", methodWrapper);
     }
-    let result = method.apply(this, arguments);
-    if (result !== void 0) return result;
-    let newAssertion = new Assertion();
+    var result = method.apply(this, arguments);
+    if (result !== void 0)
+      return result;
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "methodWrapper");
@@ -6863,22 +6807,23 @@ function addMethod(ctx, name, method) {
 }
 __name(addMethod, "addMethod");
 function overwriteProperty(ctx, name, getter) {
-  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
+  var _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
   }, "_super");
-  if (_get && "function" === typeof _get.get) _super = _get.get;
+  if (_get && "function" === typeof _get.get)
+    _super = _get.get;
   Object.defineProperty(ctx, name, {
     get: /* @__PURE__ */ __name(function overwritingPropertyGetter() {
       if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
         flag(this, "ssfi", overwritingPropertyGetter);
       }
-      let origLockSsfi = flag(this, "lockSsfi");
+      var origLockSsfi = flag(this, "lockSsfi");
       flag(this, "lockSsfi", true);
-      let result = getter(_super).call(this);
+      var result = getter(_super).call(this);
       flag(this, "lockSsfi", origLockSsfi);
       if (result !== void 0) {
         return result;
       }
-      let newAssertion = new Assertion();
+      var newAssertion = new Assertion();
       transferFlags(this, newAssertion);
       return newAssertion;
     }, "overwritingPropertyGetter"),
@@ -6887,22 +6832,23 @@ function overwriteProperty(ctx, name, getter) {
 }
 __name(overwriteProperty, "overwriteProperty");
 function overwriteMethod(ctx, name, method) {
-  let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
+  var _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
     throw new Error(name + " is not a function");
   }, "_super");
-  if (_method && "function" === typeof _method) _super = _method;
-  let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
+  if (_method && "function" === typeof _method)
+    _super = _method;
+  var overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", overwritingMethodWrapper);
     }
-    let origLockSsfi = flag(this, "lockSsfi");
+    var origLockSsfi = flag(this, "lockSsfi");
     flag(this, "lockSsfi", true);
-    let result = method(_super).apply(this, arguments);
+    var result = method(_super).apply(this, arguments);
     flag(this, "lockSsfi", origLockSsfi);
     if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion();
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingMethodWrapper");
@@ -6914,8 +6860,9 @@ var canSetPrototype = typeof Object.setPrototypeOf === "function";
 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;
+  var propDesc = Object.getOwnPropertyDescriptor(testFn, name);
+  if (typeof propDesc !== "object")
+    return true;
   return !propDesc.configurable;
 });
 var call = Function.prototype.call;
@@ -6925,7 +6872,7 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
     chainingBehavior = /* @__PURE__ */ __name(function() {
     }, "chainingBehavior");
   }
-  let chainableBehavior = {
+  var chainableBehavior = {
     method,
     chainingBehavior
   };
@@ -6936,31 +6883,31 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
   Object.defineProperty(ctx, name, {
     get: /* @__PURE__ */ __name(function chainableMethodGetter() {
       chainableBehavior.chainingBehavior.call(this);
-      let chainableMethodWrapper = /* @__PURE__ */ __name(function() {
+      var chainableMethodWrapper = /* @__PURE__ */ __name(function() {
         if (!flag(this, "lockSsfi")) {
           flag(this, "ssfi", chainableMethodWrapper);
         }
-        let result = chainableBehavior.method.apply(this, arguments);
+        var result = chainableBehavior.method.apply(this, arguments);
         if (result !== void 0) {
           return result;
         }
-        let newAssertion = new Assertion();
+        var newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
       }, "chainableMethodWrapper");
       addLengthGuard(chainableMethodWrapper, name, true);
       if (canSetPrototype) {
-        let prototype = Object.create(this);
+        var prototype = Object.create(this);
         prototype.call = call;
         prototype.apply = apply;
         Object.setPrototypeOf(chainableMethodWrapper, prototype);
       } else {
-        let asserterNames = Object.getOwnPropertyNames(ctx);
+        var asserterNames = Object.getOwnPropertyNames(ctx);
         asserterNames.forEach(function(asserterName) {
           if (excludeNames.indexOf(asserterName) !== -1) {
             return;
           }
-          let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+          var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
           Object.defineProperty(chainableMethodWrapper, asserterName, pd);
         });
       }
@@ -6972,35 +6919,36 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
 }
 __name(addChainableMethod, "addChainableMethod");
 function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
-  let chainableBehavior = ctx.__methods[name];
-  let _chainingBehavior = chainableBehavior.chainingBehavior;
+  var chainableBehavior = ctx.__methods[name];
+  var _chainingBehavior = chainableBehavior.chainingBehavior;
   chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
-    let result = chainingBehavior(_chainingBehavior).call(this);
+    var result = chainingBehavior(_chainingBehavior).call(this);
     if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion();
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingChainableMethodGetter");
-  let _method = chainableBehavior.method;
+  var _method = chainableBehavior.method;
   chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() {
-    let result = method(_method).apply(this, arguments);
+    var result = method(_method).apply(this, arguments);
     if (result !== void 0) {
       return result;
     }
-    let newAssertion = new Assertion();
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   }, "overwritingChainableMethodWrapper");
 }
 __name(overwriteChainableMethod, "overwriteChainableMethod");
-function compareByInspect(a3, b2) {
-  return inspect22(a3) < inspect22(b2) ? -1 : 1;
+function compareByInspect(a3, b) {
+  return inspect22(a3) < inspect22(b) ? -1 : 1;
 }
 __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;
   });
@@ -7012,20 +6960,21 @@ function getOwnEnumerableProperties(obj) {
 __name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
 var isNaN22 = Number.isNaN;
 function isObjectType(obj) {
-  let objectType = type(obj);
-  let objectTypes = ["Array", "Object", "Function"];
+  var objectType = type(obj);
+  var objectTypes = ["Array", "Object", "Function"];
   return objectTypes.indexOf(objectType) !== -1;
 }
 __name(isObjectType, "isObjectType");
 function getOperator(obj, args) {
-  let operator = flag(obj, "operator");
-  let negate = flag(obj, "negate");
-  let expected = args[3];
-  let msg = negate ? args[2] : args[1];
+  var operator = flag(obj, "operator");
+  var negate = flag(obj, "negate");
+  var expected = args[3];
+  var msg = negate ? args[2] : args[1];
   if (operator) {
     return operator;
   }
-  if (typeof msg === "function") msg = msg();
+  if (typeof msg === "function")
+    msg = msg();
   msg = msg || "";
   if (!msg) {
     return void 0;
@@ -7033,7 +6982,7 @@ function getOperator(obj, args) {
   if (/\shave\s/.test(msg)) {
     return void 0;
   }
-  let isObject3 = isObjectType(expected);
+  var isObject3 = isObjectType(expected);
   if (/\snot\s/.test(msg)) {
     return isObject3 ? "notDeepStrictEqual" : "notStrictEqual";
   }
@@ -7109,9 +7058,10 @@ 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 ";
+  var 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(
@@ -7130,8 +7080,8 @@ function an(type3, msg) {
 __name(an, "an");
 Assertion.addChainableMethod("an", an);
 Assertion.addChainableMethod("a", an);
-function SameValueZero(a3, b2) {
-  return isNaN22(a3) && isNaN22(b2) || a3 === b2;
+function SameValueZero(a3, b) {
+  return isNaN22(a3) && isNaN22(b) || a3 === b;
 }
 __name(SameValueZero, "SameValueZero");
 function includeChainingBehavior() {
@@ -7139,10 +7089,11 @@ function includeChainingBehavior() {
 }
 __name(includeChainingBehavior, "includeChainingBehavior");
 function include(val, 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;
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
   flagMsg = flagMsg ? flagMsg + ": " : "";
-  let included = false;
+  var included = false;
   switch (objType) {
     case "string":
       included = obj.indexOf(val) !== -1;
@@ -7180,7 +7131,7 @@ function include(val, msg) {
         included = obj.indexOf(val) !== -1;
       }
       break;
-    default: {
+    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(),
@@ -7188,11 +7139,9 @@ function include(val, msg) {
           ssfi
         );
       }
-      let props = Object.keys(val);
-      let firstErr = null;
-      let numErrs = 0;
+      var props = Object.keys(val), firstErr = null, numErrs = 0;
       props.forEach(function(prop) {
-        let propAssertion = new Assertion(obj);
+        var propAssertion = new Assertion(obj);
         transferFlags(this, propAssertion, true);
         flag2(propAssertion, "lockSsfi", true);
         if (!negate || props.length === 1) {
@@ -7205,7 +7154,8 @@ 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);
@@ -7213,7 +7163,6 @@ function include(val, msg) {
         throw firstErr;
       }
       return;
-    }
   }
   this.assert(
     included,
@@ -7297,7 +7246,7 @@ Assertion.addProperty("NaN", function() {
   );
 });
 function assertExist() {
-  let val = flag2(this, "object");
+  var val = flag2(this, "object");
   this.assert(
     val !== null && val !== void 0,
     "expected #{this} to exist",
@@ -7308,7 +7257,7 @@ __name(assertExist, "assertExist");
 Assertion.addProperty("exist", assertExist);
 Assertion.addProperty("exists", assertExist);
 Assertion.addProperty("empty", function() {
-  let val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
+  var val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
   flagMsg = flagMsg ? flagMsg + ": " : "";
   switch (type(val).toLowerCase()) {
     case "array":
@@ -7326,10 +7275,9 @@ Assertion.addProperty("empty", function() {
         void 0,
         ssfi
       );
-    case "function": {
-      const msg = flagMsg + ".empty was passed a function " + getName(val);
+    case "function":
+      var msg = flagMsg + ".empty was passed a function " + getName(val);
       throw new AssertionError(msg.trim(), void 0, ssfi);
-    }
     default:
       if (val !== Object(val)) {
         throw new AssertionError(
@@ -7347,7 +7295,7 @@ Assertion.addProperty("empty", function() {
   );
 });
 function checkArguments() {
-  let obj = flag2(this, "object"), type3 = type(obj);
+  var obj = flag2(this, "object"), type3 = type(obj);
   this.assert(
     "Arguments" === type3,
     "expected #{this} to be arguments but got " + type3,
@@ -7358,10 +7306,11 @@ __name(checkArguments, "checkArguments");
 Assertion.addProperty("arguments", checkArguments);
 Assertion.addProperty("Arguments", checkArguments);
 function assertEqual(val, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object");
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
   if (flag2(this, "deep")) {
-    let prevLockSsfi = flag2(this, "lockSsfi");
+    var prevLockSsfi = flag2(this, "lockSsfi");
     flag2(this, "lockSsfi", true);
     this.eql(val);
     flag2(this, "lockSsfi", prevLockSsfi);
@@ -7381,8 +7330,9 @@ Assertion.addMethod("equal", assertEqual);
 Assertion.addMethod("equals", assertEqual);
 Assertion.addMethod("eq", assertEqual);
 function assertEql(obj, msg) {
-  if (msg) flag2(this, "message", msg);
-  let eql = flag2(this, "eql");
+  if (msg)
+    flag2(this, "message", msg);
+  var eql = flag2(this, "eql");
   this.assert(
     eql(obj, flag2(this, "object")),
     "expected #{this} to deeply equal #{exp}",
@@ -7396,8 +7346,9 @@ __name(assertEql, "assertEql");
 Assertion.addMethod("eql", assertEql);
 Assertion.addMethod("eqls", assertEql);
 function assertAbove(n, 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 (msg)
+    flag2(this, "message", msg);
+  var 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");
   }
@@ -7414,7 +7365,7 @@ function assertAbove(n, msg) {
       ssfi
     );
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
-    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    var printObj = objType === "string" ? "'" + obj + "'" : obj;
     throw new AssertionError(
       msgPrefix + "expected " + printObj + " to be a number or a date",
       void 0,
@@ -7422,7 +7373,7 @@ function assertAbove(n, msg) {
     );
   }
   if (doLength) {
-    let descriptor = "length", itemsCount;
+    var descriptor = "length", itemsCount;
     if (objType === "map" || objType === "set") {
       descriptor = "size";
       itemsCount = obj.size;
@@ -7450,8 +7401,9 @@ Assertion.addMethod("above", assertAbove);
 Assertion.addMethod("gt", assertAbove);
 Assertion.addMethod("greaterThan", assertAbove);
 function assertLeast(n, 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 (msg)
+    flag2(this, "message", msg);
+  var 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");
   }
@@ -7460,7 +7412,7 @@ function assertLeast(n, msg) {
   } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to least must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
-    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    var printObj = objType === "string" ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
   } else {
     shouldThrow = false;
@@ -7469,7 +7421,7 @@ function assertLeast(n, msg) {
     throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
-    let descriptor = "length", itemsCount;
+    var descriptor = "length", itemsCount;
     if (objType === "map" || objType === "set") {
       descriptor = "size";
       itemsCount = obj.size;
@@ -7497,8 +7449,9 @@ Assertion.addMethod("least", assertLeast);
 Assertion.addMethod("gte", assertLeast);
 Assertion.addMethod("greaterThanOrEqual", assertLeast);
 function assertBelow(n, 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 (msg)
+    flag2(this, "message", msg);
+  var 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");
   }
@@ -7507,7 +7460,7 @@ function assertBelow(n, msg) {
   } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to below must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
-    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    var printObj = objType === "string" ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
   } else {
     shouldThrow = false;
@@ -7516,7 +7469,7 @@ function assertBelow(n, msg) {
     throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
-    let descriptor = "length", itemsCount;
+    var descriptor = "length", itemsCount;
     if (objType === "map" || objType === "set") {
       descriptor = "size";
       itemsCount = obj.size;
@@ -7544,8 +7497,9 @@ Assertion.addMethod("below", assertBelow);
 Assertion.addMethod("lt", assertBelow);
 Assertion.addMethod("lessThan", assertBelow);
 function assertMost(n, 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 (msg)
+    flag2(this, "message", msg);
+  var 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");
   }
@@ -7554,7 +7508,7 @@ function assertMost(n, msg) {
   } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to most must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
-    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    var printObj = objType === "string" ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
   } else {
     shouldThrow = false;
@@ -7563,7 +7517,7 @@ function assertMost(n, msg) {
     throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
-    let descriptor = "length", itemsCount;
+    var descriptor = "length", itemsCount;
     if (objType === "map" || objType === "set") {
       descriptor = "size";
       itemsCount = obj.size;
@@ -7591,8 +7545,9 @@ 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);
-  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 (msg)
+    flag2(this, "message", msg);
+  var 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");
   }
@@ -7601,7 +7556,7 @@ Assertion.addMethod("within", function(start, finish, msg) {
   } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the arguments to within must be numbers";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
-    let printObj = objType === "string" ? "'" + obj + "'" : obj;
+    var printObj = objType === "string" ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
   } else {
     shouldThrow = false;
@@ -7610,7 +7565,7 @@ Assertion.addMethod("within", function(start, finish, msg) {
     throw new AssertionError(errorMessage, void 0, ssfi);
   }
   if (doLength) {
-    let descriptor = "length", itemsCount;
+    var descriptor = "length", itemsCount;
     if (objType === "map" || objType === "set") {
       descriptor = "size";
       itemsCount = obj.size;
@@ -7631,13 +7586,13 @@ Assertion.addMethod("within", function(start, finish, msg) {
   }
 });
 function assertInstanceOf(constructor, msg) {
-  if (msg) flag2(this, "message", msg);
-  let target = flag2(this, "object");
-  let ssfi = flag2(this, "ssfi");
-  let flagMsg = flag2(this, "message");
-  let isInstanceOf;
+  if (msg)
+    flag2(this, "message", msg);
+  var target = flag2(this, "object");
+  var ssfi = flag2(this, "ssfi");
+  var flagMsg = flag2(this, "message");
   try {
-    isInstanceOf = target instanceof constructor;
+    var isInstanceOf = target instanceof constructor;
   } catch (err) {
     if (err instanceof TypeError) {
       flagMsg = flagMsg ? flagMsg + ": " : "";
@@ -7649,7 +7604,7 @@ function assertInstanceOf(constructor, msg) {
     }
     throw err;
   }
-  let name = getName(constructor);
+  var name = getName(constructor);
   if (name == null) {
     name = "an unnamed constructor";
   }
@@ -7663,8 +7618,9 @@ __name(assertInstanceOf, "assertInstanceOf");
 Assertion.addMethod("instanceof", assertInstanceOf);
 Assertion.addMethod("instanceOf", assertInstanceOf);
 function assertProperty(name, val, 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;
+  if (msg)
+    flag2(this, "message", msg);
+  var 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") {
@@ -7697,16 +7653,22 @@ function assertProperty(name, val, msg) {
       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 ";
+  var isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
+  var descriptor = "";
+  if (isDeep)
+    descriptor += "deep ";
+  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);
+  var hasProperty2;
+  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,
@@ -7739,10 +7701,11 @@ function assertOwnPropertyDescriptor(name, descriptor, msg) {
     msg = descriptor;
     descriptor = null;
   }
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object");
-  let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
-  let eql = flag2(this, "eql");
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
+  var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
+  var eql = flag2(this, "eql");
   if (actualDescriptor && descriptor) {
     this.assert(
       eql(descriptor, actualDescriptor),
@@ -7769,8 +7732,9 @@ function assertLengthChain() {
 }
 __name(assertLengthChain, "assertLengthChain");
 function assertLength(n, 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;
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
   switch (objType) {
     case "map":
     case "set":
@@ -7793,8 +7757,9 @@ __name(assertLength, "assertLength");
 Assertion.addChainableMethod("length", assertLength, assertLengthChain);
 Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
 function assertMatch(re, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object");
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
   this.assert(
     re.exec(obj),
     "expected #{this} to match " + re,
@@ -7805,8 +7770,9 @@ __name(assertMatch, "assertMatch");
 Assertion.addMethod("match", assertMatch);
 Assertion.addMethod("matches", assertMatch);
 Assertion.addMethod("string", function(str, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var 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),
@@ -7815,9 +7781,9 @@ Assertion.addMethod("string", function(str, msg) {
   );
 });
 function assertKeys(keys2) {
-  let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys2), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
+  var obj = flag2(this, "object"), objType = type(obj), keysType = type(keys2), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
   flagMsg = flagMsg ? flagMsg + ": " : "";
-  let mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
+  var mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
   if (objType === "Map" || objType === "Set") {
     deepStr = isDeep ? "deeply " : "";
     actual = [];
@@ -7851,7 +7817,7 @@ function assertKeys(keys2) {
   if (!keys2.length) {
     throw new AssertionError(flagMsg + "keys required", void 0, ssfi);
   }
-  let len = keys2.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys2, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
+  var len = keys2.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys2, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2;
   if (!any && !all) {
     all = true;
   }
@@ -7876,7 +7842,7 @@ function assertKeys(keys2) {
     keys2 = keys2.map(function(key) {
       return inspect22(key);
     });
-    let last = keys2.pop();
+    var last = keys2.pop();
     if (all) {
       str = keys2.join(", ") + ", and " + last;
     }
@@ -7901,8 +7867,9 @@ __name(assertKeys, "assertKeys");
 Assertion.addMethod("keys", assertKeys);
 Assertion.addMethod("key", assertKeys);
 function assertThrows(errorLike, errMsgMatcher, 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;
+  if (msg)
+    flag2(this, "message", msg);
+  var 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") {
     errMsgMatcher = errorLike;
@@ -7916,12 +7883,12 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     errorWasThrown = true;
     caughtErr = err;
   }
-  let everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
-  let everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
-  let errorLikeFail = false;
-  let errMsgMatcherFail = false;
+  var everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
+  var everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
+  var errorLikeFail = false;
+  var errMsgMatcherFail = false;
   if (everyArgIsUndefined || !everyArgIsUndefined && !negate) {
-    let errorLikeString = "an error";
+    var errorLikeString = "an error";
     if (errorLike instanceof Error) {
       errorLikeString = "#{exp}";
     } else if (errorLike) {
@@ -7948,7 +7915,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
   }
   if (errorLike && caughtErr) {
     if (errorLike instanceof Error) {
-      let isCompatibleInstance = check_error_exports.compatibleInstance(
+      var isCompatibleInstance = check_error_exports.compatibleInstance(
         caughtErr,
         errorLike
       );
@@ -7966,7 +7933,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
         }
       }
     }
-    let isCompatibleConstructor = check_error_exports.compatibleConstructor(
+    var isCompatibleConstructor = check_error_exports.compatibleConstructor(
       caughtErr,
       errorLike
     );
@@ -7985,11 +7952,11 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     }
   }
   if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
-    let placeholder = "including";
+    var placeholder = "including";
     if (isRegExp2(errMsgMatcher)) {
       placeholder = "matching";
     }
-    let isCompatibleMessage = check_error_exports.compatibleMessage(
+    var isCompatibleMessage = check_error_exports.compatibleMessage(
       caughtErr,
       errMsgMatcher
     );
@@ -8023,8 +7990,9 @@ 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 = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method];
+  if (msg)
+    flag2(this, "message", msg);
+  var 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 " + inspect22(method),
@@ -8038,9 +8006,10 @@ Assertion.addProperty("itself", function() {
   flag2(this, "itself", true);
 });
 function satisfy(matcher, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object");
-  let result = matcher(obj);
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
+  var result = matcher(obj);
   this.assert(
     result,
     "expected #{this} to satisfy " + objDisplay2(matcher),
@@ -8053,28 +8022,27 @@ __name(satisfy, "satisfy");
 Assertion.addMethod("satisfy", satisfy);
 Assertion.addMethod("satisfies", satisfy);
 function closeTo(expected, delta, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var 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 == void 0) {
+  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 == void 0) {
+  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((x2) => x2 < 0n ? -x2 : x2, "abs");
+  const abs = /* @__PURE__ */ __name((x) => x < 0n ? -x : x, "abs");
   const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
   this.assert(
     strip(abs(obj - expected)) <= delta,
@@ -8089,33 +8057,40 @@ 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);
+      var matchIdx = superset.indexOf(elem);
+      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);
+    return superset.some(function(elem2, matchIdx2) {
+      if (!cmp(elem, elem2))
+        return false;
+      if (!contains)
+        superset.splice(matchIdx2, 1);
       return true;
     });
   });
 }
 __name(isSubsetOf, "isSubsetOf");
 Assertion.addMethod("members", function(subset, msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var 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;
-  let contains = flag2(this, "contains");
-  let ordered = flag2(this, "ordered");
-  let subject, failMsg, failNegateMsg;
+  var contains = flag2(this, "contains");
+  var ordered = flag2(this, "ordered");
+  var subject, failMsg, failNegateMsg;
   if (contains) {
     subject = ordered ? "an ordered superset" : "a superset";
     failMsg = "expected #{this} to be " + subject + " of #{exp}";
@@ -8125,7 +8100,7 @@ Assertion.addMethod("members", function(subset, msg) {
     failMsg = "expected #{this} to have the same " + subject + " as #{exp}";
     failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}";
   }
-  let cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
+  var cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
   this.assert(
     isSubsetOf(subset, obj, cmp, contains, ordered),
     failMsg,
@@ -8136,8 +8111,9 @@ Assertion.addMethod("members", function(subset, msg) {
   );
 });
 Assertion.addProperty("iterable", function(msg) {
-  if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object");
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
   this.assert(
     obj != void 0 && obj[Symbol.iterator],
     "expected #{this} to be an iterable",
@@ -8146,8 +8122,9 @@ Assertion.addProperty("iterable", function(msg) {
   );
 });
 function oneOf(list, 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");
+  if (msg)
+    flag2(this, "message", msg);
+  var expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql");
   new Assertion(list, flagMsg, ssfi, true).to.be.an("array");
   if (contains) {
     this.assert(
@@ -8184,10 +8161,11 @@ function oneOf(list, msg) {
 __name(oneOf, "oneOf");
 Assertion.addMethod("oneOf", oneOf);
 function assertChanges(subject, prop, msg) {
-  if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
-  let initial;
+  var initial;
   if (!prop) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
     initial = subject();
@@ -8196,8 +8174,8 @@ function assertChanges(subject, prop, msg) {
     initial = subject[prop];
   }
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
-  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+  var final = prop === void 0 || prop === null ? subject() : subject[prop];
+  var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
@@ -8213,10 +8191,11 @@ __name(assertChanges, "assertChanges");
 Assertion.addMethod("change", assertChanges);
 Assertion.addMethod("changes", assertChanges);
 function assertIncreases(subject, prop, msg) {
-  if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
-  let initial;
+  var initial;
   if (!prop) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
     initial = subject();
@@ -8226,8 +8205,8 @@ function assertIncreases(subject, prop, msg) {
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
-  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+  var final = prop === void 0 || prop === null ? subject() : subject[prop];
+  var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
@@ -8243,10 +8222,11 @@ __name(assertIncreases, "assertIncreases");
 Assertion.addMethod("increase", assertIncreases);
 Assertion.addMethod("increases", assertIncreases);
 function assertDecreases(subject, prop, msg) {
-  if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  if (msg)
+    flag2(this, "message", msg);
+  var fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
-  let initial;
+  var initial;
   if (!prop) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
     initial = subject();
@@ -8256,8 +8236,8 @@ function assertDecreases(subject, prop, msg) {
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
-  let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+  var final = prop === void 0 || prop === null ? subject() : subject[prop];
+  var msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
   flag2(this, "finalDeltaValue", final);
@@ -8273,13 +8253,14 @@ __name(assertDecreases, "assertDecreases");
 Assertion.addMethod("decrease", assertDecreases);
 Assertion.addMethod("decreases", assertDecreases);
 function assertDelta(delta, msg) {
-  if (msg) flag2(this, "message", msg);
-  let msgObj = flag2(this, "deltaMsgObj");
-  let initial = flag2(this, "initialDeltaValue");
-  let final = flag2(this, "finalDeltaValue");
-  let behavior = flag2(this, "deltaBehavior");
-  let realDelta = flag2(this, "realDelta");
-  let expression;
+  if (msg)
+    flag2(this, "message", msg);
+  var msgObj = flag2(this, "deltaMsgObj");
+  var initial = flag2(this, "initialDeltaValue");
+  var final = flag2(this, "finalDeltaValue");
+  var behavior = flag2(this, "deltaBehavior");
+  var realDelta = flag2(this, "realDelta");
+  var expression;
   if (behavior === "change") {
     expression = Math.abs(final - initial) === Math.abs(delta);
   } else {
@@ -8294,8 +8275,8 @@ function assertDelta(delta, msg) {
 __name(assertDelta, "assertDelta");
 Assertion.addMethod("by", assertDelta);
 Assertion.addProperty("extensible", function() {
-  let obj = flag2(this, "object");
-  let isExtensible = obj === Object(obj) && Object.isExtensible(obj);
+  var obj = flag2(this, "object");
+  var isExtensible = obj === Object(obj) && Object.isExtensible(obj);
   this.assert(
     isExtensible,
     "expected #{this} to be extensible",
@@ -8303,8 +8284,8 @@ Assertion.addProperty("extensible", function() {
   );
 });
 Assertion.addProperty("sealed", function() {
-  let obj = flag2(this, "object");
-  let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
+  var obj = flag2(this, "object");
+  var isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
   this.assert(
     isSealed,
     "expected #{this} to be sealed",
@@ -8312,8 +8293,8 @@ Assertion.addProperty("sealed", function() {
   );
 });
 Assertion.addProperty("frozen", function() {
-  let obj = flag2(this, "object");
-  let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
+  var obj = flag2(this, "object");
+  var isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
   this.assert(
     isFrozen,
     "expected #{this} to be frozen",
@@ -8321,7 +8302,7 @@ Assertion.addProperty("frozen", function() {
   );
 });
 Assertion.addProperty("finite", function(_msg) {
-  let obj = flag2(this, "object");
+  var obj = flag2(this, "object");
   this.assert(
     typeof obj === "number" && isFinite(obj),
     "expected #{this} to be a finite number",
@@ -8359,8 +8340,8 @@ function compareSubset(expected, actual) {
     }
   }
   return Object.keys(expected).every(function(key) {
-    let expectedValue = expected[key];
-    let actualValue = actual[key];
+    var expectedValue = expected[key];
+    var actualValue = actual[key];
     if (typeof expectedValue === "object" && expectedValue !== null && actualValue !== null) {
       return compareSubset(expectedValue, actualValue);
     }
@@ -8430,7 +8411,7 @@ function loadShould() {
     get: shouldGetter,
     configurable: true
   });
-  let should2 = {};
+  var should2 = {};
   should2.fail = function(actual, expected, message, operator) {
     if (arguments.length < 2) {
       message = actual;
@@ -8473,12 +8454,12 @@ function loadShould() {
 __name(loadShould, "loadShould");
 var should = loadShould;
 var Should = loadShould;
-function assert(express, errmsg) {
-  let test22 = new Assertion(null, null, assert, true);
+function assert2(express, errmsg) {
+  var test22 = new Assertion(null, null, assert2, true);
   test22.assert(express, errmsg, "[ negation message unavailable ]");
 }
-__name(assert, "assert");
-assert.fail = function(actual, expected, message, operator) {
+__name(assert2, "assert");
+assert2.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
     actual = void 0;
@@ -8491,17 +8472,17 @@ assert.fail = function(actual, expected, message, operator) {
       expected,
       operator
     },
-    assert.fail
+    assert2.fail
   );
 };
-assert.isOk = function(val, msg) {
-  new Assertion(val, msg, assert.isOk, true).is.ok;
+assert2.isOk = function(val, msg) {
+  new Assertion(val, msg, assert2.isOk, true).is.ok;
 };
-assert.isNotOk = function(val, msg) {
-  new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
+assert2.isNotOk = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotOk, true).is.not.ok;
 };
-assert.equal = function(act, exp, msg) {
-  let test22 = new Assertion(act, msg, assert.equal, true);
+assert2.equal = function(act, exp, msg) {
+  var test22 = new Assertion(act, msg, assert2.equal, true);
   test22.assert(
     exp == flag(test22, "object"),
     "expected #{this} to equal #{exp}",
@@ -8511,8 +8492,8 @@ assert.equal = function(act, exp, msg) {
     true
   );
 };
-assert.notEqual = function(act, exp, msg) {
-  let test22 = new Assertion(act, msg, assert.notEqual, true);
+assert2.notEqual = function(act, exp, msg) {
+  var test22 = new Assertion(act, msg, assert2.notEqual, true);
   test22.assert(
     exp != flag(test22, "object"),
     "expected #{this} to not equal #{exp}",
@@ -8522,371 +8503,371 @@ assert.notEqual = function(act, exp, msg) {
     true
   );
 };
-assert.strictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
+assert2.strictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.strictEqual, true).to.equal(exp);
 };
-assert.notStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
+assert2.notStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.notStrictEqual, true).to.not.equal(exp);
 };
-assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
+assert2.deepEqual = assert2.deepStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.deepEqual, true).to.eql(exp);
 };
-assert.notDeepEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
+assert2.notDeepEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.notDeepEqual, true).to.not.eql(exp);
 };
-assert.isAbove = function(val, abv, msg) {
-  new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
+assert2.isAbove = function(val, abv, msg) {
+  new Assertion(val, msg, assert2.isAbove, true).to.be.above(abv);
 };
-assert.isAtLeast = function(val, atlst, msg) {
-  new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
+assert2.isAtLeast = function(val, atlst, msg) {
+  new Assertion(val, msg, assert2.isAtLeast, true).to.be.least(atlst);
 };
-assert.isBelow = function(val, blw, msg) {
-  new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
+assert2.isBelow = function(val, blw, msg) {
+  new Assertion(val, msg, assert2.isBelow, true).to.be.below(blw);
 };
-assert.isAtMost = function(val, atmst, msg) {
-  new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
+assert2.isAtMost = function(val, atmst, msg) {
+  new Assertion(val, msg, assert2.isAtMost, true).to.be.most(atmst);
 };
-assert.isTrue = function(val, msg) {
-  new Assertion(val, msg, assert.isTrue, true).is["true"];
+assert2.isTrue = function(val, msg) {
+  new Assertion(val, msg, assert2.isTrue, true).is["true"];
 };
-assert.isNotTrue = function(val, msg) {
-  new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
+assert2.isNotTrue = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotTrue, true).to.not.equal(true);
 };
-assert.isFalse = function(val, msg) {
-  new Assertion(val, msg, assert.isFalse, true).is["false"];
+assert2.isFalse = function(val, msg) {
+  new Assertion(val, msg, assert2.isFalse, true).is["false"];
 };
-assert.isNotFalse = function(val, msg) {
-  new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
+assert2.isNotFalse = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotFalse, true).to.not.equal(false);
 };
-assert.isNull = function(val, msg) {
-  new Assertion(val, msg, assert.isNull, true).to.equal(null);
+assert2.isNull = function(val, msg) {
+  new Assertion(val, msg, assert2.isNull, true).to.equal(null);
 };
-assert.isNotNull = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
+assert2.isNotNull = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNull, true).to.not.equal(null);
 };
-assert.isNaN = function(val, msg) {
-  new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
+assert2.isNaN = function(val, msg) {
+  new Assertion(val, msg, assert2.isNaN, true).to.be.NaN;
 };
-assert.isNotNaN = function(value, message) {
-  new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
+assert2.isNotNaN = function(value, message) {
+  new Assertion(value, message, assert2.isNotNaN, true).not.to.be.NaN;
 };
-assert.exists = function(val, msg) {
-  new Assertion(val, msg, assert.exists, true).to.exist;
+assert2.exists = function(val, msg) {
+  new Assertion(val, msg, assert2.exists, true).to.exist;
 };
-assert.notExists = function(val, msg) {
-  new Assertion(val, msg, assert.notExists, true).to.not.exist;
+assert2.notExists = function(val, msg) {
+  new Assertion(val, msg, assert2.notExists, true).to.not.exist;
 };
-assert.isUndefined = function(val, msg) {
-  new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
+assert2.isUndefined = function(val, msg) {
+  new Assertion(val, msg, assert2.isUndefined, true).to.equal(void 0);
 };
-assert.isDefined = function(val, msg) {
-  new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
+assert2.isDefined = function(val, msg) {
+  new Assertion(val, msg, assert2.isDefined, true).to.not.equal(void 0);
 };
-assert.isCallable = function(value, message) {
-  new Assertion(value, message, assert.isCallable, true).is.callable;
+assert2.isCallable = function(value, message) {
+  new Assertion(value, message, assert2.isCallable, true).is.callable;
 };
-assert.isNotCallable = function(value, message) {
-  new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
+assert2.isNotCallable = function(value, message) {
+  new Assertion(value, message, assert2.isNotCallable, true).is.not.callable;
 };
-assert.isObject = function(val, msg) {
-  new Assertion(val, msg, assert.isObject, true).to.be.a("object");
+assert2.isObject = function(val, msg) {
+  new Assertion(val, msg, assert2.isObject, true).to.be.a("object");
 };
-assert.isNotObject = function(val, msg) {
-  new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
+assert2.isNotObject = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotObject, true).to.not.be.a("object");
 };
-assert.isArray = function(val, msg) {
-  new Assertion(val, msg, assert.isArray, true).to.be.an("array");
+assert2.isArray = function(val, msg) {
+  new Assertion(val, msg, assert2.isArray, true).to.be.an("array");
 };
-assert.isNotArray = function(val, msg) {
-  new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
+assert2.isNotArray = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotArray, true).to.not.be.an("array");
 };
-assert.isString = function(val, msg) {
-  new Assertion(val, msg, assert.isString, true).to.be.a("string");
+assert2.isString = function(val, msg) {
+  new Assertion(val, msg, assert2.isString, true).to.be.a("string");
 };
-assert.isNotString = function(val, msg) {
-  new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
+assert2.isNotString = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotString, true).to.not.be.a("string");
 };
-assert.isNumber = function(val, msg) {
-  new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
+assert2.isNumber = function(val, msg) {
+  new Assertion(val, msg, assert2.isNumber, true).to.be.a("number");
 };
-assert.isNotNumber = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
+assert2.isNotNumber = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNumber, true).to.not.be.a("number");
 };
-assert.isNumeric = function(val, msg) {
-  new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+assert2.isNumeric = function(val, msg) {
+  new Assertion(val, msg, assert2.isNumeric, true).is.numeric;
 };
-assert.isNotNumeric = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+assert2.isNotNumeric = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNumeric, true).is.not.numeric;
 };
-assert.isFinite = function(val, msg) {
-  new Assertion(val, msg, assert.isFinite, true).to.be.finite;
+assert2.isFinite = function(val, msg) {
+  new Assertion(val, msg, assert2.isFinite, true).to.be.finite;
 };
-assert.isBoolean = function(val, msg) {
-  new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
+assert2.isBoolean = function(val, msg) {
+  new Assertion(val, msg, assert2.isBoolean, true).to.be.a("boolean");
 };
-assert.isNotBoolean = function(val, msg) {
-  new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
+assert2.isNotBoolean = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotBoolean, true).to.not.be.a("boolean");
 };
-assert.typeOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
+assert2.typeOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.typeOf, true).to.be.a(type3);
 };
-assert.notTypeOf = function(value, type3, message) {
-  new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
+assert2.notTypeOf = function(value, type3, message) {
+  new Assertion(value, message, assert2.notTypeOf, true).to.not.be.a(type3);
 };
-assert.instanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
+assert2.instanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.instanceOf, true).to.be.instanceOf(type3);
 };
-assert.notInstanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
+assert2.notInstanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.notInstanceOf, true).to.not.be.instanceOf(
     type3
   );
 };
-assert.include = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.include, true).include(inc);
+assert2.include = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.include, true).include(inc);
 };
-assert.notInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
+assert2.notInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notInclude, true).not.include(inc);
 };
-assert.deepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
+assert2.deepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepInclude, true).deep.include(inc);
 };
-assert.notDeepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
+assert2.notDeepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notDeepInclude, true).not.deep.include(inc);
 };
-assert.nestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
+assert2.nestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.nestedInclude, true).nested.include(inc);
 };
-assert.notNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
+assert2.notNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notNestedInclude, true).not.nested.include(
     inc
   );
 };
-assert.deepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
+assert2.deepNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepNestedInclude, true).deep.nested.include(
     inc
   );
 };
-assert.notDeepNestedInclude = function(exp, inc, msg) {
+assert2.notDeepNestedInclude = function(exp, inc, msg) {
   new Assertion(
     exp,
     msg,
-    assert.notDeepNestedInclude,
+    assert2.notDeepNestedInclude,
     true
   ).not.deep.nested.include(inc);
 };
-assert.ownInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
+assert2.ownInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.ownInclude, true).own.include(inc);
 };
-assert.notOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
+assert2.notOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notOwnInclude, true).not.own.include(inc);
 };
-assert.deepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
+assert2.deepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepOwnInclude, true).deep.own.include(inc);
 };
-assert.notDeepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
+assert2.notDeepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notDeepOwnInclude, true).not.deep.own.include(
     inc
   );
 };
-assert.match = function(exp, re, msg) {
-  new Assertion(exp, msg, assert.match, true).to.match(re);
+assert2.match = function(exp, re, msg) {
+  new Assertion(exp, msg, assert2.match, true).to.match(re);
 };
-assert.notMatch = function(exp, re, msg) {
-  new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
+assert2.notMatch = function(exp, re, msg) {
+  new Assertion(exp, msg, assert2.notMatch, true).to.not.match(re);
 };
-assert.property = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.property, true).to.have.property(prop);
+assert2.property = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.property, true).to.have.property(prop);
 };
-assert.notProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
+assert2.notProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.notProperty, true).to.not.have.property(prop);
 };
-assert.propertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
+assert2.propertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.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(
+assert2.notPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.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(
+assert2.deepPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.deepPropertyVal, true).to.have.deep.property(
     prop,
     val
   );
 };
-assert.notDeepPropertyVal = function(obj, prop, val, msg) {
+assert2.notDeepPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepPropertyVal,
+    assert2.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);
+assert2.ownProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.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(
+assert2.notOwnProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.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(
+assert2.ownPropertyVal = function(obj, prop, value, msg) {
+  new Assertion(obj, msg, assert2.ownPropertyVal, true).to.have.own.property(
     prop,
     value
   );
 };
-assert.notOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.notOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notOwnPropertyVal,
+    assert2.notOwnPropertyVal,
     true
   ).to.not.have.own.property(prop, value);
 };
-assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.deepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.deepOwnPropertyVal,
+    assert2.deepOwnPropertyVal,
     true
   ).to.have.deep.own.property(prop, value);
 };
-assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepOwnPropertyVal,
+    assert2.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(
+assert2.nestedProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.nestedProperty, true).to.have.nested.property(
     prop
   );
 };
-assert.notNestedProperty = function(obj, prop, msg) {
+assert2.notNestedProperty = function(obj, prop, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notNestedProperty,
+    assert2.notNestedProperty,
     true
   ).to.not.have.nested.property(prop);
 };
-assert.nestedPropertyVal = function(obj, prop, val, msg) {
+assert2.nestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.nestedPropertyVal,
+    assert2.nestedPropertyVal,
     true
   ).to.have.nested.property(prop, val);
 };
-assert.notNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.notNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notNestedPropertyVal,
+    assert2.notNestedPropertyVal,
     true
   ).to.not.have.nested.property(prop, val);
 };
-assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.deepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.deepNestedPropertyVal,
+    assert2.deepNestedPropertyVal,
     true
   ).to.have.deep.nested.property(prop, val);
 };
-assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepNestedPropertyVal,
+    assert2.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);
+assert2.lengthOf = function(exp, len, msg) {
+  new Assertion(exp, msg, assert2.lengthOf, true).to.have.lengthOf(len);
 };
-assert.hasAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys2);
+assert2.hasAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAnyKeys, true).to.have.any.keys(keys2);
 };
-assert.hasAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys2);
+assert2.hasAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAllKeys, true).to.have.all.keys(keys2);
 };
-assert.containsAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
+assert2.containsAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.containsAllKeys, true).to.contain.all.keys(
     keys2
   );
 };
-assert.doesNotHaveAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
+assert2.doesNotHaveAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.doesNotHaveAnyKeys, true).to.not.have.any.keys(
     keys2
   );
 };
-assert.doesNotHaveAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
+assert2.doesNotHaveAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.doesNotHaveAllKeys, true).to.not.have.all.keys(
     keys2
   );
 };
-assert.hasAnyDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
+assert2.hasAnyDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAnyDeepKeys, true).to.have.any.deep.keys(
     keys2
   );
 };
-assert.hasAllDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
+assert2.hasAllDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAllDeepKeys, true).to.have.all.deep.keys(
     keys2
   );
 };
-assert.containsAllDeepKeys = function(obj, keys2, msg) {
+assert2.containsAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.containsAllDeepKeys,
+    assert2.containsAllDeepKeys,
     true
   ).to.contain.all.deep.keys(keys2);
 };
-assert.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
+assert2.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.doesNotHaveAnyDeepKeys,
+    assert2.doesNotHaveAnyDeepKeys,
     true
   ).to.not.have.any.deep.keys(keys2);
 };
-assert.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
+assert2.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.doesNotHaveAllDeepKeys,
+    assert2.doesNotHaveAllDeepKeys,
     true
   ).to.not.have.all.deep.keys(keys2);
 };
-assert.throws = function(fn2, errorLike, errMsgMatcher, msg) {
+assert2.throws = function(fn2, errorLike, errMsgMatcher, msg) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  let assertErr = new Assertion(fn2, msg, assert.throws, true).to.throw(
+  var assertErr = new Assertion(fn2, msg, assert2.throws, true).to.throw(
     errorLike,
     errMsgMatcher
   );
   return flag(assertErr, "object");
 };
-assert.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
+assert2.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn2, message, assert.doesNotThrow, true).to.not.throw(
+  new Assertion(fn2, message, assert2.doesNotThrow, true).to.not.throw(
     errorLike,
     errMsgMatcher
   );
 };
-assert.operator = function(val, operator, val2, msg) {
-  let ok;
+assert2.operator = function(val, operator, val2, msg) {
+  var ok;
   switch (operator) {
     case "==":
       ok = val == val2;
@@ -8917,315 +8898,315 @@ assert.operator = function(val, operator, val2, msg) {
       throw new AssertionError(
         msg + 'Invalid operator "' + operator + '"',
         void 0,
-        assert.operator
+        assert2.operator
       );
   }
-  let test22 = new Assertion(ok, msg, assert.operator, true);
+  var test22 = new Assertion(ok, msg, assert2.operator, true);
   test22.assert(
     true === flag(test22, "object"),
     "expected " + inspect22(val) + " to be " + operator + " " + inspect22(val2),
     "expected " + inspect22(val) + " to not be " + operator + " " + inspect22(val2)
   );
 };
-assert.closeTo = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
+assert2.closeTo = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert2.closeTo, true).to.be.closeTo(exp, delta);
 };
-assert.approximately = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert.approximately, true).to.be.approximately(
+assert2.approximately = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert2.approximately, true).to.be.approximately(
     exp,
     delta
   );
 };
-assert.sameMembers = function(set1, set22, msg) {
-  new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set22);
+assert2.sameMembers = function(set1, set22, msg) {
+  new Assertion(set1, msg, assert2.sameMembers, true).to.have.same.members(set22);
 };
-assert.notSameMembers = function(set1, set22, msg) {
+assert2.notSameMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameMembers,
+    assert2.notSameMembers,
     true
   ).to.not.have.same.members(set22);
 };
-assert.sameDeepMembers = function(set1, set22, msg) {
+assert2.sameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameDeepMembers,
+    assert2.sameDeepMembers,
     true
   ).to.have.same.deep.members(set22);
 };
-assert.notSameDeepMembers = function(set1, set22, msg) {
+assert2.notSameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameDeepMembers,
+    assert2.notSameDeepMembers,
     true
   ).to.not.have.same.deep.members(set22);
 };
-assert.sameOrderedMembers = function(set1, set22, msg) {
+assert2.sameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameOrderedMembers,
+    assert2.sameOrderedMembers,
     true
   ).to.have.same.ordered.members(set22);
 };
-assert.notSameOrderedMembers = function(set1, set22, msg) {
+assert2.notSameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameOrderedMembers,
+    assert2.notSameOrderedMembers,
     true
   ).to.not.have.same.ordered.members(set22);
 };
-assert.sameDeepOrderedMembers = function(set1, set22, msg) {
+assert2.sameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameDeepOrderedMembers,
+    assert2.sameDeepOrderedMembers,
     true
   ).to.have.same.deep.ordered.members(set22);
 };
-assert.notSameDeepOrderedMembers = function(set1, set22, msg) {
+assert2.notSameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameDeepOrderedMembers,
+    assert2.notSameDeepOrderedMembers,
     true
   ).to.not.have.same.deep.ordered.members(set22);
 };
-assert.includeMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
+assert2.includeMembers = function(superset, subset, msg) {
+  new Assertion(superset, msg, assert2.includeMembers, true).to.include.members(
     subset
   );
 };
-assert.notIncludeMembers = function(superset, subset, msg) {
+assert2.notIncludeMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeMembers,
+    assert2.notIncludeMembers,
     true
   ).to.not.include.members(subset);
 };
-assert.includeDeepMembers = function(superset, subset, msg) {
+assert2.includeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeDeepMembers,
+    assert2.includeDeepMembers,
     true
   ).to.include.deep.members(subset);
 };
-assert.notIncludeDeepMembers = function(superset, subset, msg) {
+assert2.notIncludeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeDeepMembers,
+    assert2.notIncludeDeepMembers,
     true
   ).to.not.include.deep.members(subset);
 };
-assert.includeOrderedMembers = function(superset, subset, msg) {
+assert2.includeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeOrderedMembers,
+    assert2.includeOrderedMembers,
     true
   ).to.include.ordered.members(subset);
 };
-assert.notIncludeOrderedMembers = function(superset, subset, msg) {
+assert2.notIncludeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeOrderedMembers,
+    assert2.notIncludeOrderedMembers,
     true
   ).to.not.include.ordered.members(subset);
 };
-assert.includeDeepOrderedMembers = function(superset, subset, msg) {
+assert2.includeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeDeepOrderedMembers,
+    assert2.includeDeepOrderedMembers,
     true
   ).to.include.deep.ordered.members(subset);
 };
-assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+assert2.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeDeepOrderedMembers,
+    assert2.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);
+assert2.oneOf = function(inList, list, msg) {
+  new Assertion(inList, msg, assert2.oneOf, true).to.be.oneOf(list);
 };
-assert.isIterable = function(obj, msg) {
+assert2.isIterable = function(obj, msg) {
   if (obj == void 0 || !obj[Symbol.iterator]) {
     msg = msg ? `${msg} expected ${inspect22(obj)} to be an iterable` : `expected ${inspect22(obj)} to be an iterable`;
-    throw new AssertionError(msg, void 0, assert.isIterable);
+    throw new AssertionError(msg, void 0, assert2.isIterable);
   }
 };
-assert.changes = function(fn2, obj, prop, msg) {
+assert2.changes = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changes, true).to.change(obj, prop);
+  new Assertion(fn2, msg, assert2.changes, true).to.change(obj, prop);
 };
-assert.changesBy = function(fn2, obj, prop, delta, msg) {
+assert2.changesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.changesBy, true).to.change(obj, prop).by(delta);
 };
-assert.doesNotChange = function(fn2, obj, prop, msg) {
+assert2.doesNotChange = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotChange, true).to.not.change(
+  return new Assertion(fn2, msg, assert2.doesNotChange, true).to.not.change(
     obj,
     prop
   );
 };
-assert.changesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.changesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
 };
-assert.increases = function(fn2, obj, prop, msg) {
+assert2.increases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.increases, true).to.increase(obj, prop);
+  return new Assertion(fn2, msg, assert2.increases, true).to.increase(obj, prop);
 };
-assert.increasesBy = function(fn2, obj, prop, delta, msg) {
+assert2.increasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.increasesBy, true).to.increase(obj, prop).by(delta);
 };
-assert.doesNotIncrease = function(fn2, obj, prop, msg) {
+assert2.doesNotIncrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotIncrease, true).to.not.increase(
+  return new Assertion(fn2, msg, assert2.doesNotIncrease, true).to.not.increase(
     obj,
     prop
   );
 };
-assert.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
 };
-assert.decreases = function(fn2, obj, prop, msg) {
+assert2.decreases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.decreases, true).to.decrease(obj, prop);
+  return new Assertion(fn2, msg, assert2.decreases, true).to.decrease(obj, prop);
 };
-assert.decreasesBy = function(fn2, obj, prop, delta, msg) {
+assert2.decreasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.decreasesBy, true).to.decrease(obj, prop).by(delta);
 };
-assert.doesNotDecrease = function(fn2, obj, prop, msg) {
+assert2.doesNotDecrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotDecrease, true).to.not.decrease(
+  return new Assertion(fn2, msg, assert2.doesNotDecrease, true).to.not.decrease(
     obj,
     prop
   );
 };
-assert.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
+assert2.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+  return new Assertion(fn2, msg, assert2.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
 };
-assert.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
-    let tmpMsg = delta;
+    var tmpMsg = delta;
     delta = prop;
     msg = tmpMsg;
   } else if (arguments.length === 3) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
 };
-assert.ifError = function(val) {
+assert2.ifError = function(val) {
   if (val) {
     throw val;
   }
 };
-assert.isExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
+assert2.isExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isExtensible, true).to.be.extensible;
 };
-assert.isNotExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
+assert2.isNotExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotExtensible, true).to.not.be.extensible;
 };
-assert.isSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
+assert2.isSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isSealed, true).to.be.sealed;
 };
-assert.isNotSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
+assert2.isNotSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotSealed, true).to.not.be.sealed;
 };
-assert.isFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
+assert2.isFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isFrozen, true).to.be.frozen;
 };
-assert.isNotFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
+assert2.isNotFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotFrozen, true).to.not.be.frozen;
 };
-assert.isEmpty = function(val, msg) {
-  new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
+assert2.isEmpty = function(val, msg) {
+  new Assertion(val, msg, assert2.isEmpty, true).to.be.empty;
 };
-assert.isNotEmpty = function(val, msg) {
-  new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
+assert2.isNotEmpty = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotEmpty, true).to.not.be.empty;
 };
-assert.containsSubset = function(val, exp, msg) {
+assert2.containsSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.containSubset(exp);
 };
-assert.doesNotContainSubset = function(val, exp, msg) {
+assert2.doesNotContainSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.not.containSubset(exp);
 };
 var aliases = [
@@ -9246,7 +9227,7 @@ var aliases = [
   ["containsSubset", "containSubset"]
 ];
 for (const [name, as] of aliases) {
-  assert[as] = assert[name];
+  assert2[as] = assert2[name];
 }
 var used = [];
 function use(fn2) {
@@ -9256,7 +9237,7 @@ function use(fn2) {
     util: utils_exports,
     config,
     expect,
-    assert,
+    assert: assert2,
     Assertion,
     ...should_exports
   };
@@ -9400,71 +9381,71 @@ function addCustomEqualityTesters(newTesters) {
 function getCustomEqualityTesters() {
   return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
 }
-function equals(a3, b2, customTesters, strictCheck) {
+function equals(a3, b, customTesters, strictCheck) {
   customTesters = customTesters || [];
-  return eq(a3, b2, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+  return eq(a3, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
 }
 var functionToString = Function.prototype.toString;
 function isAsymmetric(obj) {
   return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
 }
-function asymmetricMatch(a3, b2) {
+function asymmetricMatch(a3, b) {
   const asymmetricA = isAsymmetric(a3);
-  const asymmetricB = isAsymmetric(b2);
+  const asymmetricB = isAsymmetric(b);
   if (asymmetricA && asymmetricB) {
     return void 0;
   }
   if (asymmetricA) {
-    return a3.asymmetricMatch(b2);
+    return a3.asymmetricMatch(b);
   }
   if (asymmetricB) {
-    return b2.asymmetricMatch(a3);
+    return b.asymmetricMatch(a3);
   }
 }
-function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
+function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
   let result = true;
-  const asymmetricResult = asymmetricMatch(a3, b2);
+  const asymmetricResult = asymmetricMatch(a3, b);
   if (asymmetricResult !== void 0) {
     return asymmetricResult;
   }
   const testerContext = { equals };
   for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i].call(testerContext, a3, b2, customTesters);
+    const customTesterResult = customTesters[i].call(testerContext, a3, b, customTesters);
     if (customTesterResult !== void 0) {
       return customTesterResult;
     }
   }
-  if (typeof URL === "function" && a3 instanceof URL && b2 instanceof URL) {
-    return a3.href === b2.href;
+  if (typeof URL === "function" && a3 instanceof URL && b instanceof URL) {
+    return a3.href === b.href;
   }
-  if (Object.is(a3, b2)) {
+  if (Object.is(a3, b)) {
     return true;
   }
-  if (a3 === null || b2 === null) {
-    return a3 === b2;
+  if (a3 === null || b === null) {
+    return a3 === b;
   }
   const className = Object.prototype.toString.call(a3);
-  if (className !== Object.prototype.toString.call(b2)) {
+  if (className !== Object.prototype.toString.call(b)) {
     return false;
   }
   switch (className) {
     case "[object Boolean]":
     case "[object String]":
     case "[object Number]":
-      if (typeof a3 !== typeof b2) {
+      if (typeof a3 !== typeof b) {
         return false;
-      } else if (typeof a3 !== "object" && typeof b2 !== "object") {
-        return Object.is(a3, b2);
+      } else if (typeof a3 !== "object" && typeof b !== "object") {
+        return Object.is(a3, b);
       } else {
-        return Object.is(a3.valueOf(), b2.valueOf());
+        return Object.is(a3.valueOf(), b.valueOf());
       }
     case "[object Date]": {
       const numA = +a3;
-      const numB = +b2;
+      const numB = +b;
       return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
     }
     case "[object RegExp]":
-      return a3.source === b2.source && a3.flags === b2.flags;
+      return a3.source === b.source && a3.flags === b.flags;
     case "[object Temporal.Instant]":
     case "[object Temporal.ZonedDateTime]":
     case "[object Temporal.PlainDateTime]":
@@ -9472,32 +9453,32 @@ function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
     case "[object Temporal.PlainTime]":
     case "[object Temporal.PlainYearMonth]":
     case "[object Temporal.PlainMonthDay]":
-      return a3.equals(b2);
+      return a3.equals(b);
     case "[object Temporal.Duration]":
-      return a3.toString() === b2.toString();
+      return a3.toString() === b.toString();
   }
-  if (typeof a3 !== "object" || typeof b2 !== "object") {
+  if (typeof a3 !== "object" || typeof b !== "object") {
     return false;
   }
-  if (isDomNode(a3) && isDomNode(b2)) {
-    return a3.isEqualNode(b2);
+  if (isDomNode(a3) && isDomNode(b)) {
+    return a3.isEqualNode(b);
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a3) {
-      return bStack[length] === b2;
-    } else if (bStack[length] === b2) {
+      return bStack[length] === b;
+    } else if (bStack[length] === b) {
       return false;
     }
   }
   aStack.push(a3);
-  bStack.push(b2);
-  if (className === "[object Array]" && a3.length !== b2.length) {
+  bStack.push(b);
+  if (className === "[object Array]" && a3.length !== b.length) {
     return false;
   }
-  if (a3 instanceof Error && b2 instanceof Error) {
+  if (a3 instanceof Error && b instanceof Error) {
     try {
-      return isErrorEqual(a3, b2, aStack, bStack, customTesters, hasKey2);
+      return isErrorEqual(a3, b, aStack, bStack, customTesters, hasKey2);
     } finally {
       aStack.pop();
       bStack.pop();
@@ -9506,12 +9487,12 @@ function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
   const aKeys = keys(a3, hasKey2);
   let key;
   let size = aKeys.length;
-  if (keys(b2, hasKey2).length !== size) {
+  if (keys(b, hasKey2).length !== size) {
     return false;
   }
   while (size--) {
     key = aKeys[size];
-    result = hasKey2(b2, key) && eq(a3[key], b2[key], aStack, bStack, customTesters, hasKey2);
+    result = hasKey2(b, key) && eq(a3[key], b[key], aStack, bStack, customTesters, hasKey2);
     if (!result) {
       return false;
     }
@@ -9520,15 +9501,15 @@ function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
   bStack.pop();
   return result;
 }
-function isErrorEqual(a3, b2, aStack, bStack, customTesters, hasKey2) {
-  let result = Object.getPrototypeOf(a3) === Object.getPrototypeOf(b2) && a3.name === b2.name && a3.message === b2.message;
-  if (typeof b2.cause !== "undefined") {
-    result && (result = eq(a3.cause, b2.cause, aStack, bStack, customTesters, hasKey2));
+function isErrorEqual(a3, b, aStack, bStack, customTesters, hasKey2) {
+  let result = Object.getPrototypeOf(a3) === Object.getPrototypeOf(b) && a3.name === b.name && a3.message === b.message;
+  if (typeof b.cause !== "undefined") {
+    result && (result = eq(a3.cause, b.cause, aStack, bStack, customTesters, hasKey2));
   }
-  if (a3 instanceof AggregateError && b2 instanceof AggregateError) {
-    result && (result = eq(a3.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
+  if (a3 instanceof AggregateError && b instanceof AggregateError) {
+    result && (result = eq(a3.errors, b.errors, aStack, bStack, customTesters, hasKey2));
   }
-  result && (result = eq({ ...a3 }, { ...b2 }, aStack, bStack, customTesters, hasKey2));
+  result && (result = eq({ ...a3 }, { ...b }, aStack, bStack, customTesters, hasKey2));
   return result;
 }
 function keys(obj, hasKey2) {
@@ -9582,34 +9563,34 @@ var IteratorSymbol = Symbol.iterator;
 function hasIterator(object2) {
   return !!(object2 != null && object2[IteratorSymbol]);
 }
-function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = []) {
-  if (typeof a3 !== "object" || typeof b2 !== "object" || Array.isArray(a3) || Array.isArray(b2) || !hasIterator(a3) || !hasIterator(b2)) {
+function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
+  if (typeof a3 !== "object" || typeof b !== "object" || Array.isArray(a3) || Array.isArray(b) || !hasIterator(a3) || !hasIterator(b)) {
     return void 0;
   }
-  if (a3.constructor !== b2.constructor) {
+  if (a3.constructor !== b.constructor) {
     return false;
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a3) {
-      return bStack[length] === b2;
+      return bStack[length] === b;
     }
   }
   aStack.push(a3);
-  bStack.push(b2);
+  bStack.push(b);
   const filteredCustomTesters = [...customTesters.filter((t) => t !== iterableEquality), iterableEqualityWithStack];
-  function iterableEqualityWithStack(a4, b3) {
-    return iterableEquality(a4, b3, [...customTesters], [...aStack], [...bStack]);
+  function iterableEqualityWithStack(a4, b2) {
+    return iterableEquality(a4, b2, [...customTesters], [...aStack], [...bStack]);
   }
   if (a3.size !== void 0) {
-    if (a3.size !== b2.size) {
+    if (a3.size !== b.size) {
       return false;
     } else if (isA("Set", a3) || isImmutableUnorderedSet(a3)) {
       let allFound = true;
       for (const aValue of a3) {
-        if (!b2.has(aValue)) {
+        if (!b.has(aValue)) {
           let has = false;
-          for (const bValue of b2) {
+          for (const bValue of b) {
             const isEqual = equals(aValue, bValue, filteredCustomTesters);
             if (isEqual === true) {
               has = true;
@@ -9627,9 +9608,9 @@ function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = [])
     } else if (isA("Map", a3) || isImmutableUnorderedKeyed(a3)) {
       let allFound = true;
       for (const aEntry of a3) {
-        if (!b2.has(aEntry[0]) || !equals(aEntry[1], b2.get(aEntry[0]), filteredCustomTesters)) {
+        if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), filteredCustomTesters)) {
           let has = false;
-          for (const bEntry of b2) {
+          for (const bEntry of b) {
             const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
             let matchedValue = false;
             if (matchedKey === true) {
@@ -9650,7 +9631,7 @@ function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = [])
       return allFound;
     }
   }
-  const bIterator = b2[IteratorSymbol]();
+  const bIterator = b[IteratorSymbol]();
   for (const aValue of a3) {
     const nextB = bIterator.next();
     if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) {
@@ -9662,7 +9643,7 @@ function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = [])
   }
   if (!isImmutableList(a3) && !isImmutableOrderedKeyed(a3) && !isImmutableOrderedSet(a3) && !isImmutableRecord(a3)) {
     const aEntries = Object.entries(a3);
-    const bEntries = Object.entries(b2);
+    const bEntries = Object.entries(b);
     if (!equals(aEntries, bEntries, filteredCustomTesters)) {
       return false;
     }
@@ -9701,22 +9682,22 @@ function subsetEquality(object2, subset, customTesters = []) {
   };
   return subsetEqualityWithContext()(object2, subset);
 }
-function typeEquality(a3, b2) {
-  if (a3 == null || b2 == null || a3.constructor === b2.constructor) {
+function typeEquality(a3, b) {
+  if (a3 == null || b == null || a3.constructor === b.constructor) {
     return void 0;
   }
   return false;
 }
-function arrayBufferEquality(a3, b2) {
+function arrayBufferEquality(a3, b) {
   let dataViewA = a3;
-  let dataViewB = b2;
-  if (!(a3 instanceof DataView && b2 instanceof DataView)) {
-    if (!(a3 instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) {
+  let dataViewB = b;
+  if (!(a3 instanceof DataView && b instanceof DataView)) {
+    if (!(a3 instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
       return void 0;
     }
     try {
       dataViewA = new DataView(a3);
-      dataViewB = new DataView(b2);
+      dataViewB = new DataView(b);
     } catch {
       return void 0;
     }
@@ -9731,14 +9712,14 @@ function arrayBufferEquality(a3, b2) {
   }
   return true;
 }
-function sparseArrayEquality(a3, b2, customTesters = []) {
-  if (!Array.isArray(a3) || !Array.isArray(b2)) {
+function sparseArrayEquality(a3, b, customTesters = []) {
+  if (!Array.isArray(a3) || !Array.isArray(b)) {
     return void 0;
   }
   const aKeys = Object.keys(a3);
-  const bKeys = Object.keys(b2);
+  const bKeys = Object.keys(b);
   const filteredCustomTesters = customTesters.filter((t) => t !== sparseArrayEquality);
-  return equals(a3, b2, filteredCustomTesters, true) && equals(aKeys, bKeys);
+  return equals(a3, b, filteredCustomTesters, true) && equals(aKeys, bKeys);
 }
 function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
@@ -10430,7 +10411,7 @@ var JestChaiExpect = (chai2, utils) => {
     return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected, false);
   });
   function assertIsMock(assertion) {
-    if (!isMockFunction(assertion._obj)) {
+    if (!isMockFunction2(assertion._obj)) {
       throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
     }
   }
@@ -10470,8 +10451,8 @@ var JestChaiExpect = (chai2, utils) => {
       throw new AssertionError2(msg);
     }
   });
-  function equalsArgumentArray(a3, b2) {
-    return a3.length === b2.length && a3.every((aItem, i) => equals(aItem, b2[i], [...customTesters, iterableEquality]));
+  function equalsArgumentArray(a3, b) {
+    return a3.length === b.length && a3.every((aItem, i) => equals(aItem, b[i], [...customTesters, iterableEquality]));
   }
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
@@ -10532,14 +10513,14 @@ var JestChaiExpect = (chai2, utils) => {
   }
   def(["toHaveBeenCalledBefore"], function(resultSpy, failIfNoFirstInvocation = true) {
     const expectSpy = getSpy(this);
-    if (!isMockFunction(resultSpy)) {
+    if (!isMockFunction2(resultSpy)) {
       throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
     }
     this.assert(isSpyCalledBeforeAnotherSpy(expectSpy, resultSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called before "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called before "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
   });
   def(["toHaveBeenCalledAfter"], function(resultSpy, failIfNoFirstInvocation = true) {
     const expectSpy = getSpy(this);
-    if (!isMockFunction(resultSpy)) {
+    if (!isMockFunction2(resultSpy)) {
       throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
     }
     this.assert(isSpyCalledBeforeAnotherSpy(resultSpy, expectSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called after "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called after "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
@@ -10773,15 +10754,15 @@ var JestChaiExpect = (chai2, utils) => {
   });
 };
 function ordinalOf(i) {
-  const j2 = i % 10;
-  const k2 = i % 100;
-  if (j2 === 1 && k2 !== 11) {
+  const j = i % 10;
+  const k = i % 100;
+  if (j === 1 && k !== 11) {
     return `${i}st`;
   }
-  if (j2 === 2 && k2 !== 12) {
+  if (j === 2 && k !== 12) {
     return `${i}nd`;
   }
-  if (j2 === 3 && k2 !== 13) {
+  if (j === 3 && k !== 13) {
     return `${i}rd`;
   }
   return `${i}th`;
@@ -11150,68 +11131,80 @@ function parseSingleV8Stack(raw) {
   };
 }
 var import_js_tokens = (0, import_chunk_2ESYSVXG.__toESM)(require_js_tokens(), 1);
-var FILL_COMMENT = " ";
-function stripLiteralFromToken(token, fillChar, filter) {
-  if (token.type === "SingleLineComment") {
-    return FILL_COMMENT.repeat(token.value.length);
-  }
-  if (token.type === "MultiLineComment") {
-    return token.value.replace(/[^\n]/g, FILL_COMMENT);
-  }
-  if (token.type === "StringLiteral") {
-    if (!token.closed) {
-      return token.value;
+function stripLiteralJsTokens(code, options) {
+  const FILL = options?.fillChar ?? " ";
+  const FILL_COMMENT = " ";
+  let result = "";
+  const filter = options?.filter ?? (() => true);
+  const tokens = [];
+  for (const token of (0, import_js_tokens.default)(code, { jsx: false })) {
+    tokens.push(token);
+    if (token.type === "SingleLineComment") {
+      result += FILL_COMMENT.repeat(token.value.length);
+      continue;
     }
-    const body = token.value.slice(1, -1);
-    if (filter(body)) {
-      return token.value[0] + fillChar.repeat(body.length) + token.value[token.value.length - 1];
+    if (token.type === "MultiLineComment") {
+      result += token.value.replace(/[^\n]/g, FILL_COMMENT);
+      continue;
     }
-  }
-  if (token.type === "NoSubstitutionTemplate") {
-    const body = token.value.slice(1, -1);
-    if (filter(body)) {
-      return `\`${body.replace(/[^\n]/g, fillChar)}\``;
+    if (token.type === "StringLiteral") {
+      if (!token.closed) {
+        result += token.value;
+        continue;
+      }
+      const body = token.value.slice(1, -1);
+      if (filter(body)) {
+        result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
+        continue;
+      }
     }
-  }
-  if (token.type === "RegularExpressionLiteral") {
-    const body = token.value;
-    if (filter(body)) {
-      return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`);
+    if (token.type === "NoSubstitutionTemplate") {
+      const body = token.value.slice(1, -1);
+      if (filter(body)) {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
     }
-  }
-  if (token.type === "TemplateHead") {
-    const body = token.value.slice(1, -2);
-    if (filter(body)) {
-      return `\`${body.replace(/[^\n]/g, fillChar)}\${`;
+    if (token.type === "RegularExpressionLiteral") {
+      const body = token.value;
+      if (filter(body)) {
+        result += body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${FILL.repeat($1.length)}/${$2}`);
+        continue;
+      }
     }
-  }
-  if (token.type === "TemplateTail") {
-    const body = token.value.slice(0, -2);
-    if (filter(body)) {
-      return `}${body.replace(/[^\n]/g, fillChar)}\``;
+    if (token.type === "TemplateHead") {
+      const body = token.value.slice(1, -2);
+      if (filter(body)) {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
     }
-  }
-  if (token.type === "TemplateMiddle") {
-    const body = token.value.slice(1, -2);
-    if (filter(body)) {
-      return `}${body.replace(/[^\n]/g, fillChar)}\${`;
+    if (token.type === "TemplateTail") {
+      const body = token.value.slice(0, -2);
+      if (filter(body)) {
+        result += `}${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
     }
+    if (token.type === "TemplateMiddle") {
+      const body = token.value.slice(1, -2);
+      if (filter(body)) {
+        result += `}${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    result += token.value;
   }
-  return token.value;
-}
-function optionsWithDefaults(options) {
   return {
-    fillChar: options?.fillChar ?? " ",
-    filter: options?.filter ?? (() => true)
+    result,
+    tokens
   };
 }
 function stripLiteral(code, options) {
-  let result = "";
-  const _options = optionsWithDefaults(options);
-  for (const token of (0, import_js_tokens.default)(code, { jsx: false })) {
-    result += stripLiteralFromToken(token, _options.fillChar, _options.filter);
-  }
-  return result;
+  return stripLiteralDetailed(code, options).result;
+}
+function stripLiteralDetailed(code, options) {
+  return stripLiteralJsTokens(code, options);
 }
 var _DRIVE_LETTER_START_RE2 = /^[A-Za-z]:\//;
 function normalizeWindowsPath2(input = "") {
@@ -11634,7 +11627,7 @@ var test3 = createTest(function(name, optionsOrFn, optionsOrTest) {
 var runner;
 var defaultSuite;
 var currentTestFilepath;
-function assert2(condition, message) {
+function assert3(condition, message) {
   if (!condition) {
     throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
   }
@@ -11643,12 +11636,12 @@ function getTestFilepath() {
   return currentTestFilepath;
 }
 function getRunner() {
-  assert2(runner, "the runner");
+  assert3(runner, "the runner");
   return runner;
 }
 function getCurrentSuite() {
   const currentSuite = collectorContext.currentSuite || defaultSuite;
-  assert2(currentSuite, "the current suite");
+  assert3(currentSuite, "the current suite");
   return currentSuite;
 }
 function createSuiteHooks() {
@@ -12047,8 +12040,8 @@ function formatTemplateString(cases, args) {
   const res = [];
   for (let i = 0; i < Math.floor(args.length / header.length); i++) {
     const oneCase = {};
-    for (let j2 = 0; j2 < header.length; j2++) {
-      oneCase[header[j2]] = args[i * header.length + j2];
+    for (let j = 0; j < header.length; j++) {
+      oneCase[header[j]] = args[i * header.length + j];
     }
     res.push(oneCase);
   }
@@ -12319,25 +12312,25 @@ function encodeUint8Array(bytes) {
   for (let i = 0; i < len; i += 3) {
     if (len === i + 1) {
       const a3 = (bytes[i] & 252) >> 2;
-      const b2 = (bytes[i] & 3) << 4;
+      const b = (bytes[i] & 3) << 4;
       base64 += table[a3];
-      base64 += table[b2];
+      base64 += table[b];
       base64 += "==";
     } else if (len === i + 2) {
       const a3 = (bytes[i] & 252) >> 2;
-      const b2 = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
       const c = (bytes[i + 1] & 15) << 2;
       base64 += table[a3];
-      base64 += table[b2];
+      base64 += table[b];
       base64 += table[c];
       base64 += "=";
     } else {
       const a3 = (bytes[i] & 252) >> 2;
-      const b2 = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
       const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
       const d = bytes[i + 2] & 63;
       base64 += table[a3];
-      base64 += table[b2];
+      base64 += table[b];
       base64 += table[c];
       base64 += table[d];
     }
@@ -12444,8 +12437,8 @@ async function waitForImportsToResolve() {
   await waitForImportsToResolve();
 }
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs3(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs3(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var comma2 = ",".charCodeAt(0);
 var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -12542,8 +12535,8 @@ function decode(mappings) {
 function sort(line) {
   line.sort(sortComparator$1);
 }
-function sortComparator$1(a3, b2) {
-  return a3[0] - b2[0];
+function sortComparator$1(a3, b) {
+  return a3[0] - b[0];
 }
 var schemeRegex = /^[\w+.-]+:\/\//;
 var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
@@ -12757,8 +12750,8 @@ function nextUnsortedSegmentLine(mappings, start) {
   return mappings.length;
 }
 function isSorted(line) {
-  for (let j2 = 1; j2 < line.length; j2++) {
-    if (line[j2][COLUMN] < line[j2 - 1][COLUMN]) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
       return false;
     }
   }
@@ -12769,8 +12762,8 @@ function sortSegments(line, owned) {
     line = line.slice();
   return line.sort(sortComparator);
 }
-function sortComparator(a3, b2) {
-  return a3[COLUMN] - b2[COLUMN];
+function sortComparator(a3, b) {
+  return a3[COLUMN] - b[COLUMN];
 }
 var found = false;
 function binarySearch(haystack, needle, low, high) {
@@ -12903,8 +12896,8 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     return -1;
   return index2;
 }
-function notNullish2(v2) {
-  return v2 != null;
+function notNullish2(v) {
+  return v != null;
 }
 function isPrimitive3(value) {
   return value === null || typeof value !== "function" && typeof value !== "object";
@@ -13119,7 +13112,7 @@ function parseErrorStacktrace(e, options = {}) {
     }
   }
   if (options.frameFilter) {
-    stackFrames = stackFrames.filter((f4) => options.frameFilter(e, f4) !== false);
+    stackFrames = stackFrames.filter((f3) => options.frameFilter(e, f3) !== false);
   }
   e.stacks = stackFrames;
   return stackFrames;
@@ -13139,8 +13132,8 @@ try {
 } catch (notNode) {
 }
 var { AsymmetricMatcher: AsymmetricMatcher$1, DOMCollection: DOMCollection$1, DOMElement: DOMElement$1, Immutable: Immutable$1, ReactElement: ReactElement$1, ReactTestComponent: ReactTestComponent$1 } = plugins;
-function getDefaultExportFromCjs4(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs4(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var jsTokens_12;
 var hasRequiredJsTokens2;
@@ -13588,7 +13581,7 @@ var reservedWords2 = {
 };
 new Set(reservedWords2.keyword);
 new Set(reservedWords2.strict);
-var f3 = {
+var f2 = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
   dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -13631,7 +13624,7 @@ var f3 = {
   bgCyanBright: [106, 49],
   bgWhiteBright: [107, 49]
 };
-var h3 = Object.entries(f3);
+var h2 = Object.entries(f2);
 function a2(n) {
   return String(n);
 }
@@ -13643,27 +13636,27 @@ function C2(n = false) {
 }
 function p2(n = false) {
   let e = C2(n), i = (r2, t, c, o) => {
-    let l2 = "", s2 = 0;
+    let l = "", s2 = 0;
     do
-      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l2 + r2.substring(s2);
+    return l + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    let o = (l2) => {
-      let s2 = String(l2), b2 = s2.indexOf(t, r2.length);
-      return ~b2 ? r2 + i(s2, t, c, b2) + t : r2 + s2 + t;
+    let o = (l) => {
+      let s2 = String(l), b = s2.indexOf(t, r2.length);
+      return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
     };
     return o.open = r2, o.close = t, o;
-  }, u3 = {
+  }, u2 = {
     isColorSupported: e
   }, d = (r2) => `\x1B[${r2}m`;
-  for (let [r2, t] of h3)
-    u3[r2] = e ? g(
+  for (let [r2, t] of h2)
+    u2[r2] = e ? g(
       d(t[0]),
       d(t[1]),
       t[2]
     ) : a2;
-  return u3;
+  return u2;
 }
 p2();
 var lineSplitRE = /\r?\n/;
@@ -13697,7 +13690,7 @@ function offsetToLineNumber(source, offset) {
   return line + 1;
 }
 async function saveInlineSnapshots(environment, snapshots) {
-  const MagicString = (await import("../magic-string.es-SDTMJBWP.js")).default;
+  const MagicString = (await import("../magic-string.es-3WRPFX2A.js")).default;
   const files = new Set(snapshots.map((i) => i.file));
   await Promise.all(Array.from(files).map(async (file) => {
     const snaps = snapshots.filter((i) => i.file === file);
@@ -13848,7 +13841,7 @@ var hasRequiredNaturalCompare;
 function requireNaturalCompare() {
   if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
   hasRequiredNaturalCompare = 1;
-  var naturalCompare2 = function(a3, b2) {
+  var naturalCompare2 = function(a3, b) {
     var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
     function getCode(str, pos, code) {
       if (code) {
@@ -13858,12 +13851,12 @@ function requireNaturalCompare() {
       code = alphabet && alphabet.indexOf(str.charAt(pos));
       return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
     }
-    if ((a3 += "") != (b2 += "")) for (; codeB; ) {
+    if ((a3 += "") != (b += "")) for (; codeB; ) {
       codeA = getCode(a3, posA++);
-      codeB = getCode(b2, posB++);
+      codeB = getCode(b, posB++);
       if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
         codeA = getCode(a3, posA, posA);
-        codeB = getCode(b2, posB, posA = i);
+        codeB = getCode(b, posB, posA = i);
         posB = i;
       }
       if (codeA != codeB) return codeA < codeB ? -1 : 1;
@@ -14054,14 +14047,14 @@ var CounterMap = class extends DefaultMap {
       return this._total;
     }
     let total = 0;
-    for (const x2 of this.values()) {
-      total += x2;
+    for (const x of this.values()) {
+      total += x;
     }
     return total;
   }
 };
-function isSameStackPosition(x2, y2) {
-  return x2.file === y2.file && x2.column === y2.column && x2.line === y2.line;
+function isSameStackPosition(x, y) {
+  return x.file === y.file && x.column === y.column && x.line === y.line;
 }
 var SnapshotState = class _SnapshotState {
   _counters = new CounterMap();
@@ -14476,7 +14469,7 @@ var SnapshotClient = class {
 var RealDate = Date;
 var now2 = null;
 var MockDate = class _MockDate extends RealDate {
-  constructor(y2, m2, d, h4, M2, s2, ms) {
+  constructor(y, m2, d, h3, M, s2, ms) {
     super();
     let date;
     switch (arguments.length) {
@@ -14485,15 +14478,15 @@ var MockDate = class _MockDate extends RealDate {
         else date = new RealDate();
         break;
       case 1:
-        date = new RealDate(y2);
+        date = new RealDate(y);
         break;
       default:
         d = typeof d === "undefined" ? 1 : d;
-        h4 = h4 || 0;
-        M2 = M2 || 0;
+        h3 = h3 || 0;
+        M = M || 0;
         s2 = s2 || 0;
         ms = ms || 0;
-        date = new RealDate(y2, m2, d, h4, M2, s2, ms);
+        date = new RealDate(y, m2, d, h3, M, s2, ms);
         break;
     }
     Object.setPrototypeOf(date, _MockDate.prototype);
@@ -14889,11 +14882,11 @@ function createExpect(test5) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
     setState({ assertionCalls: assertionCalls + 1 }, expect2);
-    const assert3 = expect(value, message);
+    const assert4 = expect(value, message);
     const _test2 = test5 || getCurrentTest();
     if (_test2)
-      return assert3.withTest(_test2);
-    else return assert3;
+      return assert4.withTest(_test2);
+    else return assert4;
   };
   Object.assign(expect2, expect);
   Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
@@ -14920,7 +14913,7 @@ function createExpect(test5) {
   };
   expect2.poll = createExpectPoll(expect2);
   expect2.unreachable = (message) => {
-    assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+    assert2.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
   };
   function assertions(expected) {
     const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
@@ -15037,10 +15030,10 @@ function requireCalledInOrder() {
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index2, spies) {
+  function checkAdjacentCalls(callMap, spy, index2, spies2) {
     var calledBeforeNext = true;
-    if (index2 !== spies.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
+    if (index2 !== spies2.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies2[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -15048,9 +15041,9 @@ function requireCalledInOrder() {
     }
     return false;
   }
-  function calledInOrder(spies) {
+  function calledInOrder(spies2) {
     var callMap = {};
-    var _spies = arguments.length > 1 ? arguments : spies;
+    var _spies = arguments.length > 1 ? arguments : spies2;
     return every2(_spies, checkAdjacentCalls.bind(null, callMap));
   }
   calledInOrder_1 = calledInOrder;
@@ -15147,15 +15140,15 @@ function requireOrderByFirstCall() {
   hasRequiredOrderByFirstCall = 1;
   var sort2 = requireArray().sort;
   var slice = requireArray().slice;
-  function comparator(a3, b2) {
+  function comparator(a3, b) {
     var aCall = a3.getCall(0);
-    var bCall = b2.getCall(0);
+    var bCall = b.getCall(0);
     var aId = aCall && aCall.callId || -1;
     var bId = bCall && bCall.callId || -1;
     return aId < bId ? -1 : 1;
   }
-  function orderByFirstCall(spies) {
-    return sort2(slice(spies), comparator);
+  function orderByFirstCall(spies2) {
+    return sort2(slice(spies2), comparator);
   }
   orderByFirstCall_1 = orderByFirstCall;
   return orderByFirstCall_1;
@@ -15482,11 +15475,11 @@ function requireFakeTimersSrc() {
         return 0;
       }
       const strings = str.split(":");
-      const l2 = strings.length;
-      let i = l2;
+      const l = strings.length;
+      let i = l;
       let ms = 0;
       let parsed;
-      if (l2 > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+      if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
         throw new Error(
           "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
         );
@@ -15496,7 +15489,7 @@ function requireFakeTimersSrc() {
         if (parsed >= 60) {
           throw new Error(`Invalid time ${str}`);
         }
-        ms += parsed * Math.pow(60, l2 - i - 1);
+        ms += parsed * Math.pow(60, l - i - 1);
       }
       return ms * 1e3;
     }
@@ -15735,29 +15728,29 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return timer.id;
     }
-    function compareTimers(a3, b2) {
-      if (a3.callAt < b2.callAt) {
+    function compareTimers(a3, b) {
+      if (a3.callAt < b.callAt) {
         return -1;
       }
-      if (a3.callAt > b2.callAt) {
+      if (a3.callAt > b.callAt) {
         return 1;
       }
-      if (a3.immediate && !b2.immediate) {
+      if (a3.immediate && !b.immediate) {
         return -1;
       }
-      if (!a3.immediate && b2.immediate) {
+      if (!a3.immediate && b.immediate) {
         return 1;
       }
-      if (a3.createdAt < b2.createdAt) {
+      if (a3.createdAt < b.createdAt) {
         return -1;
       }
-      if (a3.createdAt > b2.createdAt) {
+      if (a3.createdAt > b.createdAt) {
         return 1;
       }
-      if (a3.id < b2.id) {
+      if (a3.id < b.id) {
         return -1;
       }
-      if (a3.id > b2.id) {
+      if (a3.id > b.id) {
         return 1;
       }
     }
@@ -15868,10 +15861,10 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       }
     }
     function uninstall(clock, config2) {
-      let method, i, l2;
+      let method, i, l;
       const installedHrTime = "_hrtime";
       const installedNextTick = "_nextTick";
-      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
+      for (i = 0, l = clock.methods.length; i < l; i++) {
         method = clock.methods[i];
         if (method === "hrtime" && _global.process) {
           _global.process.hrtime = clock[installedHrTime];
@@ -15902,14 +15895,14 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           }
         }
         if (clock.timersModuleMethods !== void 0) {
-          for (let j2 = 0; j2 < clock.timersModuleMethods.length; j2++) {
-            const entry = clock.timersModuleMethods[j2];
+          for (let j = 0; j < clock.timersModuleMethods.length; j++) {
+            const entry = clock.timersModuleMethods[j];
             timersModule[entry.methodName] = entry.original;
           }
         }
         if (clock.timersPromisesModuleMethods !== void 0) {
-          for (let j2 = 0; j2 < clock.timersPromisesModuleMethods.length; j2++) {
-            const entry = clock.timersPromisesModuleMethods[j2];
+          for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
+            const entry = clock.timersPromisesModuleMethods[j];
             timersPromisesModule[entry.methodName] = entry.original;
           }
         }
@@ -16414,7 +16407,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
         };
       }
-      clock.reset = function reset() {
+      clock.reset = function reset2() {
         nanos = 0;
         clock.timers = {};
         clock.jobs = [];
@@ -16485,7 +16478,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           `non-existent timers and/or objects cannot be faked: '${timer}'`
         );
       }
-      let i, l2;
+      let i, l;
       const clock = createClock(config2.now, config2.loopLimit);
       clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
       clock.uninstall = function() {
@@ -16536,7 +16529,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       if (_global === globalObject && timersPromisesModule) {
         clock.timersPromisesModuleMethods = [];
       }
-      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
+      for (i = 0, l = clock.methods.length; i < l; i++) {
         const nameOfMethodToReplace = clock.methods[i];
         if (!isPresent[nameOfMethodToReplace]) {
           handleMissingTimer(nameOfMethodToReplace);
@@ -17121,7 +17114,7 @@ function createVitest() {
       return item;
     },
     isMockFunction(fn2) {
-      return isMockFunction(fn2);
+      return isMockFunction2(fn2);
     },
     clearAllMocks() {
       [...mocks].reverse().forEach((spy) => spy.mockClear());
@@ -17241,7 +17234,7 @@ ${[...generateDirectoryTree(children, indent)].join("\n")}
         c.fs.symlink(import_node_path.default.join(originalCwd, "..", "config"), import_node_path.default.join(c.fs.cwd(), "node_modules", "@prisma", "config"));
       };
       c.cli = (...input) => {
-        return (0, import_chunk_OJINGNLI.execaNode)(import_node_path.default.join(originalCwd, "../cli/build/index.js"), input, {
+        return (0, import_chunk_3UEKS5W6.execaNode)(import_node_path.default.join(originalCwd, "../cli/build/index.js"), input, {
           cwd: c.fs.cwd(),
           stdio: "pipe",
           all: true
@@ -17249,7 +17242,7 @@ ${[...generateDirectoryTree(children, indent)].join("\n")}
       };
       c.printDir = (dir, extensions) => {
         const content = c.fs.list(dir) ?? [];
-        content.sort((a3, b2) => a3.localeCompare(b2));
+        content.sort((a3, b) => a3.localeCompare(b));
         return content.filter((name) => extensions.includes(import_node_path.default.extname(name))).map((name) => `${name}:
 
 ${c.fs.read(import_node_path.default.join(dir, name))}`).join("\n\n");
@@ -17375,7 +17368,7 @@ var processExitContext = vitestProcessExitContext;
    * LICENSE file in the root directory of this source tree.
    *)
 
-chai/index.js:
+chai/chai.js:
   (*!
    * Chai - flag utility
    * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>