@blindpay/node 2.0.4 → 2.1.0

package/dist/{chunk-GCCHFONX.mjs → chunk-D6N3USMR.mjs}

@@ -20,27 +20,27 @@ function C(n = false) {
 }
 function p(n = false) {
   let e = C(n), i = (r2, t, c, o) => {
-    let l = "", s2 = 0;
+    let l2 = "", s2 = 0;
     do
-      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l + r2.substring(s2);
+    return l2 + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    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;
+    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;
     };
     return o.open = r2, o.close = t, o;
-  }, u2 = {
+  }, u3 = {
     isColorSupported: e
   }, d = (r2) => `\x1B[${r2}m`;
   for (let [r2, t] of h)
-    u2[r2] = e ? g(
+    u3[r2] = e ? g(
       d(t[0]),
       d(t[1]),
       t[2]
     ) : a;
-  return u2;
+  return u3;
 }
 var f, h;
 var init_chunk_BVHSVHOK = __esm({
@@ -110,13 +110,13 @@ var init_node = __esm({
 // node_modules/@vitest/pretty-format/dist/index.js
 function _mergeNamespaces(n, m2) {
   m2.forEach(function(e) {
-    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 : {
+    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 : {
           enumerable: true,
           get: function() {
-            return e[k];
+            return e[k2];
           }
         });
       }
@@ -191,7 +191,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 = (l) => l instanceof DataView;
+  const isDataView = (l2) => l2 instanceof DataView;
   const length = isDataView(list) ? list.byteLength : list.length;
   if (length > 0) {
     result += config2.spacingOuter;
@@ -337,8 +337,8 @@ function printImmutableSeq(val, config2, indentation, depth, refs, printer2) {
 function printImmutableValues(val, config2, indentation, depth, refs, printer2, type3) {
   return ++depth > config2.maxDepth ? printAsLeaf(getImmutableName(type3)) : `${getImmutableName(type3) + SPACE}[${printIteratorValues(val.values(), config2, indentation, depth, refs, printer2)}]`;
 }
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+function getDefaultExportFromCjs(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
 function requireReactIs_production() {
   if (hasRequiredReactIs_production) return reactIs_production;
@@ -535,25 +535,25 @@ function requireReactIs$1() {
 function requireReactIs_production_min() {
   if (hasRequiredReactIs_production_min) return reactIs_production_min;
   hasRequiredReactIs_production_min = 1;
-  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) {
+  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) {
     if ("object" === typeof a3 && null !== a3) {
       var r2 = a3.$$typeof;
       switch (r2) {
-        case b:
+        case b2:
           switch (a3 = a3.type, a3) {
             case d:
-            case f3:
+            case f4:
             case e:
             case m2:
             case n:
               return a3;
             default:
               switch (a3 = a3 && a3.$$typeof, a3) {
-                case k:
-                case h3:
-                case l:
+                case k2:
+                case h4:
+                case l2:
                 case q:
                 case p3:
                 case g:
@@ -567,15 +567,15 @@ function requireReactIs_production_min() {
       }
     }
   }
-  reactIs_production_min.ContextConsumer = h3;
+  reactIs_production_min.ContextConsumer = h4;
   reactIs_production_min.ContextProvider = g;
-  reactIs_production_min.Element = b;
-  reactIs_production_min.ForwardRef = l;
+  reactIs_production_min.Element = b2;
+  reactIs_production_min.ForwardRef = l2;
   reactIs_production_min.Fragment = d;
   reactIs_production_min.Lazy = q;
   reactIs_production_min.Memo = p3;
   reactIs_production_min.Portal = c;
-  reactIs_production_min.Profiler = f3;
+  reactIs_production_min.Profiler = f4;
   reactIs_production_min.StrictMode = e;
   reactIs_production_min.Suspense = m2;
   reactIs_production_min.SuspenseList = n;
@@ -586,45 +586,45 @@ function requireReactIs_production_min() {
     return false;
   };
   reactIs_production_min.isContextConsumer = function(a3) {
-    return v(a3) === h3;
+    return v2(a3) === h4;
   };
   reactIs_production_min.isContextProvider = function(a3) {
-    return v(a3) === g;
+    return v2(a3) === g;
   };
   reactIs_production_min.isElement = function(a3) {
-    return "object" === typeof a3 && null !== a3 && a3.$$typeof === b;
+    return "object" === typeof a3 && null !== a3 && a3.$$typeof === b2;
   };
   reactIs_production_min.isForwardRef = function(a3) {
-    return v(a3) === l;
+    return v2(a3) === l2;
   };
   reactIs_production_min.isFragment = function(a3) {
-    return v(a3) === d;
+    return v2(a3) === d;
   };
   reactIs_production_min.isLazy = function(a3) {
-    return v(a3) === q;
+    return v2(a3) === q;
   };
   reactIs_production_min.isMemo = function(a3) {
-    return v(a3) === p3;
+    return v2(a3) === p3;
   };
   reactIs_production_min.isPortal = function(a3) {
-    return v(a3) === c;
+    return v2(a3) === c;
   };
   reactIs_production_min.isProfiler = function(a3) {
-    return v(a3) === f3;
+    return v2(a3) === f4;
   };
   reactIs_production_min.isStrictMode = function(a3) {
-    return v(a3) === e;
+    return v2(a3) === e;
   };
   reactIs_production_min.isSuspense = function(a3) {
-    return v(a3) === m2;
+    return v2(a3) === m2;
   };
   reactIs_production_min.isSuspenseList = function(a3) {
-    return v(a3) === n;
+    return v2(a3) === n;
   };
   reactIs_production_min.isValidElementType = function(a3) {
-    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;
+    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;
   };
-  reactIs_production_min.typeOf = v;
+  reactIs_production_min.typeOf = v2;
   return reactIs_production_min;
 }
 function requireReactIs_development() {
@@ -1263,7 +1263,7 @@ var init_dist = __esm({
       "isSuspenseList",
       "isValidElementType"
     ];
-    ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v) => ReactIs18[m2](v) || ReactIs19[m2](v)]));
+    ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v2) => ReactIs18[m2](v2) || ReactIs19[m2](v2)]));
     serialize$1 = (element, config2, indentation, depth, refs, printer2) => ++depth > config2.maxDepth ? printElementAsLeaf(getType(element), config2) : printElement(getType(element), printProps(getPropKeys$1(element), element.props, config2, indentation + config2.indent, depth, refs, printer2), printChildren(getChildren(element.props.children), config2, indentation + config2.indent, depth, refs, printer2), config2, indentation);
     test$1 = (val) => val != null && ReactIs.isElement(val);
     plugin$1 = {
@@ -2071,14 +2071,14 @@ function format2(...args) {
   const len = args.length;
   let i = 1;
   const template = args[0];
-  let str = String(template).replace(formatRegExp, (x) => {
-    if (x === "%%") {
+  let str = String(template).replace(formatRegExp, (x2) => {
+    if (x2 === "%%") {
       return "%";
     }
     if (i >= len) {
-      return x;
+      return x2;
     }
-    switch (x) {
+    switch (x2) {
       case "%s": {
         const value = args[i++];
         if (typeof value === "bigint") {
@@ -2136,14 +2136,14 @@ function format2(...args) {
           throw err;
         }
       default:
-        return x;
+        return x2;
     }
   });
-  for (let x = args[i]; i < len; x = args[++i]) {
-    if (x === null || typeof x !== "object") {
-      str += ` ${x}`;
+  for (let x2 = args[i]; i < len; x2 = args[++i]) {
+    if (x2 === null || typeof x2 !== "object") {
+      str += ` ${x2}`;
     } else {
-      str += ` ${inspect2(x)}`;
+      str += ` ${inspect2(x2)}`;
     }
   }
   return str;
@@ -2176,8 +2176,8 @@ function objDisplay(obj, options = {}) {
   }
   return str;
 }
-function getDefaultExportFromCjs2(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+function getDefaultExportFromCjs2(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
 var AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent, PLUGINS, formatRegExp;
 var init_chunk_commonjsHelpers = __esm({
@@ -2254,15 +2254,15 @@ function deepClone(val, options = defaultCloneOptions) {
   return clone(val, seen, options);
 }
 function clone(val, seen, options = defaultCloneOptions) {
-  let k, out;
+  let k2, out;
   if (seen.has(val)) {
     return seen.get(val);
   }
   if (Array.isArray(val)) {
-    out = Array.from({ length: k = val.length });
+    out = Array.from({ length: k2 = val.length });
     seen.set(val, out);
-    while (k--) {
-      out[k] = clone(val[k], seen, options);
+    while (k2--) {
+      out[k2] = clone(val[k2], seen, options);
     }
     return out;
   }
@@ -2270,27 +2270,27 @@ function clone(val, seen, options = defaultCloneOptions) {
     out = Object.create(Object.getPrototypeOf(val));
     seen.set(val, out);
     const props = getOwnProperties(val);
-    for (const k2 of props) {
-      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
+    for (const k3 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k3);
       if (!descriptor) {
         continue;
       }
-      const cloned = clone(val[k2], seen, options);
+      const cloned = clone(val[k3], seen, options);
       if (options.forceWritable) {
-        Object.defineProperty(out, k2, {
+        Object.defineProperty(out, k3, {
           enumerable: descriptor.enumerable,
           configurable: true,
           writable: true,
           value: cloned
         });
       } else if ("get" in descriptor) {
-        Object.defineProperty(out, k2, __spreadProps(__spreadValues({}, descriptor), {
+        Object.defineProperty(out, k3, __spreadProps(__spreadValues({}, descriptor), {
           get() {
             return cloned;
           }
         }));
       } else {
-        Object.defineProperty(out, k2, __spreadProps(__spreadValues({}, descriptor), {
+        Object.defineProperty(out, k3, __spreadProps(__spreadValues({}, descriptor), {
           value: cloned
         }));
       }
@@ -3889,19 +3889,19 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   let aEnd = 0;
   let bEnd = 0;
   const pushCommonLine = (line) => {
-    const j = lines.length;
-    lines.push(printCommonLine(line, j === 0 || j === jLast, options));
+    const j2 = lines.length;
+    lines.push(printCommonLine(line, j2 === 0 || j2 === jLast, options));
     aEnd += 1;
     bEnd += 1;
   };
   const pushDeleteLine = (line) => {
-    const j = lines.length;
-    lines.push(printDeleteLine(line, j === 0 || j === jLast, options));
+    const j2 = lines.length;
+    lines.push(printDeleteLine(line, j2 === 0 || j2 === jLast, options));
     aEnd += 1;
   };
   const pushInsertLine = (line) => {
-    const j = lines.length;
-    lines.push(printInsertLine(line, j === 0 || j === jLast, options));
+    const j2 = lines.length;
+    lines.push(printInsertLine(line, j2 === 0 || j2 === jLast, options));
     bEnd += 1;
   };
   i = 0;
@@ -4023,20 +4023,20 @@ function isEmptyString(lines) {
 }
 function countChanges(diffs) {
   let a3 = 0;
-  let b = 0;
+  let b2 = 0;
   diffs.forEach((diff2) => {
     switch (diff2[0]) {
       case DIFF_DELETE:
         a3 += 1;
         break;
       case DIFF_INSERT:
-        b += 1;
+        b2 += 1;
         break;
     }
   });
   return {
     a: a3,
-    b
+    b: b2
   };
 }
 function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
@@ -4058,9 +4058,9 @@ function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor,
     bRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;
   }
   const a3 = `${aIndicator} ${aAnnotation}${aRest}`;
-  const b = `${bIndicator} ${bAnnotation}${bRest}`;
+  const b2 = `${bIndicator} ${bAnnotation}${bRest}`;
   return `${aColor(a3)}
-${bColor(b)}
+${bColor(b2)}
 
 `;
 }
@@ -4175,26 +4175,26 @@ function getType3(value) {
 function getNewLineSymbol(string2) {
   return string2.includes("\r\n") ? "\r\n" : "\n";
 }
-function diffStrings(a3, b, options) {
+function diffStrings(a3, b2, options) {
   var _a3, _b;
   const truncate3 = (_a3 = options === null || options === void 0 ? void 0 : options.truncateThreshold) != null ? _a3 : false;
   const truncateThreshold = Math.max(Math.floor((_b = options === null || options === void 0 ? void 0 : options.truncateThreshold) != null ? _b : 0), 0);
   let aLength = a3.length;
-  let bLength = b.length;
+  let bLength = b2.length;
   if (truncate3) {
     const aMultipleLines = a3.includes("\n");
-    const bMultipleLines = b.includes("\n");
+    const bMultipleLines = b2.includes("\n");
     const aNewLineSymbol = getNewLineSymbol(a3);
-    const bNewLineSymbol = getNewLineSymbol(b);
+    const bNewLineSymbol = getNewLineSymbol(b2);
     const _a4 = aMultipleLines ? `${a3.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
 ` : a3;
-    const _b2 = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
-` : b;
+    const _b2 = bMultipleLines ? `${b2.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
+` : b2;
     aLength = _a4.length;
     bLength = _b2.length;
   }
-  const truncated = aLength !== a3.length || bLength !== b.length;
-  const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b[bIndex2];
+  const truncated = aLength !== a3.length || bLength !== b2.length;
+  const isCommon = (aIndex2, bIndex2) => a3[aIndex2] === b2[bIndex2];
   let aIndex = 0;
   let bIndex = 0;
   const diffs = [];
@@ -4203,18 +4203,18 @@ function diffStrings(a3, b, options) {
       diffs.push(new Diff(DIFF_DELETE, a3.slice(aIndex, aCommon)));
     }
     if (bIndex !== bCommon) {
-      diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
+      diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex, bCommon)));
     }
     aIndex = aCommon + nCommon;
     bIndex = bCommon + nCommon;
-    diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
+    diffs.push(new Diff(DIFF_EQUAL, b2.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, b.slice(bIndex)));
+    diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex)));
   }
   return [diffs, truncated];
 }
@@ -4246,22 +4246,22 @@ function hasCommonDiff(diffs, isMultiline) {
   }
   return diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
 }
-function diffStringsUnified(a3, b, options) {
-  if (a3 !== b && a3.length !== 0 && b.length !== 0) {
-    const isMultiline = a3.includes("\n") || b.includes("\n");
+function diffStringsUnified(a3, b2, options) {
+  if (a3 !== b2 && a3.length !== 0 && b2.length !== 0) {
+    const isMultiline = a3.includes("\n") || b2.includes("\n");
     const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a3}
-` : a3, isMultiline ? `${b}
-` : b, true, options);
+` : a3, isMultiline ? `${b2}
+` : b2, 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"), b.split("\n"), options);
+  return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
 }
-function diffStringsRaw(a3, b, cleanup, options) {
-  const [diffs, truncated] = diffStrings(a3, b, options);
+function diffStringsRaw(a3, b2, cleanup, options) {
+  const [diffs, truncated] = diffStrings(a3, b2, options);
   if (cleanup) {
     diff_cleanupSemantic(diffs);
   }
@@ -4271,8 +4271,8 @@ function getCommonMessage(message, options) {
   const { commonColor } = normalizeDiffOptions(options);
   return commonColor(message);
 }
-function diff(a3, b, options) {
-  if (Object.is(a3, b)) {
+function diff(a3, b2, options) {
+  if (Object.is(a3, b2)) {
     return "";
   }
   const aType = getType3(a3);
@@ -4288,7 +4288,7 @@ function diff(a3, b, options) {
     expectedType = a3.getExpectedType();
     omitDifference = expectedType === "string";
   }
-  if (expectedType !== getType3(b)) {
+  if (expectedType !== getType3(b2)) {
     let truncate4 = function(s2) {
       return s2.length <= MAX_LENGTH ? s2 : `${s2.slice(0, MAX_LENGTH)}...`;
     };
@@ -4296,7 +4296,7 @@ function diff(a3, b, 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(b, formatOptions);
+    let bDisplay = format(b2, formatOptions);
     const MAX_LENGTH = 1e5;
     aDisplay = truncate4(aDisplay);
     bDisplay = truncate4(bDisplay);
@@ -4313,21 +4313,21 @@ ${bDiff}`;
   }
   switch (aType) {
     case "string":
-      return diffLinesUnified(a3.split("\n"), b.split("\n"), options);
+      return diffLinesUnified(a3.split("\n"), b2.split("\n"), options);
     case "boolean":
     case "number":
-      return comparePrimitive(a3, b, options);
+      return comparePrimitive(a3, b2, options);
     case "map":
-      return compareObjects(sortMap(a3), sortMap(b), options);
+      return compareObjects(sortMap(a3), sortMap(b2), options);
     case "set":
-      return compareObjects(sortSet(a3), sortSet(b), options);
+      return compareObjects(sortSet(a3), sortSet(b2), options);
     default:
-      return compareObjects(a3, b, options);
+      return compareObjects(a3, b2, options);
   }
 }
-function comparePrimitive(a3, b, options) {
+function comparePrimitive(a3, b2, options) {
   const aFormat = format(a3, FORMAT_OPTIONS);
-  const bFormat = format(b, FORMAT_OPTIONS);
+  const bFormat = format(b2, FORMAT_OPTIONS);
   return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
 }
 function sortMap(map2) {
@@ -4336,19 +4336,19 @@ function sortMap(map2) {
 function sortSet(set3) {
   return new Set(Array.from(set3.values()).sort());
 }
-function compareObjects(a3, b, options) {
+function compareObjects(a3, b2, options) {
   let difference;
   let hasThrown = false;
   try {
     const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a3, b, formatOptions, options);
+    difference = getObjectsDifference(a3, b2, formatOptions, options);
   } catch (e) {
     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, b, formatOptions, options);
+    difference = getObjectsDifference(a3, b2, formatOptions, options);
     if (difference !== noDiffMessage && !hasThrown) {
       difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
 
@@ -4365,17 +4365,17 @@ function getFormatOptions(formatOptions, options) {
     maxDepth: maxDepth != null ? maxDepth : formatOptions.maxDepth
   });
 }
-function getObjectsDifference(a3, b, formatOptions, options) {
+function getObjectsDifference(a3, b2, formatOptions, options) {
   const formatOptionsZeroIndent = __spreadProps(__spreadValues({}, formatOptions), {
     indent: 0
   });
   const aCompare = format(a3, formatOptionsZeroIndent);
-  const bCompare = format(b, formatOptionsZeroIndent);
+  const bCompare = format(b2, formatOptionsZeroIndent);
   if (aCompare === bCompare) {
     return getCommonMessage(NO_DIFF_MESSAGE, options);
   } else {
     const aDisplay = format(a3, formatOptions);
-    const bDisplay = format(b, formatOptions);
+    const bDisplay = format(b2, formatOptions);
     return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
   }
 }
@@ -4636,8 +4636,8 @@ var init_diff = __esm({
 });
 
 // node_modules/@vitest/utils/dist/error.js
-function isImmutable(v) {
-  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+function isImmutable(v2) {
+  return v2 && (v2[IS_COLLECTION_SYMBOL] || v2[IS_RECORD_SYMBOL]);
 }
 function getUnserializableMessage(err) {
   if (err instanceof Error) {
@@ -5226,87 +5226,75 @@ var require_js_tokens = __commonJS({
 });
 
 // node_modules/strip-literal/dist/index.mjs
-function stripLiteralJsTokens(code, options) {
-  var _a3, _b;
-  const FILL = (_a3 = options == null ? void 0 : options.fillChar) != null ? _a3 : " ";
-  const FILL_COMMENT = " ";
-  let result = "";
-  const filter = (_b = options == null ? void 0 : options.filter) != null ? _b : (() => 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;
+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;
     }
-    if (token.type === "MultiLineComment") {
-      result += token.value.replace(/[^\n]/g, FILL_COMMENT);
-      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 === "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 === "NoSubstitutionTemplate") {
-      const body = token.value.slice(1, -1);
-      if (filter(body)) {
-        result += `\`${body.replace(/[^\n]/g, FILL)}\``;
-        continue;
-      }
+  }
+  if (token.type === "NoSubstitutionTemplate") {
+    const body = token.value.slice(1, -1);
+    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 === "RegularExpressionLiteral") {
+    const body = token.value;
+    if (filter(body)) {
+      return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`);
     }
-    if (token.type === "TemplateHead") {
-      const body = token.value.slice(1, -2);
-      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 === "TemplateTail") {
-      const body = token.value.slice(0, -2);
-      if (filter(body)) {
-        result += `}${body.replace(/[^\n]/g, FILL)}\``;
-        continue;
-      }
+  }
+  if (token.type === "TemplateTail") {
+    const body = token.value.slice(0, -2);
+    if (filter(body)) {
+      return `}${body.replace(/[^\n]/g, fillChar)}\``;
     }
-    if (token.type === "TemplateMiddle") {
-      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)}\${`;
     }
-    result += token.value;
   }
+  return token.value;
+}
+function optionsWithDefaults(options) {
+  var _a3, _b;
   return {
-    result,
-    tokens
+    fillChar: (_a3 = options == null ? void 0 : options.fillChar) != null ? _a3 : " ",
+    filter: (_b = options == null ? void 0 : options.filter) != null ? _b : (() => true)
   };
 }
 function stripLiteral(code, options) {
-  return stripLiteralDetailed(code, options).result;
-}
-function stripLiteralDetailed(code, options) {
-  return stripLiteralJsTokens(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;
 }
-var import_js_tokens;
+var import_js_tokens, FILL_COMMENT;
 var init_dist3 = __esm({
   "node_modules/strip-literal/dist/index.mjs"() {
     "use strict";
     import_js_tokens = __toESM(require_js_tokens(), 1);
+    FILL_COMMENT = " ";
   }
 });
 
@@ -6140,8 +6128,8 @@ function formatTemplateString(cases, args) {
   const res = [];
   for (let i = 0; i < Math.floor(args.length / header.length); i++) {
     const oneCase = {};
-    for (let j = 0; j < header.length; j++) {
-      oneCase[header[j]] = args[i * header.length + j];
+    for (let j2 = 0; j2 < header.length; j2++) {
+      oneCase[header[j2]] = args[i * header.length + j2];
     }
     res.push(oneCase);
   }
@@ -6394,25 +6382,25 @@ function encodeUint8Array(bytes) {
   for (let i = 0; i < len; i += 3) {
     if (len === i + 1) {
       const a3 = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4;
+      const b2 = (bytes[i] & 3) << 4;
       base64 += table[a3];
-      base64 += table[b];
+      base64 += table[b2];
       base64 += "==";
     } else if (len === i + 2) {
       const a3 = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const b2 = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
       const c = (bytes[i + 1] & 15) << 2;
       base64 += table[a3];
-      base64 += table[b];
+      base64 += table[b2];
       base64 += table[c];
       base64 += "=";
     } else {
       const a3 = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const b2 = (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[b];
+      base64 += table[b2];
       base64 += table[c];
       base64 += table[d];
     }
@@ -6532,161 +6520,161 @@ var init_dist5 = __esm({
 });
 
 // node_modules/tinyspy/dist/index.js
-function assert2(condition, message) {
-  if (!condition)
-    throw new Error(message);
+function S(e, t) {
+  if (!e)
+    throw new Error(t);
 }
-function isType(type3, value) {
-  return typeof value === type3;
+function f2(e, t) {
+  return typeof t === e;
 }
-function isPromise(value) {
-  return value instanceof Promise;
+function w(e) {
+  return e instanceof Promise;
 }
-function define(obj, key, descriptor) {
-  Object.defineProperty(obj, key, descriptor);
+function u2(e, t, r2) {
+  Object.defineProperty(e, t, r2);
 }
-function defineValue(obj, key, value) {
-  define(obj, key, { value, configurable: true, writable: true });
+function l(e, t, r2) {
+  u2(e, t, { value: r2, configurable: true, writable: true });
 }
-function createInternalSpy(cb) {
-  assert2(
-    isType("function", cb) || isType("undefined", cb),
+function R(e) {
+  S(
+    f2("function", e) || f2("undefined", e),
     "cannot spy on a non-function value"
   );
-  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)
+  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)
       try {
-        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;
+        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;
   };
-  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;
+  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 isMockFunction(obj) {
-  return !!obj && obj._isMockFunction === true;
+function v(e) {
+  return !!e && e._isMockFunction === true;
 }
-function internalSpyOn(obj, methodName, mock) {
-  assert2(
-    !isType("undefined", obj),
+function M(e, t, r2) {
+  S(
+    !f2("undefined", e),
     "spyOn could not find an object to spy upon"
-  ), assert2(
-    isType("object", obj) || isType("function", obj),
+  ), S(
+    f2("object", e) || f2("function", e),
     "cannot spyOn on a primitive value"
   );
-  let [accessName, accessType] = (() => {
-    if (!isType("object", methodName))
-      return [methodName, "value"];
-    if ("getter" in methodName && "setter" in methodName)
+  let [s2, n] = (() => {
+    if (!f2("object", t))
+      return [t, "value"];
+    if ("getter" in t && "setter" in t)
       throw new Error("cannot spy on both getter and setter");
-    if ("getter" in methodName)
-      return [methodName.getter, "get"];
-    if ("setter" in methodName)
-      return [methodName.setter, "set"];
+    if ("getter" in t)
+      return [t.getter, "get"];
+    if ("setter" in t)
+      return [t.setter, "set"];
     throw new Error("specify getter or setter to spy on");
-  })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
-  assert2(
-    originalDescriptor || accessName in obj,
-    `${String(accessName)} does not exist`
+  })(), [d, o] = b(e, s2) || [];
+  S(
+    o || s2 in e,
+    `${String(s2)} does not exist`
   );
-  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 _a3 = originalDescriptor || {
+  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 _a3 = o || {
       configurable: true,
       writable: true
-    }, { value } = _a3, desc = __objRest(_a3, ["value"]);
-    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);
+    }, { value: F } = _a3, O = __objRest(_a3, ["value"]);
+    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);
   };
-  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;
-}
-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)
+  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;
+}
+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)
     ];
-    for (let prop of ownProperties)
-      descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
-    original = Object.getPrototypeOf(original);
+    for (let n of s2)
+      r2[n] || K.has(n) || (t.add(n), r2[n] = Object.getOwnPropertyDescriptor(e, n));
+    e = Object.getPrototypeOf(e);
   }
   return {
-    properties,
-    descriptors: descriptors2
+    properties: t,
+    descriptors: r2
   };
 }
-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);
+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);
   }
-  return mock;
+  return e;
 }
-function isSpyFunction(obj) {
-  return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
+function j(e) {
+  return v(e) && "getOriginal" in e[y];
 }
-var SYMBOL_STATE, spies, reset, defineState, getInternalState, getDescriptor, setPototype, ignoreProperties;
+var y, x, h2, k, T, b, P, K;
 var init_dist6 = __esm({
   "node_modules/tinyspy/dist/index.js"() {
     "use strict";
-    SYMBOL_STATE = Symbol.for("tinyspy:spy");
-    spies = /* @__PURE__ */ new Set();
-    reset = (state) => {
-      state.called = false, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
-    };
-    defineState = (spy2) => (define(spy2, SYMBOL_STATE, {
-      value: { reset: () => reset(spy2[SYMBOL_STATE]) }
-    }), spy2[SYMBOL_STATE]);
-    getInternalState = (spy2) => spy2[SYMBOL_STATE] || defineState(spy2);
-    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);
-      }
-    };
-    setPototype = (fn2, val) => {
-      val != null && typeof val == "function" && val.prototype != null && Object.setPrototypeOf(fn2.prototype, val.prototype);
-    };
-    ignoreProperties = /* @__PURE__ */ new Set([
+    y = Symbol.for("tinyspy:spy");
+    x = /* @__PURE__ */ new Set();
+    h2 = (e) => {
+      e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.resolves = [], e.next = [];
+    };
+    k = (e) => (u2(e, y, {
+      value: { reset: () => h2(e[y]) }
+    }), e[y]);
+    T = (e) => e[y] || k(e);
+    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);
+      }
+    };
+    P = (e, t) => {
+      t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
+    };
+    K = /* @__PURE__ */ new Set([
       "length",
       "name",
       "prototype"
@@ -6695,7 +6683,7 @@ var init_dist6 = __esm({
 });
 
 // node_modules/@vitest/spy/dist/index.js
-function isMockFunction2(fn2) {
+function isMockFunction(fn2) {
   return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
 }
 function spyOn(obj, method, accessType) {
@@ -6705,13 +6693,13 @@ function spyOn(obj, method, accessType) {
   };
   const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
   let state;
-  const descriptor = getDescriptor2(obj, method);
+  const descriptor = getDescriptor(obj, method);
   const fn2 = descriptor && descriptor[accessType || "value"];
-  if (isMockFunction2(fn2)) {
+  if (isMockFunction(fn2)) {
     state = fn2.mock._state();
   }
   try {
-    const stub = internalSpyOn(obj, objMethod);
+    const stub = M(obj, objMethod);
     const spy = enhanceSpy(stub);
     if (state) {
       spy.mock._state(state);
@@ -6732,7 +6720,7 @@ function enhanceSpy(spy) {
   let instances = [];
   let contexts = [];
   let invocations = [];
-  const state = getInternalState(spy);
+  const state = T(spy);
   const mockContext = {
     get calls() {
       return state.calls;
@@ -6830,18 +6818,18 @@ function enhanceSpy(spy) {
     implementation = fn2;
     state.willCall(mockCall);
     implementationChangedTemporarily = true;
-    const reset2 = () => {
+    const reset = () => {
       implementation = originalImplementation;
       implementationChangedTemporarily = false;
     };
     const result = cb();
     if (typeof result === "object" && result && typeof result.then === "function") {
       return result.then(() => {
-        reset2();
+        reset();
         return stub;
       });
     }
-    reset2();
+    reset();
     return stub;
   }
   stub.withImplementation = withImplementation;
@@ -6860,14 +6848,14 @@ function enhanceSpy(spy) {
   return stub;
 }
 function fn(implementation) {
-  const enhancedSpy = enhanceSpy(internalSpyOn({ spy: implementation || function() {
+  const enhancedSpy = enhanceSpy(M({ spy: implementation || function() {
   } }, "spy"));
   if (implementation) {
     enhancedSpy.mockImplementation(implementation);
   }
   return enhancedSpy;
 }
-function getDescriptor2(obj, method) {
+function getDescriptor(obj, method) {
   const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
   if (objDescriptor) {
     return objDescriptor;
@@ -7864,20 +7852,20 @@ function stringDistanceCapped(strA, strB, cap) {
     memo[i] = Array(strB.length + 1).fill(0);
     memo[i][0] = i;
   }
-  for (let j = 0; j < strB.length; j++) {
-    memo[0][j] = j;
+  for (let j2 = 0; j2 < strB.length; j2++) {
+    memo[0][j2] = j2;
   }
   for (let i = 1; i <= strA.length; i++) {
     let ch = strA.charCodeAt(i - 1);
-    for (let j = 1; j <= strB.length; j++) {
-      if (Math.abs(i - j) >= cap) {
-        memo[i][j] = cap;
+    for (let j2 = 1; j2 <= strB.length; j2++) {
+      if (Math.abs(i - j2) >= cap) {
+        memo[i][j2] = cap;
         continue;
       }
-      memo[i][j] = Math.min(
-        memo[i - 1][j] + 1,
-        memo[i][j - 1] + 1,
-        memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
+      memo[i][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)
       );
     }
   }
@@ -8016,8 +8004,8 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
     return newAssertion;
   }, "overwritingChainableMethodWrapper");
 }
-function compareByInspect(a3, b) {
-  return inspect22(a3) < inspect22(b) ? -1 : 1;
+function compareByInspect(a3, b2) {
+  return inspect22(a3) < inspect22(b2) ? -1 : 1;
 }
 function getOwnEnumerablePropertySymbols(obj) {
   if (typeof Object.getOwnPropertySymbols !== "function") return [];
@@ -8083,8 +8071,8 @@ function an(type3, msg) {
     );
   }
 }
-function SameValueZero(a3, b) {
-  return isNaN22(a3) && isNaN22(b) || a3 === b;
+function SameValueZero(a3, b2) {
+  return isNaN22(a3) && isNaN22(b2) || a3 === b2;
 }
 function includeChainingBehavior() {
   flag2(this, "contains", true);
@@ -8798,7 +8786,7 @@ function closeTo(expected, delta, msg) {
     );
   }
   new Assertion(expected, flagMsg, ssfi, true).is.numeric;
-  const abs = /* @__PURE__ */ __name((x) => x < /* @__PURE__ */ BigInt("0") ? -x : x, "abs");
+  const abs = /* @__PURE__ */ __name((x2) => x2 < /* @__PURE__ */ BigInt("0") ? -x2 : x2, "abs");
   const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
   this.assert(
     strip(abs(obj - expected)) <= delta,
@@ -9070,8 +9058,8 @@ function loadShould() {
   should2.not["throw"] = should2.not["Throw"];
   return should2;
 }
-function assert3(express, errmsg) {
-  let test22 = new Assertion(null, null, assert3, true);
+function assert2(express, errmsg) {
+  let test22 = new Assertion(null, null, assert2, true);
   test22.assert(express, errmsg, "[ negation message unavailable ]");
 }
 function use(fn2) {
@@ -9081,7 +9069,7 @@ function use(fn2) {
     util: utils_exports,
     config,
     expect,
-    assert: assert3,
+    assert: assert2,
     Assertion
   }, should_exports);
   if (!~used.indexOf(fn2)) {
@@ -10133,8 +10121,8 @@ var init_chai = __esm({
     __name(loadShould, "loadShould");
     should = loadShould;
     Should = loadShould;
-    __name(assert3, "assert");
-    assert3.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;
@@ -10147,17 +10135,17 @@ var init_chai = __esm({
           expected,
           operator
         },
-        assert3.fail
+        assert2.fail
       );
     };
-    assert3.isOk = function(val, msg) {
-      new Assertion(val, msg, assert3.isOk, true).is.ok;
+    assert2.isOk = function(val, msg) {
+      new Assertion(val, msg, assert2.isOk, true).is.ok;
     };
-    assert3.isNotOk = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotOk, true).is.not.ok;
+    assert2.isNotOk = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotOk, true).is.not.ok;
     };
-    assert3.equal = function(act, exp, msg) {
-      let test22 = new Assertion(act, msg, assert3.equal, true);
+    assert2.equal = function(act, exp, msg) {
+      let test22 = new Assertion(act, msg, assert2.equal, true);
       test22.assert(
         exp == flag(test22, "object"),
         "expected #{this} to equal #{exp}",
@@ -10167,8 +10155,8 @@ var init_chai = __esm({
         true
       );
     };
-    assert3.notEqual = function(act, exp, msg) {
-      let test22 = new Assertion(act, msg, assert3.notEqual, true);
+    assert2.notEqual = function(act, exp, msg) {
+      let test22 = new Assertion(act, msg, assert2.notEqual, true);
       test22.assert(
         exp != flag(test22, "object"),
         "expected #{this} to not equal #{exp}",
@@ -10178,370 +10166,370 @@ var init_chai = __esm({
         true
       );
     };
-    assert3.strictEqual = function(act, exp, msg) {
-      new Assertion(act, msg, assert3.strictEqual, true).to.equal(exp);
+    assert2.strictEqual = function(act, exp, msg) {
+      new Assertion(act, msg, assert2.strictEqual, true).to.equal(exp);
     };
-    assert3.notStrictEqual = function(act, exp, msg) {
-      new Assertion(act, msg, assert3.notStrictEqual, true).to.not.equal(exp);
+    assert2.notStrictEqual = function(act, exp, msg) {
+      new Assertion(act, msg, assert2.notStrictEqual, true).to.not.equal(exp);
     };
-    assert3.deepEqual = assert3.deepStrictEqual = function(act, exp, msg) {
-      new Assertion(act, msg, assert3.deepEqual, true).to.eql(exp);
+    assert2.deepEqual = assert2.deepStrictEqual = function(act, exp, msg) {
+      new Assertion(act, msg, assert2.deepEqual, true).to.eql(exp);
     };
-    assert3.notDeepEqual = function(act, exp, msg) {
-      new Assertion(act, msg, assert3.notDeepEqual, true).to.not.eql(exp);
+    assert2.notDeepEqual = function(act, exp, msg) {
+      new Assertion(act, msg, assert2.notDeepEqual, true).to.not.eql(exp);
     };
-    assert3.isAbove = function(val, abv, msg) {
-      new Assertion(val, msg, assert3.isAbove, true).to.be.above(abv);
+    assert2.isAbove = function(val, abv, msg) {
+      new Assertion(val, msg, assert2.isAbove, true).to.be.above(abv);
     };
-    assert3.isAtLeast = function(val, atlst, msg) {
-      new Assertion(val, msg, assert3.isAtLeast, true).to.be.least(atlst);
+    assert2.isAtLeast = function(val, atlst, msg) {
+      new Assertion(val, msg, assert2.isAtLeast, true).to.be.least(atlst);
     };
-    assert3.isBelow = function(val, blw, msg) {
-      new Assertion(val, msg, assert3.isBelow, true).to.be.below(blw);
+    assert2.isBelow = function(val, blw, msg) {
+      new Assertion(val, msg, assert2.isBelow, true).to.be.below(blw);
     };
-    assert3.isAtMost = function(val, atmst, msg) {
-      new Assertion(val, msg, assert3.isAtMost, true).to.be.most(atmst);
+    assert2.isAtMost = function(val, atmst, msg) {
+      new Assertion(val, msg, assert2.isAtMost, true).to.be.most(atmst);
     };
-    assert3.isTrue = function(val, msg) {
-      new Assertion(val, msg, assert3.isTrue, true).is["true"];
+    assert2.isTrue = function(val, msg) {
+      new Assertion(val, msg, assert2.isTrue, true).is["true"];
     };
-    assert3.isNotTrue = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotTrue, true).to.not.equal(true);
+    assert2.isNotTrue = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotTrue, true).to.not.equal(true);
     };
-    assert3.isFalse = function(val, msg) {
-      new Assertion(val, msg, assert3.isFalse, true).is["false"];
+    assert2.isFalse = function(val, msg) {
+      new Assertion(val, msg, assert2.isFalse, true).is["false"];
     };
-    assert3.isNotFalse = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotFalse, true).to.not.equal(false);
+    assert2.isNotFalse = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotFalse, true).to.not.equal(false);
     };
-    assert3.isNull = function(val, msg) {
-      new Assertion(val, msg, assert3.isNull, true).to.equal(null);
+    assert2.isNull = function(val, msg) {
+      new Assertion(val, msg, assert2.isNull, true).to.equal(null);
     };
-    assert3.isNotNull = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotNull, true).to.not.equal(null);
+    assert2.isNotNull = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotNull, true).to.not.equal(null);
     };
-    assert3.isNaN = function(val, msg) {
-      new Assertion(val, msg, assert3.isNaN, true).to.be.NaN;
+    assert2.isNaN = function(val, msg) {
+      new Assertion(val, msg, assert2.isNaN, true).to.be.NaN;
     };
-    assert3.isNotNaN = function(value, message) {
-      new Assertion(value, message, assert3.isNotNaN, true).not.to.be.NaN;
+    assert2.isNotNaN = function(value, message) {
+      new Assertion(value, message, assert2.isNotNaN, true).not.to.be.NaN;
     };
-    assert3.exists = function(val, msg) {
-      new Assertion(val, msg, assert3.exists, true).to.exist;
+    assert2.exists = function(val, msg) {
+      new Assertion(val, msg, assert2.exists, true).to.exist;
     };
-    assert3.notExists = function(val, msg) {
-      new Assertion(val, msg, assert3.notExists, true).to.not.exist;
+    assert2.notExists = function(val, msg) {
+      new Assertion(val, msg, assert2.notExists, true).to.not.exist;
     };
-    assert3.isUndefined = function(val, msg) {
-      new Assertion(val, msg, assert3.isUndefined, true).to.equal(void 0);
+    assert2.isUndefined = function(val, msg) {
+      new Assertion(val, msg, assert2.isUndefined, true).to.equal(void 0);
     };
-    assert3.isDefined = function(val, msg) {
-      new Assertion(val, msg, assert3.isDefined, true).to.not.equal(void 0);
+    assert2.isDefined = function(val, msg) {
+      new Assertion(val, msg, assert2.isDefined, true).to.not.equal(void 0);
     };
-    assert3.isCallable = function(value, message) {
-      new Assertion(value, message, assert3.isCallable, true).is.callable;
+    assert2.isCallable = function(value, message) {
+      new Assertion(value, message, assert2.isCallable, true).is.callable;
     };
-    assert3.isNotCallable = function(value, message) {
-      new Assertion(value, message, assert3.isNotCallable, true).is.not.callable;
+    assert2.isNotCallable = function(value, message) {
+      new Assertion(value, message, assert2.isNotCallable, true).is.not.callable;
     };
-    assert3.isObject = function(val, msg) {
-      new Assertion(val, msg, assert3.isObject, true).to.be.a("object");
+    assert2.isObject = function(val, msg) {
+      new Assertion(val, msg, assert2.isObject, true).to.be.a("object");
     };
-    assert3.isNotObject = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotObject, true).to.not.be.a("object");
+    assert2.isNotObject = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotObject, true).to.not.be.a("object");
     };
-    assert3.isArray = function(val, msg) {
-      new Assertion(val, msg, assert3.isArray, true).to.be.an("array");
+    assert2.isArray = function(val, msg) {
+      new Assertion(val, msg, assert2.isArray, true).to.be.an("array");
     };
-    assert3.isNotArray = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotArray, true).to.not.be.an("array");
+    assert2.isNotArray = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotArray, true).to.not.be.an("array");
     };
-    assert3.isString = function(val, msg) {
-      new Assertion(val, msg, assert3.isString, true).to.be.a("string");
+    assert2.isString = function(val, msg) {
+      new Assertion(val, msg, assert2.isString, true).to.be.a("string");
     };
-    assert3.isNotString = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotString, true).to.not.be.a("string");
+    assert2.isNotString = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotString, true).to.not.be.a("string");
     };
-    assert3.isNumber = function(val, msg) {
-      new Assertion(val, msg, assert3.isNumber, true).to.be.a("number");
+    assert2.isNumber = function(val, msg) {
+      new Assertion(val, msg, assert2.isNumber, true).to.be.a("number");
     };
-    assert3.isNotNumber = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotNumber, true).to.not.be.a("number");
+    assert2.isNotNumber = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotNumber, true).to.not.be.a("number");
     };
-    assert3.isNumeric = function(val, msg) {
-      new Assertion(val, msg, assert3.isNumeric, true).is.numeric;
+    assert2.isNumeric = function(val, msg) {
+      new Assertion(val, msg, assert2.isNumeric, true).is.numeric;
     };
-    assert3.isNotNumeric = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotNumeric, true).is.not.numeric;
+    assert2.isNotNumeric = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotNumeric, true).is.not.numeric;
     };
-    assert3.isFinite = function(val, msg) {
-      new Assertion(val, msg, assert3.isFinite, true).to.be.finite;
+    assert2.isFinite = function(val, msg) {
+      new Assertion(val, msg, assert2.isFinite, true).to.be.finite;
     };
-    assert3.isBoolean = function(val, msg) {
-      new Assertion(val, msg, assert3.isBoolean, true).to.be.a("boolean");
+    assert2.isBoolean = function(val, msg) {
+      new Assertion(val, msg, assert2.isBoolean, true).to.be.a("boolean");
     };
-    assert3.isNotBoolean = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotBoolean, true).to.not.be.a("boolean");
+    assert2.isNotBoolean = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotBoolean, true).to.not.be.a("boolean");
     };
-    assert3.typeOf = function(val, type3, msg) {
-      new Assertion(val, msg, assert3.typeOf, true).to.be.a(type3);
+    assert2.typeOf = function(val, type3, msg) {
+      new Assertion(val, msg, assert2.typeOf, true).to.be.a(type3);
     };
-    assert3.notTypeOf = function(value, type3, message) {
-      new Assertion(value, message, assert3.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);
     };
-    assert3.instanceOf = function(val, type3, msg) {
-      new Assertion(val, msg, assert3.instanceOf, true).to.be.instanceOf(type3);
+    assert2.instanceOf = function(val, type3, msg) {
+      new Assertion(val, msg, assert2.instanceOf, true).to.be.instanceOf(type3);
     };
-    assert3.notInstanceOf = function(val, type3, msg) {
-      new Assertion(val, msg, assert3.notInstanceOf, true).to.not.be.instanceOf(
+    assert2.notInstanceOf = function(val, type3, msg) {
+      new Assertion(val, msg, assert2.notInstanceOf, true).to.not.be.instanceOf(
         type3
       );
     };
-    assert3.include = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.include, true).include(inc);
+    assert2.include = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.include, true).include(inc);
     };
-    assert3.notInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.notInclude, true).not.include(inc);
+    assert2.notInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.notInclude, true).not.include(inc);
     };
-    assert3.deepInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.deepInclude, true).deep.include(inc);
+    assert2.deepInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.deepInclude, true).deep.include(inc);
     };
-    assert3.notDeepInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.notDeepInclude, true).not.deep.include(inc);
+    assert2.notDeepInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.notDeepInclude, true).not.deep.include(inc);
     };
-    assert3.nestedInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.nestedInclude, true).nested.include(inc);
+    assert2.nestedInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.nestedInclude, true).nested.include(inc);
     };
-    assert3.notNestedInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.notNestedInclude, true).not.nested.include(
+    assert2.notNestedInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.notNestedInclude, true).not.nested.include(
         inc
       );
     };
-    assert3.deepNestedInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.deepNestedInclude, true).deep.nested.include(
+    assert2.deepNestedInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.deepNestedInclude, true).deep.nested.include(
         inc
       );
     };
-    assert3.notDeepNestedInclude = function(exp, inc, msg) {
+    assert2.notDeepNestedInclude = function(exp, inc, msg) {
       new Assertion(
         exp,
         msg,
-        assert3.notDeepNestedInclude,
+        assert2.notDeepNestedInclude,
         true
       ).not.deep.nested.include(inc);
     };
-    assert3.ownInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.ownInclude, true).own.include(inc);
+    assert2.ownInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.ownInclude, true).own.include(inc);
     };
-    assert3.notOwnInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.notOwnInclude, true).not.own.include(inc);
+    assert2.notOwnInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.notOwnInclude, true).not.own.include(inc);
     };
-    assert3.deepOwnInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.deepOwnInclude, true).deep.own.include(inc);
+    assert2.deepOwnInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.deepOwnInclude, true).deep.own.include(inc);
     };
-    assert3.notDeepOwnInclude = function(exp, inc, msg) {
-      new Assertion(exp, msg, assert3.notDeepOwnInclude, true).not.deep.own.include(
+    assert2.notDeepOwnInclude = function(exp, inc, msg) {
+      new Assertion(exp, msg, assert2.notDeepOwnInclude, true).not.deep.own.include(
         inc
       );
     };
-    assert3.match = function(exp, re, msg) {
-      new Assertion(exp, msg, assert3.match, true).to.match(re);
+    assert2.match = function(exp, re, msg) {
+      new Assertion(exp, msg, assert2.match, true).to.match(re);
     };
-    assert3.notMatch = function(exp, re, msg) {
-      new Assertion(exp, msg, assert3.notMatch, true).to.not.match(re);
+    assert2.notMatch = function(exp, re, msg) {
+      new Assertion(exp, msg, assert2.notMatch, true).to.not.match(re);
     };
-    assert3.property = function(obj, prop, msg) {
-      new Assertion(obj, msg, assert3.property, true).to.have.property(prop);
+    assert2.property = function(obj, prop, msg) {
+      new Assertion(obj, msg, assert2.property, true).to.have.property(prop);
     };
-    assert3.notProperty = function(obj, prop, msg) {
-      new Assertion(obj, msg, assert3.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);
     };
-    assert3.propertyVal = function(obj, prop, val, msg) {
-      new Assertion(obj, msg, assert3.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);
     };
-    assert3.notPropertyVal = function(obj, prop, val, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.deepPropertyVal = function(obj, prop, val, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.notDeepPropertyVal = function(obj, prop, val, msg) {
+    assert2.notDeepPropertyVal = function(obj, prop, val, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notDeepPropertyVal,
+        assert2.notDeepPropertyVal,
         true
       ).to.not.have.deep.property(prop, val);
     };
-    assert3.ownProperty = function(obj, prop, msg) {
-      new Assertion(obj, msg, assert3.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);
     };
-    assert3.notOwnProperty = function(obj, prop, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.ownPropertyVal = function(obj, prop, value, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.notOwnPropertyVal = function(obj, prop, value, msg) {
+    assert2.notOwnPropertyVal = function(obj, prop, value, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notOwnPropertyVal,
+        assert2.notOwnPropertyVal,
         true
       ).to.not.have.own.property(prop, value);
     };
-    assert3.deepOwnPropertyVal = function(obj, prop, value, msg) {
+    assert2.deepOwnPropertyVal = function(obj, prop, value, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.deepOwnPropertyVal,
+        assert2.deepOwnPropertyVal,
         true
       ).to.have.deep.own.property(prop, value);
     };
-    assert3.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+    assert2.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notDeepOwnPropertyVal,
+        assert2.notDeepOwnPropertyVal,
         true
       ).to.not.have.deep.own.property(prop, value);
     };
-    assert3.nestedProperty = function(obj, prop, msg) {
-      new Assertion(obj, msg, assert3.nestedProperty, true).to.have.nested.property(
+    assert2.nestedProperty = function(obj, prop, msg) {
+      new Assertion(obj, msg, assert2.nestedProperty, true).to.have.nested.property(
         prop
       );
     };
-    assert3.notNestedProperty = function(obj, prop, msg) {
+    assert2.notNestedProperty = function(obj, prop, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notNestedProperty,
+        assert2.notNestedProperty,
         true
       ).to.not.have.nested.property(prop);
     };
-    assert3.nestedPropertyVal = function(obj, prop, val, msg) {
+    assert2.nestedPropertyVal = function(obj, prop, val, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.nestedPropertyVal,
+        assert2.nestedPropertyVal,
         true
       ).to.have.nested.property(prop, val);
     };
-    assert3.notNestedPropertyVal = function(obj, prop, val, msg) {
+    assert2.notNestedPropertyVal = function(obj, prop, val, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notNestedPropertyVal,
+        assert2.notNestedPropertyVal,
         true
       ).to.not.have.nested.property(prop, val);
     };
-    assert3.deepNestedPropertyVal = function(obj, prop, val, msg) {
+    assert2.deepNestedPropertyVal = function(obj, prop, val, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.deepNestedPropertyVal,
+        assert2.deepNestedPropertyVal,
         true
       ).to.have.deep.nested.property(prop, val);
     };
-    assert3.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+    assert2.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.notDeepNestedPropertyVal,
+        assert2.notDeepNestedPropertyVal,
         true
       ).to.not.have.deep.nested.property(prop, val);
     };
-    assert3.lengthOf = function(exp, len, msg) {
-      new Assertion(exp, msg, assert3.lengthOf, true).to.have.lengthOf(len);
+    assert2.lengthOf = function(exp, len, msg) {
+      new Assertion(exp, msg, assert2.lengthOf, true).to.have.lengthOf(len);
     };
-    assert3.hasAnyKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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);
     };
-    assert3.hasAllKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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);
     };
-    assert3.containsAllKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.containsAllKeys, true).to.contain.all.keys(
+    assert2.containsAllKeys = function(obj, keys2, msg) {
+      new Assertion(obj, msg, assert2.containsAllKeys, true).to.contain.all.keys(
         keys2
       );
     };
-    assert3.doesNotHaveAnyKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.doesNotHaveAllKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.hasAnyDeepKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.hasAllDeepKeys = function(obj, keys2, msg) {
-      new Assertion(obj, msg, assert3.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
       );
     };
-    assert3.containsAllDeepKeys = function(obj, keys2, msg) {
+    assert2.containsAllDeepKeys = function(obj, keys2, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.containsAllDeepKeys,
+        assert2.containsAllDeepKeys,
         true
       ).to.contain.all.deep.keys(keys2);
     };
-    assert3.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
+    assert2.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.doesNotHaveAnyDeepKeys,
+        assert2.doesNotHaveAnyDeepKeys,
         true
       ).to.not.have.any.deep.keys(keys2);
     };
-    assert3.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
+    assert2.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
       new Assertion(
         obj,
         msg,
-        assert3.doesNotHaveAllDeepKeys,
+        assert2.doesNotHaveAllDeepKeys,
         true
       ).to.not.have.all.deep.keys(keys2);
     };
-    assert3.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, assert3.throws, true).to.throw(
+      let assertErr = new Assertion(fn2, msg, assert2.throws, true).to.throw(
         errorLike,
         errMsgMatcher
       );
       return flag(assertErr, "object");
     };
-    assert3.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, assert3.doesNotThrow, true).to.not.throw(
+      new Assertion(fn2, message, assert2.doesNotThrow, true).to.not.throw(
         errorLike,
         errMsgMatcher
       );
     };
-    assert3.operator = function(val, operator, val2, msg) {
+    assert2.operator = function(val, operator, val2, msg) {
       let ok;
       switch (operator) {
         case "==":
@@ -10573,162 +10561,162 @@ var init_chai = __esm({
           throw new AssertionError(
             msg + 'Invalid operator "' + operator + '"',
             void 0,
-            assert3.operator
+            assert2.operator
           );
       }
-      let test22 = new Assertion(ok, msg, assert3.operator, true);
+      let 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)
       );
     };
-    assert3.closeTo = function(act, exp, delta, msg) {
-      new Assertion(act, msg, assert3.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);
     };
-    assert3.approximately = function(act, exp, delta, msg) {
-      new Assertion(act, msg, assert3.approximately, true).to.be.approximately(
+    assert2.approximately = function(act, exp, delta, msg) {
+      new Assertion(act, msg, assert2.approximately, true).to.be.approximately(
         exp,
         delta
       );
     };
-    assert3.sameMembers = function(set1, set22, msg) {
-      new Assertion(set1, msg, assert3.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);
     };
-    assert3.notSameMembers = function(set1, set22, msg) {
+    assert2.notSameMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.notSameMembers,
+        assert2.notSameMembers,
         true
       ).to.not.have.same.members(set22);
     };
-    assert3.sameDeepMembers = function(set1, set22, msg) {
+    assert2.sameDeepMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.sameDeepMembers,
+        assert2.sameDeepMembers,
         true
       ).to.have.same.deep.members(set22);
     };
-    assert3.notSameDeepMembers = function(set1, set22, msg) {
+    assert2.notSameDeepMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.notSameDeepMembers,
+        assert2.notSameDeepMembers,
         true
       ).to.not.have.same.deep.members(set22);
     };
-    assert3.sameOrderedMembers = function(set1, set22, msg) {
+    assert2.sameOrderedMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.sameOrderedMembers,
+        assert2.sameOrderedMembers,
         true
       ).to.have.same.ordered.members(set22);
     };
-    assert3.notSameOrderedMembers = function(set1, set22, msg) {
+    assert2.notSameOrderedMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.notSameOrderedMembers,
+        assert2.notSameOrderedMembers,
         true
       ).to.not.have.same.ordered.members(set22);
     };
-    assert3.sameDeepOrderedMembers = function(set1, set22, msg) {
+    assert2.sameDeepOrderedMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.sameDeepOrderedMembers,
+        assert2.sameDeepOrderedMembers,
         true
       ).to.have.same.deep.ordered.members(set22);
     };
-    assert3.notSameDeepOrderedMembers = function(set1, set22, msg) {
+    assert2.notSameDeepOrderedMembers = function(set1, set22, msg) {
       new Assertion(
         set1,
         msg,
-        assert3.notSameDeepOrderedMembers,
+        assert2.notSameDeepOrderedMembers,
         true
       ).to.not.have.same.deep.ordered.members(set22);
     };
-    assert3.includeMembers = function(superset, subset, msg) {
-      new Assertion(superset, msg, assert3.includeMembers, true).to.include.members(
+    assert2.includeMembers = function(superset, subset, msg) {
+      new Assertion(superset, msg, assert2.includeMembers, true).to.include.members(
         subset
       );
     };
-    assert3.notIncludeMembers = function(superset, subset, msg) {
+    assert2.notIncludeMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.notIncludeMembers,
+        assert2.notIncludeMembers,
         true
       ).to.not.include.members(subset);
     };
-    assert3.includeDeepMembers = function(superset, subset, msg) {
+    assert2.includeDeepMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.includeDeepMembers,
+        assert2.includeDeepMembers,
         true
       ).to.include.deep.members(subset);
     };
-    assert3.notIncludeDeepMembers = function(superset, subset, msg) {
+    assert2.notIncludeDeepMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.notIncludeDeepMembers,
+        assert2.notIncludeDeepMembers,
         true
       ).to.not.include.deep.members(subset);
     };
-    assert3.includeOrderedMembers = function(superset, subset, msg) {
+    assert2.includeOrderedMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.includeOrderedMembers,
+        assert2.includeOrderedMembers,
         true
       ).to.include.ordered.members(subset);
     };
-    assert3.notIncludeOrderedMembers = function(superset, subset, msg) {
+    assert2.notIncludeOrderedMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.notIncludeOrderedMembers,
+        assert2.notIncludeOrderedMembers,
         true
       ).to.not.include.ordered.members(subset);
     };
-    assert3.includeDeepOrderedMembers = function(superset, subset, msg) {
+    assert2.includeDeepOrderedMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.includeDeepOrderedMembers,
+        assert2.includeDeepOrderedMembers,
         true
       ).to.include.deep.ordered.members(subset);
     };
-    assert3.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+    assert2.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
       new Assertion(
         superset,
         msg,
-        assert3.notIncludeDeepOrderedMembers,
+        assert2.notIncludeDeepOrderedMembers,
         true
       ).to.not.include.deep.ordered.members(subset);
     };
-    assert3.oneOf = function(inList, list, msg) {
-      new Assertion(inList, msg, assert3.oneOf, true).to.be.oneOf(list);
+    assert2.oneOf = function(inList, list, msg) {
+      new Assertion(inList, msg, assert2.oneOf, true).to.be.oneOf(list);
     };
-    assert3.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, assert3.isIterable);
+        throw new AssertionError(msg, void 0, assert2.isIterable);
       }
     };
-    assert3.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, assert3.changes, true).to.change(obj, prop);
+      new Assertion(fn2, msg, assert2.changes, true).to.change(obj, prop);
     };
-    assert3.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;
         delta = prop;
@@ -10737,19 +10725,19 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.changesBy, true).to.change(obj, prop).by(delta);
+      new Assertion(fn2, msg, assert2.changesBy, true).to.change(obj, prop).by(delta);
     };
-    assert3.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, assert3.doesNotChange, true).to.not.change(
+      return new Assertion(fn2, msg, assert2.doesNotChange, true).to.not.change(
         obj,
         prop
       );
     };
-    assert3.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;
         delta = prop;
@@ -10758,16 +10746,16 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.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);
     };
-    assert3.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, assert3.increases, true).to.increase(obj, prop);
+      return new Assertion(fn2, msg, assert2.increases, true).to.increase(obj, prop);
     };
-    assert3.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;
         delta = prop;
@@ -10776,19 +10764,19 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.increasesBy, true).to.increase(obj, prop).by(delta);
+      new Assertion(fn2, msg, assert2.increasesBy, true).to.increase(obj, prop).by(delta);
     };
-    assert3.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, assert3.doesNotIncrease, true).to.not.increase(
+      return new Assertion(fn2, msg, assert2.doesNotIncrease, true).to.not.increase(
         obj,
         prop
       );
     };
-    assert3.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;
         delta = prop;
@@ -10797,16 +10785,16 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.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);
     };
-    assert3.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, assert3.decreases, true).to.decrease(obj, prop);
+      return new Assertion(fn2, msg, assert2.decreases, true).to.decrease(obj, prop);
     };
-    assert3.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;
         delta = prop;
@@ -10815,19 +10803,19 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.decreasesBy, true).to.decrease(obj, prop).by(delta);
+      new Assertion(fn2, msg, assert2.decreasesBy, true).to.decrease(obj, prop).by(delta);
     };
-    assert3.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, assert3.doesNotDecrease, true).to.not.decrease(
+      return new Assertion(fn2, msg, assert2.doesNotDecrease, true).to.not.decrease(
         obj,
         prop
       );
     };
-    assert3.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;
         delta = prop;
@@ -10836,9 +10824,9 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      return new Assertion(fn2, msg, assert3.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+      return new Assertion(fn2, msg, assert2.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
     };
-    assert3.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;
         delta = prop;
@@ -10847,41 +10835,41 @@ var init_chai = __esm({
         delta = prop;
         prop = null;
       }
-      new Assertion(fn2, msg, assert3.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);
     };
-    assert3.ifError = function(val) {
+    assert2.ifError = function(val) {
       if (val) {
         throw val;
       }
     };
-    assert3.isExtensible = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isExtensible, true).to.be.extensible;
+    assert2.isExtensible = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isExtensible, true).to.be.extensible;
     };
-    assert3.isNotExtensible = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isNotExtensible, true).to.not.be.extensible;
+    assert2.isNotExtensible = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isNotExtensible, true).to.not.be.extensible;
     };
-    assert3.isSealed = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isSealed, true).to.be.sealed;
+    assert2.isSealed = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isSealed, true).to.be.sealed;
     };
-    assert3.isNotSealed = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isNotSealed, true).to.not.be.sealed;
+    assert2.isNotSealed = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isNotSealed, true).to.not.be.sealed;
     };
-    assert3.isFrozen = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isFrozen, true).to.be.frozen;
+    assert2.isFrozen = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isFrozen, true).to.be.frozen;
     };
-    assert3.isNotFrozen = function(obj, msg) {
-      new Assertion(obj, msg, assert3.isNotFrozen, true).to.not.be.frozen;
+    assert2.isNotFrozen = function(obj, msg) {
+      new Assertion(obj, msg, assert2.isNotFrozen, true).to.not.be.frozen;
     };
-    assert3.isEmpty = function(val, msg) {
-      new Assertion(val, msg, assert3.isEmpty, true).to.be.empty;
+    assert2.isEmpty = function(val, msg) {
+      new Assertion(val, msg, assert2.isEmpty, true).to.be.empty;
     };
-    assert3.isNotEmpty = function(val, msg) {
-      new Assertion(val, msg, assert3.isNotEmpty, true).to.not.be.empty;
+    assert2.isNotEmpty = function(val, msg) {
+      new Assertion(val, msg, assert2.isNotEmpty, true).to.not.be.empty;
     };
-    assert3.containsSubset = function(val, exp, msg) {
+    assert2.containsSubset = function(val, exp, msg) {
       new Assertion(val, msg).to.containSubset(exp);
     };
-    assert3.doesNotContainSubset = function(val, exp, msg) {
+    assert2.doesNotContainSubset = function(val, exp, msg) {
       new Assertion(val, msg).to.not.containSubset(exp);
     };
     aliases = [
@@ -10902,7 +10890,7 @@ var init_chai = __esm({
       ["containsSubset", "containSubset"]
     ];
     for (const [name, as] of aliases) {
-      assert3[as] = assert3[name];
+      assert2[as] = assert2[name];
     }
     used = [];
     __name(use, "use");
@@ -10989,70 +10977,70 @@ function addCustomEqualityTesters(newTesters) {
 function getCustomEqualityTesters() {
   return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
 }
-function equals(a3, b, customTesters, strictCheck) {
+function equals(a3, b2, customTesters, strictCheck) {
   customTesters = customTesters || [];
-  return eq(a3, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+  return eq(a3, b2, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
 }
 function isAsymmetric(obj) {
   return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
 }
-function asymmetricMatch(a3, b) {
+function asymmetricMatch(a3, b2) {
   const asymmetricA = isAsymmetric(a3);
-  const asymmetricB = isAsymmetric(b);
+  const asymmetricB = isAsymmetric(b2);
   if (asymmetricA && asymmetricB) {
     return void 0;
   }
   if (asymmetricA) {
-    return a3.asymmetricMatch(b);
+    return a3.asymmetricMatch(b2);
   }
   if (asymmetricB) {
-    return b.asymmetricMatch(a3);
+    return b2.asymmetricMatch(a3);
   }
 }
-function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
+function eq(a3, b2, aStack, bStack, customTesters, hasKey2) {
   let result = true;
-  const asymmetricResult = asymmetricMatch(a3, b);
+  const asymmetricResult = asymmetricMatch(a3, b2);
   if (asymmetricResult !== void 0) {
     return asymmetricResult;
   }
   const testerContext = { equals };
   for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i].call(testerContext, a3, b, customTesters);
+    const customTesterResult = customTesters[i].call(testerContext, a3, b2, customTesters);
     if (customTesterResult !== void 0) {
       return customTesterResult;
     }
   }
-  if (typeof URL === "function" && a3 instanceof URL && b instanceof URL) {
-    return a3.href === b.href;
+  if (typeof URL === "function" && a3 instanceof URL && b2 instanceof URL) {
+    return a3.href === b2.href;
   }
-  if (Object.is(a3, b)) {
+  if (Object.is(a3, b2)) {
     return true;
   }
-  if (a3 === null || b === null) {
-    return a3 === b;
+  if (a3 === null || b2 === null) {
+    return a3 === b2;
   }
   const className = Object.prototype.toString.call(a3);
-  if (className !== Object.prototype.toString.call(b)) {
+  if (className !== Object.prototype.toString.call(b2)) {
     return false;
   }
   switch (className) {
     case "[object Boolean]":
     case "[object String]":
     case "[object Number]":
-      if (typeof a3 !== typeof b) {
+      if (typeof a3 !== typeof b2) {
         return false;
-      } else if (typeof a3 !== "object" && typeof b !== "object") {
-        return Object.is(a3, b);
+      } else if (typeof a3 !== "object" && typeof b2 !== "object") {
+        return Object.is(a3, b2);
       } else {
-        return Object.is(a3.valueOf(), b.valueOf());
+        return Object.is(a3.valueOf(), b2.valueOf());
       }
     case "[object Date]": {
       const numA = +a3;
-      const numB = +b;
+      const numB = +b2;
       return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
     }
     case "[object RegExp]":
-      return a3.source === b.source && a3.flags === b.flags;
+      return a3.source === b2.source && a3.flags === b2.flags;
     case "[object Temporal.Instant]":
     case "[object Temporal.ZonedDateTime]":
     case "[object Temporal.PlainDateTime]":
@@ -11060,32 +11048,32 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
     case "[object Temporal.PlainTime]":
     case "[object Temporal.PlainYearMonth]":
     case "[object Temporal.PlainMonthDay]":
-      return a3.equals(b);
+      return a3.equals(b2);
     case "[object Temporal.Duration]":
-      return a3.toString() === b.toString();
+      return a3.toString() === b2.toString();
   }
-  if (typeof a3 !== "object" || typeof b !== "object") {
+  if (typeof a3 !== "object" || typeof b2 !== "object") {
     return false;
   }
-  if (isDomNode(a3) && isDomNode(b)) {
-    return a3.isEqualNode(b);
+  if (isDomNode(a3) && isDomNode(b2)) {
+    return a3.isEqualNode(b2);
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a3) {
-      return bStack[length] === b;
-    } else if (bStack[length] === b) {
+      return bStack[length] === b2;
+    } else if (bStack[length] === b2) {
       return false;
     }
   }
   aStack.push(a3);
-  bStack.push(b);
-  if (className === "[object Array]" && a3.length !== b.length) {
+  bStack.push(b2);
+  if (className === "[object Array]" && a3.length !== b2.length) {
     return false;
   }
-  if (a3 instanceof Error && b instanceof Error) {
+  if (a3 instanceof Error && b2 instanceof Error) {
     try {
-      return isErrorEqual(a3, b, aStack, bStack, customTesters, hasKey2);
+      return isErrorEqual(a3, b2, aStack, bStack, customTesters, hasKey2);
     } finally {
       aStack.pop();
       bStack.pop();
@@ -11094,12 +11082,12 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
   const aKeys = keys(a3, hasKey2);
   let key;
   let size = aKeys.length;
-  if (keys(b, hasKey2).length !== size) {
+  if (keys(b2, hasKey2).length !== size) {
     return false;
   }
   while (size--) {
     key = aKeys[size];
-    result = hasKey2(b, key) && eq(a3[key], b[key], aStack, bStack, customTesters, hasKey2);
+    result = hasKey2(b2, key) && eq(a3[key], b2[key], aStack, bStack, customTesters, hasKey2);
     if (!result) {
       return false;
     }
@@ -11108,15 +11096,15 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
   bStack.pop();
   return result;
 }
-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));
+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));
   }
-  if (a3 instanceof AggregateError && b instanceof AggregateError) {
-    result && (result = eq(a3.errors, b.errors, aStack, bStack, customTesters, hasKey2));
+  if (a3 instanceof AggregateError && b2 instanceof AggregateError) {
+    result && (result = eq(a3.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
   }
-  result && (result = eq(__spreadValues({}, a3), __spreadValues({}, b), aStack, bStack, customTesters, hasKey2));
+  result && (result = eq(__spreadValues({}, a3), __spreadValues({}, b2), aStack, bStack, customTesters, hasKey2));
   return result;
 }
 function keys(obj, hasKey2) {
@@ -11164,34 +11152,34 @@ function isImmutableRecord(source) {
 function hasIterator(object2) {
   return !!(object2 != null && object2[IteratorSymbol]);
 }
-function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
-  if (typeof a3 !== "object" || typeof b !== "object" || Array.isArray(a3) || Array.isArray(b) || !hasIterator(a3) || !hasIterator(b)) {
+function iterableEquality(a3, b2, customTesters = [], aStack = [], bStack = []) {
+  if (typeof a3 !== "object" || typeof b2 !== "object" || Array.isArray(a3) || Array.isArray(b2) || !hasIterator(a3) || !hasIterator(b2)) {
     return void 0;
   }
-  if (a3.constructor !== b.constructor) {
+  if (a3.constructor !== b2.constructor) {
     return false;
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a3) {
-      return bStack[length] === b;
+      return bStack[length] === b2;
     }
   }
   aStack.push(a3);
-  bStack.push(b);
+  bStack.push(b2);
   const filteredCustomTesters = [...customTesters.filter((t) => t !== iterableEquality), iterableEqualityWithStack];
-  function iterableEqualityWithStack(a4, b2) {
-    return iterableEquality(a4, b2, [...customTesters], [...aStack], [...bStack]);
+  function iterableEqualityWithStack(a4, b3) {
+    return iterableEquality(a4, b3, [...customTesters], [...aStack], [...bStack]);
   }
   if (a3.size !== void 0) {
-    if (a3.size !== b.size) {
+    if (a3.size !== b2.size) {
       return false;
     } else if (isA("Set", a3) || isImmutableUnorderedSet(a3)) {
       let allFound = true;
       for (const aValue of a3) {
-        if (!b.has(aValue)) {
+        if (!b2.has(aValue)) {
           let has = false;
-          for (const bValue of b) {
+          for (const bValue of b2) {
             const isEqual = equals(aValue, bValue, filteredCustomTesters);
             if (isEqual === true) {
               has = true;
@@ -11209,9 +11197,9 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
     } else if (isA("Map", a3) || isImmutableUnorderedKeyed(a3)) {
       let allFound = true;
       for (const aEntry of a3) {
-        if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), filteredCustomTesters)) {
+        if (!b2.has(aEntry[0]) || !equals(aEntry[1], b2.get(aEntry[0]), filteredCustomTesters)) {
           let has = false;
-          for (const bEntry of b) {
+          for (const bEntry of b2) {
             const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
             let matchedValue = false;
             if (matchedKey === true) {
@@ -11232,7 +11220,7 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
       return allFound;
     }
   }
-  const bIterator = b[IteratorSymbol]();
+  const bIterator = b2[IteratorSymbol]();
   for (const aValue of a3) {
     const nextB = bIterator.next();
     if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) {
@@ -11244,7 +11232,7 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
   }
   if (!isImmutableList(a3) && !isImmutableOrderedKeyed(a3) && !isImmutableOrderedSet(a3) && !isImmutableRecord(a3)) {
     const aEntries = Object.entries(a3);
-    const bEntries = Object.entries(b);
+    const bEntries = Object.entries(b2);
     if (!equals(aEntries, bEntries, filteredCustomTesters)) {
       return false;
     }
@@ -11283,22 +11271,22 @@ function subsetEquality(object2, subset, customTesters = []) {
   };
   return subsetEqualityWithContext()(object2, subset);
 }
-function typeEquality(a3, b) {
-  if (a3 == null || b == null || a3.constructor === b.constructor) {
+function typeEquality(a3, b2) {
+  if (a3 == null || b2 == null || a3.constructor === b2.constructor) {
     return void 0;
   }
   return false;
 }
-function arrayBufferEquality(a3, b) {
+function arrayBufferEquality(a3, b2) {
   let dataViewA = a3;
-  let dataViewB = b;
-  if (!(a3 instanceof DataView && b instanceof DataView)) {
-    if (!(a3 instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
+  let dataViewB = b2;
+  if (!(a3 instanceof DataView && b2 instanceof DataView)) {
+    if (!(a3 instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) {
       return void 0;
     }
     try {
       dataViewA = new DataView(a3);
-      dataViewB = new DataView(b);
+      dataViewB = new DataView(b2);
     } catch (e) {
       return void 0;
     }
@@ -11313,14 +11301,14 @@ function arrayBufferEquality(a3, b) {
   }
   return true;
 }
-function sparseArrayEquality(a3, b, customTesters = []) {
-  if (!Array.isArray(a3) || !Array.isArray(b)) {
+function sparseArrayEquality(a3, b2, customTesters = []) {
+  if (!Array.isArray(a3) || !Array.isArray(b2)) {
     return void 0;
   }
   const aKeys = Object.keys(a3);
-  const bKeys = Object.keys(b);
+  const bKeys = Object.keys(b2);
   const filteredCustomTesters = customTesters.filter((t) => t !== sparseArrayEquality);
-  return equals(a3, b, filteredCustomTesters, true) && equals(aKeys, bKeys);
+  return equals(a3, b2, filteredCustomTesters, true) && equals(aKeys, bKeys);
 }
 function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
@@ -11490,15 +11478,15 @@ function wrapAssertion(utils, name, fn2) {
   };
 }
 function ordinalOf(i) {
-  const j = i % 10;
-  const k = i % 100;
-  if (j === 1 && k !== 11) {
+  const j2 = i % 10;
+  const k2 = i % 100;
+  if (j2 === 1 && k2 !== 11) {
     return `${i}st`;
   }
-  if (j === 2 && k !== 12) {
+  if (j2 === 2 && k2 !== 12) {
     return `${i}nd`;
   }
-  if (j === 3 && k !== 13) {
+  if (j2 === 3 && k2 !== 13) {
     return `${i}rd`;
   }
   return `${i}th`;
@@ -12231,7 +12219,7 @@ ${printReceived3(actual)}`
         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 (!isMockFunction2(assertion._obj)) {
+        if (!isMockFunction(assertion._obj)) {
           throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
         }
       }
@@ -12271,8 +12259,8 @@ ${printReceived3(actual)}`
           throw new AssertionError2(msg);
         }
       });
-      function equalsArgumentArray(a3, b) {
-        return a3.length === b.length && a3.every((aItem, i) => equals(aItem, b[i], [...customTesters, iterableEquality]));
+      function equalsArgumentArray(a3, b2) {
+        return a3.length === b2.length && a3.every((aItem, i) => equals(aItem, b2[i], [...customTesters, iterableEquality]));
       }
       def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
         const spy = getSpy(this);
@@ -12333,14 +12321,14 @@ ${printReceived3(actual)}`
       }
       def(["toHaveBeenCalledBefore"], function(resultSpy, failIfNoFirstInvocation = true) {
         const expectSpy = getSpy(this);
-        if (!isMockFunction2(resultSpy)) {
+        if (!isMockFunction(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 (!isMockFunction2(resultSpy)) {
+        if (!isMockFunction(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);
@@ -12654,8 +12642,8 @@ var init_utils_XdZDrNZV = __esm({
 });
 
 // node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
-function getDefaultExportFromCjs3(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+function getDefaultExportFromCjs3(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
 var commonjsGlobal;
 var init_commonjsHelpers_BFTU3MAI = __esm({
@@ -12735,8 +12723,8 @@ function decode(mappings) {
 function sort(line) {
   line.sort(sortComparator$1);
 }
-function sortComparator$1(a3, b) {
-  return a3[0] - b[0];
+function sortComparator$1(a3, b2) {
+  return a3[0] - b2[0];
 }
 function isAbsoluteUrl(input) {
   return schemeRegex.test(input);
@@ -12932,8 +12920,8 @@ function nextUnsortedSegmentLine(mappings, start) {
   return mappings.length;
 }
 function isSorted(line) {
-  for (let j = 1; j < line.length; j++) {
-    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+  for (let j2 = 1; j2 < line.length; j2++) {
+    if (line[j2][COLUMN] < line[j2 - 1][COLUMN]) {
       return false;
     }
   }
@@ -12944,8 +12932,8 @@ function sortSegments(line, owned) {
     line = line.slice();
   return line.sort(sortComparator);
 }
-function sortComparator(a3, b) {
-  return a3[COLUMN] - b[COLUMN];
+function sortComparator(a3, b2) {
+  return a3[COLUMN] - b2[COLUMN];
 }
 function binarySearch(haystack, needle, low, high) {
   while (low <= high) {
@@ -13044,8 +13032,8 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     return -1;
   return index2;
 }
-function notNullish2(v) {
-  return v != null;
+function notNullish2(v2) {
+  return v2 != null;
 }
 function isPrimitive3(value) {
   return value === null || typeof value !== "function" && typeof value !== "object";
@@ -13238,13 +13226,13 @@ function parseErrorStacktrace(e, options = {}) {
     }
   }
   if (options.frameFilter) {
-    stackFrames = stackFrames.filter((f3) => options.frameFilter(e, f3) !== false);
+    stackFrames = stackFrames.filter((f4) => options.frameFilter(e, f4) !== false);
   }
   e.stacks = stackFrames;
   return stackFrames;
 }
-function getDefaultExportFromCjs4(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+function getDefaultExportFromCjs4(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
 function requireJsTokens2() {
   if (hasRequiredJsTokens2) return jsTokens_12;
@@ -13646,27 +13634,27 @@ function C2(n = false) {
 }
 function p2(n = false) {
   let e = C2(n), i = (r2, t, c, o) => {
-    let l = "", s2 = 0;
+    let l2 = "", s2 = 0;
     do
-      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l + r2.substring(s2);
+    return l2 + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    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;
+    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;
     };
     return o.open = r2, o.close = t, o;
-  }, u2 = {
+  }, u3 = {
     isColorSupported: e
   }, d = (r2) => `\x1B[${r2}m`;
-  for (let [r2, t] of h2)
-    u2[r2] = e ? g(
+  for (let [r2, t] of h3)
+    u3[r2] = e ? g(
       d(t[0]),
       d(t[1]),
       t[2]
     ) : a2;
-  return u2;
+  return u3;
 }
 function positionToOffset(source, lineNumber, columnNumber) {
   const lines = source.split(lineSplitRE);
@@ -13846,7 +13834,7 @@ function saveRawSnapshots(environment, snapshots) {
 function requireNaturalCompare() {
   if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
   hasRequiredNaturalCompare = 1;
-  var naturalCompare2 = function(a3, b) {
+  var naturalCompare2 = function(a3, b2) {
     var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
     function getCode(str, pos, code) {
       if (code) {
@@ -13856,12 +13844,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 += "") != (b += "")) for (; codeB; ) {
+    if ((a3 += "") != (b2 += "")) for (; codeB; ) {
       codeA = getCode(a3, posA++);
-      codeB = getCode(b, posB++);
+      codeB = getCode(b2, posB++);
       if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
         codeA = getCode(a3, posA, posA);
-        codeB = getCode(b, posB, posA = i);
+        codeB = getCode(b2, posB, posA = i);
         posB = i;
       }
       if (codeA != codeB) return codeA < codeB ? -1 : 1;
@@ -13988,8 +13976,8 @@ function deepMergeSnapshot(target, source) {
   }
   return target;
 }
-function isSameStackPosition(x, y) {
-  return x.file === y.file && x.column === y.column && x.line === y.line;
+function isSameStackPosition(x2, y2) {
+  return x2.file === y2.file && x2.column === y2.column && x2.line === y2.line;
 }
 function createMismatchError(message, expand, actual, expected) {
   const error = new Error(message);
@@ -14008,7 +13996,7 @@ function createMismatchError(message, expand, actual, expected) {
   Object.defineProperty(error, "diffOptions", { value: { expand } });
   return error;
 }
-var comma2, chars2, intToChar2, charToInt2, StringReader, schemeRegex, urlRegex, fileRegex, UrlType2, COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN, NAMES_INDEX, found, LINE_GTR_ZERO, COL_GTR_EQ_ZERO, LEAST_UPPER_BOUND, GREATEST_LOWER_BOUND, TraceMap, CHROME_IE_STACK_REGEXP2, SAFARI_NATIVE_CODE_REGEXP2, stackIgnorePatterns, getPromiseValue3, AsymmetricMatcher$1, DOMCollection$1, DOMElement$1, Immutable$1, ReactElement$1, ReactTestComponent$1, jsTokens_12, hasRequiredJsTokens2, reservedWords2, f2, h2, lineSplitRE, startObjectRegex, toMatchInlineName, toThrowErrorMatchingInlineName, startRegex, INDENTATION_REGEX, naturalCompare$1, hasRequiredNaturalCompare, naturalCompareExports, naturalCompare, serialize$12, test4, plugin2, DOMCollection3, DOMElement3, Immutable3, ReactElement3, ReactTestComponent3, AsymmetricMatcher4, PLUGINS3, escapeRegex, printFunctionName, DefaultMap, CounterMap, SnapshotState, SnapshotClient;
+var comma2, chars2, intToChar2, charToInt2, StringReader, schemeRegex, urlRegex, fileRegex, UrlType2, COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN, NAMES_INDEX, found, LINE_GTR_ZERO, COL_GTR_EQ_ZERO, LEAST_UPPER_BOUND, GREATEST_LOWER_BOUND, TraceMap, CHROME_IE_STACK_REGEXP2, SAFARI_NATIVE_CODE_REGEXP2, stackIgnorePatterns, getPromiseValue3, AsymmetricMatcher$1, DOMCollection$1, DOMElement$1, Immutable$1, ReactElement$1, ReactTestComponent$1, jsTokens_12, hasRequiredJsTokens2, reservedWords2, f3, h3, lineSplitRE, startObjectRegex, toMatchInlineName, toThrowErrorMatchingInlineName, startRegex, INDENTATION_REGEX, naturalCompare$1, hasRequiredNaturalCompare, naturalCompareExports, naturalCompare, serialize$12, test4, plugin2, DOMCollection3, DOMElement3, Immutable3, ReactElement3, ReactTestComponent3, AsymmetricMatcher4, PLUGINS3, escapeRegex, printFunctionName, DefaultMap, CounterMap, SnapshotState, SnapshotClient;
 var init_dist9 = __esm({
   "node_modules/@vitest/snapshot/dist/index.js"() {
     "use strict";
@@ -14181,7 +14169,7 @@ var init_dist9 = __esm({
     };
     new Set(reservedWords2.keyword);
     new Set(reservedWords2.strict);
-    f2 = {
+    f3 = {
       reset: [0, 0],
       bold: [1, 22, "\x1B[22m\x1B[1m"],
       dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -14224,7 +14212,7 @@ var init_dist9 = __esm({
       bgCyanBright: [106, 49],
       bgWhiteBright: [107, 49]
     };
-    h2 = Object.entries(f2);
+    h3 = Object.entries(f3);
     a2.open = "";
     a2.close = "";
     p2();
@@ -14300,8 +14288,8 @@ var init_dist9 = __esm({
           return this._total;
         }
         let total = 0;
-        for (const x of this.values()) {
-          total += x;
+        for (const x2 of this.values()) {
+          total += x2;
         }
         return total;
       }
@@ -14729,7 +14717,7 @@ var init_date_Bq6ZW5rf = __esm({
     RealDate = Date;
     now2 = null;
     MockDate = class _MockDate extends RealDate {
-      constructor(y, m2, d, h3, M, s2, ms) {
+      constructor(y2, m2, d, h4, M2, s2, ms) {
         super();
         let date;
         switch (arguments.length) {
@@ -14738,15 +14726,15 @@ var init_date_Bq6ZW5rf = __esm({
             else date = new RealDate();
             break;
           case 1:
-            date = new RealDate(y);
+            date = new RealDate(y2);
             break;
           default:
             d = typeof d === "undefined" ? 1 : d;
-            h3 = h3 || 0;
-            M = M || 0;
+            h4 = h4 || 0;
+            M2 = M2 || 0;
             s2 = s2 || 0;
             ms = ms || 0;
-            date = new RealDate(y, m2, d, h3, M, s2, ms);
+            date = new RealDate(y2, m2, d, h4, M2, s2, ms);
             break;
         }
         Object.setPrototypeOf(date, _MockDate.prototype);
@@ -15009,11 +14997,11 @@ function createExpect(test5) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
     setState({ assertionCalls: assertionCalls + 1 }, expect2);
-    const assert4 = expect(value, message);
+    const assert3 = expect(value, message);
     const _test2 = test5 || getCurrentTest();
     if (_test2)
-      return assert4.withTest(_test2);
-    else return assert4;
+      return assert3.withTest(_test2);
+    else return assert3;
   };
   Object.assign(expect2, expect);
   Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
@@ -15039,7 +15027,7 @@ function createExpect(test5) {
   };
   expect2.poll = createExpectPoll(expect2);
   expect2.unreachable = (message) => {
-    assert3.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}`);
@@ -15139,10 +15127,10 @@ function requireCalledInOrder() {
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index2, spies2) {
+  function checkAdjacentCalls(callMap, spy, index2, spies) {
     var calledBeforeNext = true;
-    if (index2 !== spies2.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies2[index2 + 1]);
+    if (index2 !== spies.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -15150,9 +15138,9 @@ function requireCalledInOrder() {
     }
     return false;
   }
-  function calledInOrder(spies2) {
+  function calledInOrder(spies) {
     var callMap = {};
-    var _spies = arguments.length > 1 ? arguments : spies2;
+    var _spies = arguments.length > 1 ? arguments : spies;
     return every2(_spies, checkAdjacentCalls.bind(null, callMap));
   }
   calledInOrder_1 = calledInOrder;
@@ -15239,15 +15227,15 @@ function requireOrderByFirstCall() {
   hasRequiredOrderByFirstCall = 1;
   var sort2 = requireArray().sort;
   var slice = requireArray().slice;
-  function comparator(a3, b) {
+  function comparator(a3, b2) {
     var aCall = a3.getCall(0);
-    var bCall = b.getCall(0);
+    var bCall = b2.getCall(0);
     var aId = aCall && aCall.callId || -1;
     var bId = bCall && bCall.callId || -1;
     return aId < bId ? -1 : 1;
   }
-  function orderByFirstCall(spies2) {
-    return sort2(slice(spies2), comparator);
+  function orderByFirstCall(spies) {
+    return sort2(slice(spies), comparator);
   }
   orderByFirstCall_1 = orderByFirstCall;
   return orderByFirstCall_1;
@@ -15552,11 +15540,11 @@ function requireFakeTimersSrc() {
         return 0;
       }
       const strings = str.split(":");
-      const l = strings.length;
-      let i = l;
+      const l2 = strings.length;
+      let i = l2;
       let ms = 0;
       let parsed;
-      if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+      if (l2 > 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"
         );
@@ -15566,7 +15554,7 @@ function requireFakeTimersSrc() {
         if (parsed >= 60) {
           throw new Error(`Invalid time ${str}`);
         }
-        ms += parsed * Math.pow(60, l - i - 1);
+        ms += parsed * Math.pow(60, l2 - i - 1);
       }
       return ms * 1e3;
     }
@@ -15805,29 +15793,29 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return timer.id;
     }
-    function compareTimers(a3, b) {
-      if (a3.callAt < b.callAt) {
+    function compareTimers(a3, b2) {
+      if (a3.callAt < b2.callAt) {
         return -1;
       }
-      if (a3.callAt > b.callAt) {
+      if (a3.callAt > b2.callAt) {
         return 1;
       }
-      if (a3.immediate && !b.immediate) {
+      if (a3.immediate && !b2.immediate) {
         return -1;
       }
-      if (!a3.immediate && b.immediate) {
+      if (!a3.immediate && b2.immediate) {
         return 1;
       }
-      if (a3.createdAt < b.createdAt) {
+      if (a3.createdAt < b2.createdAt) {
         return -1;
       }
-      if (a3.createdAt > b.createdAt) {
+      if (a3.createdAt > b2.createdAt) {
         return 1;
       }
-      if (a3.id < b.id) {
+      if (a3.id < b2.id) {
         return -1;
       }
-      if (a3.id > b.id) {
+      if (a3.id > b2.id) {
         return 1;
       }
     }
@@ -15938,10 +15926,10 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       }
     }
     function uninstall(clock, config2) {
-      let method, i, l;
+      let method, i, l2;
       const installedHrTime = "_hrtime";
       const installedNextTick = "_nextTick";
-      for (i = 0, l = clock.methods.length; i < l; i++) {
+      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
         method = clock.methods[i];
         if (method === "hrtime" && _global.process) {
           _global.process.hrtime = clock[installedHrTime];
@@ -15972,14 +15960,14 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           }
         }
         if (clock.timersModuleMethods !== void 0) {
-          for (let j = 0; j < clock.timersModuleMethods.length; j++) {
-            const entry = clock.timersModuleMethods[j];
+          for (let j2 = 0; j2 < clock.timersModuleMethods.length; j2++) {
+            const entry = clock.timersModuleMethods[j2];
             timersModule[entry.methodName] = entry.original;
           }
         }
         if (clock.timersPromisesModuleMethods !== void 0) {
-          for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
-            const entry = clock.timersPromisesModuleMethods[j];
+          for (let j2 = 0; j2 < clock.timersPromisesModuleMethods.length; j2++) {
+            const entry = clock.timersPromisesModuleMethods[j2];
             timersPromisesModule[entry.methodName] = entry.original;
           }
         }
@@ -16484,7 +16472,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
         };
       }
-      clock.reset = function reset2() {
+      clock.reset = function reset() {
         nanos = 0;
         clock.timers = {};
         clock.jobs = [];
@@ -16555,7 +16543,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           `non-existent timers and/or objects cannot be faked: '${timer}'`
         );
       }
-      let i, l;
+      let i, l2;
       const clock = createClock(config2.now, config2.loopLimit);
       clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
       clock.uninstall = function() {
@@ -16606,7 +16594,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       if (_global === globalObject && timersPromisesModule) {
         clock.timersPromisesModuleMethods = [];
       }
-      for (i = 0, l = clock.methods.length; i < l; i++) {
+      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
         const nameOfMethodToReplace = clock.methods[i];
         if (!isPresent[nameOfMethodToReplace]) {
           handleMissingTimer(nameOfMethodToReplace);
@@ -17075,7 +17063,7 @@ function createVitest() {
       return item;
     },
     isMockFunction(fn2) {
-      return isMockFunction2(fn2);
+      return isMockFunction(fn2);
     },
     clearAllMocks() {
       [...mocks].reverse().forEach((spy) => spy.mockClear());
@@ -17503,18 +17491,18 @@ var require_utils = __commonJS({
 var require_dist = __commonJS({
   "node_modules/expect-type/dist/index.js"(exports) {
     "use strict";
-    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m2, k);
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      var desc = Object.getOwnPropertyDescriptor(m2, k2);
       if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
         desc = { enumerable: true, get: function() {
-          return m2[k];
+          return m2[k2];
         } };
       }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m2, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m2[k];
+      Object.defineProperty(o, k22, desc);
+    }) : (function(o, m2, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      o[k22] = m2[k2];
     }));
     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);