@blindpay/node 2.0.4 → 2.1.1

package/dist/resources/receivers/receivers.test.js

@@ -11,18 +11,18 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __pow = Math.pow;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a3, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a3, prop, b[prop]);
+var __spreadValues = (a3, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a3, prop, b2[prop]);
   if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a3, prop, b[prop]);
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a3, prop, b2[prop]);
     }
   return a3;
 };
-var __spreadProps = (a3, b) => __defProps(a3, __getOwnPropDescs(b));
+var __spreadProps = (a3, b2) => __defProps(a3, __getOwnPropDescs(b2));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -78,7 +78,7 @@ var __async = (__this, __arguments, generator) => {
         reject(e);
       }
     };
-    var step = (x) => x.done ? resolve4(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    var step = (x2) => x2.done ? resolve4(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
@@ -527,9 +527,9 @@ function encode(decoded) {
     if (i > 0) writer.write(semicolon);
     if (line.length === 0) continue;
     let genColumn = 0;
-    for (let j = 0; j < line.length; j++) {
-      const segment = line[j];
-      if (j > 0) writer.write(comma2);
+    for (let j2 = 0; j2 < line.length; j2++) {
+      const segment = line[j2];
+      if (j2 > 0) writer.write(comma2);
       genColumn = encodeInteger(writer, segment[0], genColumn);
       if (segment.length === 1) continue;
       sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
@@ -576,9 +576,9 @@ var init_sourcemap_codec = __esm({
         this.out = "";
         this.buffer = new Uint8Array(bufLength);
       }
-      write(v) {
+      write(v2) {
         const { buffer } = this;
-        buffer[this.pos++] = v;
+        buffer[this.pos++] = v2;
         if (this.pos === bufLength) {
           this.out += td.decode(buffer);
           this.pos = 0;
@@ -652,11 +652,11 @@ function getLocator(source) {
   }
   return function locate(index2) {
     let i = 0;
-    let j = lineOffsets.length;
-    while (i < j) {
-      const m2 = i + j >> 1;
+    let j2 = lineOffsets.length;
+    while (i < j2) {
+      const m2 = i + j2 >> 1;
       if (index2 < lineOffsets[m2]) {
-        j = m2;
+        j2 = m2;
       } else {
         i = m2 + 1;
       }
@@ -1737,8 +1737,8 @@ var init_magic_string_es = __esm({
           if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
           indentStringCounts[indentStr] += 1;
         });
-        return Object.keys(indentStringCounts).sort((a3, b) => {
-          return indentStringCounts[a3] - indentStringCounts[b];
+        return Object.keys(indentStringCounts).sort((a3, b2) => {
+          return indentStringCounts[a3] - indentStringCounts[b2];
         })[0] || "	";
       }
       indent(indentStr) {
@@ -1880,18 +1880,18 @@ var require_utils = __commonJS({
 var require_dist = __commonJS({
   "node_modules/expect-type/dist/index.js"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m2, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m2, k);
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m2, exports3) {
       for (var p3 in m2) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m2, p3);
@@ -2012,27 +2012,27 @@ function C(n2 = false) {
 }
 function p(n2 = false) {
   let e = C(n2), 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;
 }
 
 // node_modules/tinyrainbow/dist/node.js
@@ -2043,13 +2043,13 @@ var u = p(r);
 // node_modules/@vitest/pretty-format/dist/index.js
 function _mergeNamespaces(n2, m2) {
   m2.forEach(function(e) {
-    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
-      if (k !== "default" && !(k in n2)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n2, k, d.get ? d : {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k2) {
+      if (k2 !== "default" && !(k2 in n2)) {
+        var d = Object.getOwnPropertyDescriptor(e, k2);
+        Object.defineProperty(n2, k2, d.get ? d : {
           enumerable: true,
           get: function() {
-            return e[k];
+            return e[k2];
           }
         });
       }
@@ -2124,7 +2124,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;
@@ -2385,8 +2385,8 @@ var plugin$2 = {
   serialize: serialize$2,
   test: test$2
 };
-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;
 }
 var reactIs$1 = { exports: {} };
 var reactIs_production = {};
@@ -2598,25 +2598,25 @@ var hasRequiredReactIs_production_min;
 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"), n2 = 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"), n2 = 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 n2:
               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:
@@ -2630,15 +2630,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 = n2;
@@ -2649,45 +2649,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) === n2;
+    return v2(a3) === n2;
   };
   reactIs_production_min.isValidElementType = function(a3) {
-    return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f3 || a3 === e || a3 === m2 || a3 === n2 || 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 === n2 || 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;
 }
 var reactIs_development = {};
@@ -2905,7 +2905,7 @@ var reactIsMethods = [
   "isSuspenseList",
   "isValidElementType"
 ];
-var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v) => ReactIs18[m2](v) || ReactIs19[m2](v)]));
+var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v2) => ReactIs18[m2](v2) || ReactIs19[m2](v2)]));
 function getChildren(arg, children = []) {
   if (Array.isArray(arg)) {
     for (const item of arg) {
@@ -3877,14 +3877,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") {
@@ -3942,14 +3942,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;
@@ -3982,8 +3982,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;
 }
 
 // node_modules/@vitest/utils/dist/helpers.js
@@ -4043,15 +4043,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;
   }
@@ -4059,27 +4059,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
         }));
       }
@@ -5467,19 +5467,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;
@@ -5604,20 +5604,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) {
@@ -5639,9 +5639,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)}
 
 `;
 }
@@ -5756,26 +5756,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 = [];
@@ -5784,18 +5784,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];
 }
@@ -5937,22 +5937,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);
   }
@@ -5981,8 +5981,8 @@ var FALLBACK_FORMAT_OPTIONS = {
   maxDepth: 8,
   plugins: PLUGINS2
 };
-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);
@@ -5998,7 +5998,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)}...`;
     };
@@ -6006,7 +6006,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);
@@ -6023,21 +6023,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) {
@@ -6046,19 +6046,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)}
 
@@ -6075,17 +6075,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);
   }
 }
@@ -6182,165 +6182,165 @@ function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
 }
 
 // node_modules/tinyspy/dist/index.js
-function assert(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 });
 }
-var SYMBOL_STATE = Symbol.for("tinyspy:spy");
-var spies = /* @__PURE__ */ new Set();
-var reset = (state) => {
-  state.called = false, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
+var y = Symbol.for("tinyspy:spy");
+var x = /* @__PURE__ */ new Set();
+var h2 = (e) => {
+  e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.resolves = [], e.next = [];
 };
-var defineState = (spy2) => (define(spy2, SYMBOL_STATE, {
-  value: { reset: () => reset(spy2[SYMBOL_STATE]) }
-}), spy2[SYMBOL_STATE]);
-var getInternalState = (spy2) => spy2[SYMBOL_STATE] || defineState(spy2);
-function createInternalSpy(cb) {
-  assert(
-    isType("function", cb) || isType("undefined", cb),
+var k = (e) => (u2(e, y, {
+  value: { reset: () => h2(e[y]) }
+}), e[y]);
+var T = (e) => e[y] || k(e);
+function R(e) {
+  S(
+    f2("function", e) || f2("undefined", e),
     "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 n2 = T(t);
+    n2.called = true, n2.callCount++, n2.calls.push(s2);
+    let d = n2.next.shift();
+    if (d) {
+      n2.results.push(d);
+      let [a3, i] = d;
+      if (a3 === "ok")
+        return i;
+      throw i;
+    }
+    let o, c = "ok", p3 = n2.results.length;
+    if (n2.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(n2.impl, s2, new.target) : o = n2.impl.apply(this, s2), c = "ok";
+      } catch (a3) {
+        throw o = a3, c = "error", n2.results.push([c, a3]), a3;
+      }
+    let g = [c, o];
+    return w(o) && o.then(
+      (a3) => n2.resolves[p3] = ["ok", a3],
+      (a3) => n2.resolves[p3] = ["error", a3]
+    ), n2.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;
-}
-function isMockFunction(obj) {
-  return !!obj && obj._isMockFunction === true;
-}
-var getDescriptor = (obj, method) => {
-  let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
-  if (objDescriptor)
-    return [obj, objDescriptor];
-  let currentProto = Object.getPrototypeOf(obj);
-  for (; currentProto !== null; ) {
-    let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
-    if (descriptor)
-      return [currentProto, descriptor];
-    currentProto = Object.getPrototypeOf(currentProto);
+  l(t, "_isMockFunction", true), l(t, "length", e ? e.length : 0), l(t, "name", e && e.name || "spy");
+  let r2 = T(t);
+  return r2.reset(), r2.impl = e, t;
+}
+function v(e) {
+  return !!e && e._isMockFunction === true;
+}
+var b = (e, t) => {
+  let r2 = Object.getOwnPropertyDescriptor(e, t);
+  if (r2)
+    return [e, r2];
+  let s2 = Object.getPrototypeOf(e);
+  for (; s2 !== null; ) {
+    let n2 = Object.getOwnPropertyDescriptor(s2, t);
+    if (n2)
+      return [s2, n2];
+    s2 = Object.getPrototypeOf(s2);
   }
 };
-var setPototype = (fn2, val) => {
-  val != null && typeof val == "function" && val.prototype != null && Object.setPrototypeOf(fn2.prototype, val.prototype);
+var P = (e, t) => {
+  t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
 };
-function internalSpyOn(obj, methodName, mock) {
-  assert(
-    !isType("undefined", obj),
+function M(e, t, r2) {
+  S(
+    !f2("undefined", e),
     "spyOn could not find an object to spy upon"
-  ), assert(
-    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, n2] = (() => {
+    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) || [];
-  assert(
-    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;
+  n2 === "value" && o && !o.value && o.get && (n2 = "get", c = true, r2 = o.get());
+  let p3;
+  o ? p3 = o[n2] : n2 !== "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"]);
+    n2 !== "value" && delete O.writable, O[n2] = 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;
-}
-var ignoreProperties = /* @__PURE__ */ new Set([
+  r2 || (r2 = p3);
+  let i = E(R(r2), r2);
+  n2 === "value" && P(i, p3);
+  let m2 = i[y];
+  return l(m2, "restore", a3), l(m2, "getOriginal", () => c ? p3() : p3), l(m2, "willCall", (I) => (m2.impl = I, i)), g(
+    c ? () => (P(i, r2), i) : i
+  ), x.add(i), i;
+}
+var K = /* @__PURE__ */ new Set([
   "length",
   "name",
   "prototype"
 ]);
-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)
+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 n2 of s2)
+      r2[n2] || K.has(n2) || (t.add(n2), r2[n2] = Object.getOwnPropertyDescriptor(e, n2));
+    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 n2 of r2) {
+    let d = s2[n2];
+    b(e, n2) || u2(e, n2, 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];
 }
 
 // node_modules/@vitest/spy/dist/index.js
 var mocks = /* @__PURE__ */ new Set();
-function isMockFunction2(fn2) {
+function isMockFunction(fn2) {
   return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
 }
 function spyOn(obj, method, accessType) {
@@ -6350,13 +6350,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);
@@ -6378,7 +6378,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;
@@ -6476,18 +6476,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;
@@ -6506,14 +6506,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;
@@ -6531,8 +6531,8 @@ function getDescriptor2(obj, method) {
 // node_modules/@vitest/utils/dist/error.js
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
-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]);
 }
 var OBJECT_PROTO = Object.getPrototypeOf({});
 function getUnserializableMessage(err) {
@@ -8261,20 +8261,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)
       );
     }
   }
@@ -8429,8 +8429,8 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   }, "overwritingChainableMethodWrapper");
 }
 __name(overwriteChainableMethod, "overwriteChainableMethod");
-function compareByInspect(a3, b) {
-  return inspect22(a3) < inspect22(b) ? -1 : 1;
+function compareByInspect(a3, b2) {
+  return inspect22(a3) < inspect22(b2) ? -1 : 1;
 }
 __name(compareByInspect, "compareByInspect");
 function getOwnEnumerablePropertySymbols(obj) {
@@ -8564,8 +8564,8 @@ function an(type3, msg) {
 __name(an, "an");
 Assertion.addChainableMethod("an", an);
 Assertion.addChainableMethod("a", an);
-function SameValueZero(a3, b) {
-  return isNaN22(a3) && isNaN22(b) || a3 === b;
+function SameValueZero(a3, b2) {
+  return isNaN22(a3) && isNaN22(b2) || a3 === b2;
 }
 __name(SameValueZero, "SameValueZero");
 function includeChainingBehavior() {
@@ -9508,7 +9508,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,
@@ -9907,12 +9907,12 @@ function loadShould() {
 __name(loadShould, "loadShould");
 var should = loadShould;
 var Should = loadShould;
-function assert2(express, errmsg) {
-  let test22 = new Assertion(null, null, assert2, true);
+function assert(express, errmsg) {
+  let test22 = new Assertion(null, null, assert, true);
   test22.assert(express, errmsg, "[ negation message unavailable ]");
 }
-__name(assert2, "assert");
-assert2.fail = function(actual, expected, message, operator) {
+__name(assert, "assert");
+assert.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
     actual = void 0;
@@ -9925,17 +9925,17 @@ assert2.fail = function(actual, expected, message, operator) {
       expected,
       operator
     },
-    assert2.fail
+    assert.fail
   );
 };
-assert2.isOk = function(val, msg) {
-  new Assertion(val, msg, assert2.isOk, true).is.ok;
+assert.isOk = function(val, msg) {
+  new Assertion(val, msg, assert.isOk, true).is.ok;
 };
-assert2.isNotOk = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotOk, true).is.not.ok;
+assert.isNotOk = function(val, msg) {
+  new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
 };
-assert2.equal = function(act, exp, msg) {
-  let test22 = new Assertion(act, msg, assert2.equal, true);
+assert.equal = function(act, exp, msg) {
+  let test22 = new Assertion(act, msg, assert.equal, true);
   test22.assert(
     exp == flag(test22, "object"),
     "expected #{this} to equal #{exp}",
@@ -9945,8 +9945,8 @@ assert2.equal = function(act, exp, msg) {
     true
   );
 };
-assert2.notEqual = function(act, exp, msg) {
-  let test22 = new Assertion(act, msg, assert2.notEqual, true);
+assert.notEqual = function(act, exp, msg) {
+  let test22 = new Assertion(act, msg, assert.notEqual, true);
   test22.assert(
     exp != flag(test22, "object"),
     "expected #{this} to not equal #{exp}",
@@ -9956,370 +9956,370 @@ assert2.notEqual = function(act, exp, msg) {
     true
   );
 };
-assert2.strictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert2.strictEqual, true).to.equal(exp);
+assert.strictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
 };
-assert2.notStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert2.notStrictEqual, true).to.not.equal(exp);
+assert.notStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
 };
-assert2.deepEqual = assert2.deepStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert2.deepEqual, true).to.eql(exp);
+assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
 };
-assert2.notDeepEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert2.notDeepEqual, true).to.not.eql(exp);
+assert.notDeepEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
 };
-assert2.isAbove = function(val, abv, msg) {
-  new Assertion(val, msg, assert2.isAbove, true).to.be.above(abv);
+assert.isAbove = function(val, abv, msg) {
+  new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
 };
-assert2.isAtLeast = function(val, atlst, msg) {
-  new Assertion(val, msg, assert2.isAtLeast, true).to.be.least(atlst);
+assert.isAtLeast = function(val, atlst, msg) {
+  new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
 };
-assert2.isBelow = function(val, blw, msg) {
-  new Assertion(val, msg, assert2.isBelow, true).to.be.below(blw);
+assert.isBelow = function(val, blw, msg) {
+  new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
 };
-assert2.isAtMost = function(val, atmst, msg) {
-  new Assertion(val, msg, assert2.isAtMost, true).to.be.most(atmst);
+assert.isAtMost = function(val, atmst, msg) {
+  new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
 };
-assert2.isTrue = function(val, msg) {
-  new Assertion(val, msg, assert2.isTrue, true).is["true"];
+assert.isTrue = function(val, msg) {
+  new Assertion(val, msg, assert.isTrue, true).is["true"];
 };
-assert2.isNotTrue = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotTrue, true).to.not.equal(true);
+assert.isNotTrue = function(val, msg) {
+  new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
 };
-assert2.isFalse = function(val, msg) {
-  new Assertion(val, msg, assert2.isFalse, true).is["false"];
+assert.isFalse = function(val, msg) {
+  new Assertion(val, msg, assert.isFalse, true).is["false"];
 };
-assert2.isNotFalse = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotFalse, true).to.not.equal(false);
+assert.isNotFalse = function(val, msg) {
+  new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
 };
-assert2.isNull = function(val, msg) {
-  new Assertion(val, msg, assert2.isNull, true).to.equal(null);
+assert.isNull = function(val, msg) {
+  new Assertion(val, msg, assert.isNull, true).to.equal(null);
 };
-assert2.isNotNull = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotNull, true).to.not.equal(null);
+assert.isNotNull = function(val, msg) {
+  new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
 };
-assert2.isNaN = function(val, msg) {
-  new Assertion(val, msg, assert2.isNaN, true).to.be.NaN;
+assert.isNaN = function(val, msg) {
+  new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
 };
-assert2.isNotNaN = function(value, message) {
-  new Assertion(value, message, assert2.isNotNaN, true).not.to.be.NaN;
+assert.isNotNaN = function(value, message) {
+  new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
 };
-assert2.exists = function(val, msg) {
-  new Assertion(val, msg, assert2.exists, true).to.exist;
+assert.exists = function(val, msg) {
+  new Assertion(val, msg, assert.exists, true).to.exist;
 };
-assert2.notExists = function(val, msg) {
-  new Assertion(val, msg, assert2.notExists, true).to.not.exist;
+assert.notExists = function(val, msg) {
+  new Assertion(val, msg, assert.notExists, true).to.not.exist;
 };
-assert2.isUndefined = function(val, msg) {
-  new Assertion(val, msg, assert2.isUndefined, true).to.equal(void 0);
+assert.isUndefined = function(val, msg) {
+  new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
 };
-assert2.isDefined = function(val, msg) {
-  new Assertion(val, msg, assert2.isDefined, true).to.not.equal(void 0);
+assert.isDefined = function(val, msg) {
+  new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
 };
-assert2.isCallable = function(value, message) {
-  new Assertion(value, message, assert2.isCallable, true).is.callable;
+assert.isCallable = function(value, message) {
+  new Assertion(value, message, assert.isCallable, true).is.callable;
 };
-assert2.isNotCallable = function(value, message) {
-  new Assertion(value, message, assert2.isNotCallable, true).is.not.callable;
+assert.isNotCallable = function(value, message) {
+  new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
 };
-assert2.isObject = function(val, msg) {
-  new Assertion(val, msg, assert2.isObject, true).to.be.a("object");
+assert.isObject = function(val, msg) {
+  new Assertion(val, msg, assert.isObject, true).to.be.a("object");
 };
-assert2.isNotObject = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotObject, true).to.not.be.a("object");
+assert.isNotObject = function(val, msg) {
+  new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
 };
-assert2.isArray = function(val, msg) {
-  new Assertion(val, msg, assert2.isArray, true).to.be.an("array");
+assert.isArray = function(val, msg) {
+  new Assertion(val, msg, assert.isArray, true).to.be.an("array");
 };
-assert2.isNotArray = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotArray, true).to.not.be.an("array");
+assert.isNotArray = function(val, msg) {
+  new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
 };
-assert2.isString = function(val, msg) {
-  new Assertion(val, msg, assert2.isString, true).to.be.a("string");
+assert.isString = function(val, msg) {
+  new Assertion(val, msg, assert.isString, true).to.be.a("string");
 };
-assert2.isNotString = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotString, true).to.not.be.a("string");
+assert.isNotString = function(val, msg) {
+  new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
 };
-assert2.isNumber = function(val, msg) {
-  new Assertion(val, msg, assert2.isNumber, true).to.be.a("number");
+assert.isNumber = function(val, msg) {
+  new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
 };
-assert2.isNotNumber = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotNumber, true).to.not.be.a("number");
+assert.isNotNumber = function(val, msg) {
+  new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
 };
-assert2.isNumeric = function(val, msg) {
-  new Assertion(val, msg, assert2.isNumeric, true).is.numeric;
+assert.isNumeric = function(val, msg) {
+  new Assertion(val, msg, assert.isNumeric, true).is.numeric;
 };
-assert2.isNotNumeric = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotNumeric, true).is.not.numeric;
+assert.isNotNumeric = function(val, msg) {
+  new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
 };
-assert2.isFinite = function(val, msg) {
-  new Assertion(val, msg, assert2.isFinite, true).to.be.finite;
+assert.isFinite = function(val, msg) {
+  new Assertion(val, msg, assert.isFinite, true).to.be.finite;
 };
-assert2.isBoolean = function(val, msg) {
-  new Assertion(val, msg, assert2.isBoolean, true).to.be.a("boolean");
+assert.isBoolean = function(val, msg) {
+  new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
 };
-assert2.isNotBoolean = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotBoolean, true).to.not.be.a("boolean");
+assert.isNotBoolean = function(val, msg) {
+  new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
 };
-assert2.typeOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert2.typeOf, true).to.be.a(type3);
+assert.typeOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
 };
-assert2.notTypeOf = function(value, type3, message) {
-  new Assertion(value, message, assert2.notTypeOf, true).to.not.be.a(type3);
+assert.notTypeOf = function(value, type3, message) {
+  new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
 };
-assert2.instanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert2.instanceOf, true).to.be.instanceOf(type3);
+assert.instanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
 };
-assert2.notInstanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert2.notInstanceOf, true).to.not.be.instanceOf(
+assert.notInstanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
     type3
   );
 };
-assert2.include = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.include, true).include(inc);
+assert.include = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.include, true).include(inc);
 };
-assert2.notInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.notInclude, true).not.include(inc);
+assert.notInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
 };
-assert2.deepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.deepInclude, true).deep.include(inc);
+assert.deepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
 };
-assert2.notDeepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.notDeepInclude, true).not.deep.include(inc);
+assert.notDeepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
 };
-assert2.nestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.nestedInclude, true).nested.include(inc);
+assert.nestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
 };
-assert2.notNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.notNestedInclude, true).not.nested.include(
+assert.notNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
     inc
   );
 };
-assert2.deepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.deepNestedInclude, true).deep.nested.include(
+assert.deepNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
     inc
   );
 };
-assert2.notDeepNestedInclude = function(exp, inc, msg) {
+assert.notDeepNestedInclude = function(exp, inc, msg) {
   new Assertion(
     exp,
     msg,
-    assert2.notDeepNestedInclude,
+    assert.notDeepNestedInclude,
     true
   ).not.deep.nested.include(inc);
 };
-assert2.ownInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.ownInclude, true).own.include(inc);
+assert.ownInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
 };
-assert2.notOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.notOwnInclude, true).not.own.include(inc);
+assert.notOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
 };
-assert2.deepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.deepOwnInclude, true).deep.own.include(inc);
+assert.deepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
 };
-assert2.notDeepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert2.notDeepOwnInclude, true).not.deep.own.include(
+assert.notDeepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
     inc
   );
 };
-assert2.match = function(exp, re, msg) {
-  new Assertion(exp, msg, assert2.match, true).to.match(re);
+assert.match = function(exp, re, msg) {
+  new Assertion(exp, msg, assert.match, true).to.match(re);
 };
-assert2.notMatch = function(exp, re, msg) {
-  new Assertion(exp, msg, assert2.notMatch, true).to.not.match(re);
+assert.notMatch = function(exp, re, msg) {
+  new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
 };
-assert2.property = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert2.property, true).to.have.property(prop);
+assert.property = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert.property, true).to.have.property(prop);
 };
-assert2.notProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert2.notProperty, true).to.not.have.property(prop);
+assert.notProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
 };
-assert2.propertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert2.propertyVal, true).to.have.property(prop, val);
+assert.propertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
 };
-assert2.notPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert2.notPropertyVal, true).to.not.have.property(
+assert.notPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(
     prop,
     val
   );
 };
-assert2.deepPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert2.deepPropertyVal, true).to.have.deep.property(
+assert.deepPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(
     prop,
     val
   );
 };
-assert2.notDeepPropertyVal = function(obj, prop, val, msg) {
+assert.notDeepPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notDeepPropertyVal,
+    assert.notDeepPropertyVal,
     true
   ).to.not.have.deep.property(prop, val);
 };
-assert2.ownProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert2.ownProperty, true).to.have.own.property(prop);
+assert.ownProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
 };
-assert2.notOwnProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert2.notOwnProperty, true).to.not.have.own.property(
+assert.notOwnProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(
     prop
   );
 };
-assert2.ownPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert2.ownPropertyVal, true).to.have.own.property(
+assert.ownPropertyVal = function(obj, prop, value, msg) {
+  new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(
     prop,
     value
   );
 };
-assert2.notOwnPropertyVal = function(obj, prop, value, msg) {
+assert.notOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notOwnPropertyVal,
+    assert.notOwnPropertyVal,
     true
   ).to.not.have.own.property(prop, value);
 };
-assert2.deepOwnPropertyVal = function(obj, prop, value, msg) {
+assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.deepOwnPropertyVal,
+    assert.deepOwnPropertyVal,
     true
   ).to.have.deep.own.property(prop, value);
 };
-assert2.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notDeepOwnPropertyVal,
+    assert.notDeepOwnPropertyVal,
     true
   ).to.not.have.deep.own.property(prop, value);
 };
-assert2.nestedProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert2.nestedProperty, true).to.have.nested.property(
+assert.nestedProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(
     prop
   );
 };
-assert2.notNestedProperty = function(obj, prop, msg) {
+assert.notNestedProperty = function(obj, prop, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notNestedProperty,
+    assert.notNestedProperty,
     true
   ).to.not.have.nested.property(prop);
 };
-assert2.nestedPropertyVal = function(obj, prop, val, msg) {
+assert.nestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.nestedPropertyVal,
+    assert.nestedPropertyVal,
     true
   ).to.have.nested.property(prop, val);
 };
-assert2.notNestedPropertyVal = function(obj, prop, val, msg) {
+assert.notNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notNestedPropertyVal,
+    assert.notNestedPropertyVal,
     true
   ).to.not.have.nested.property(prop, val);
 };
-assert2.deepNestedPropertyVal = function(obj, prop, val, msg) {
+assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.deepNestedPropertyVal,
+    assert.deepNestedPropertyVal,
     true
   ).to.have.deep.nested.property(prop, val);
 };
-assert2.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.notDeepNestedPropertyVal,
+    assert.notDeepNestedPropertyVal,
     true
   ).to.not.have.deep.nested.property(prop, val);
 };
-assert2.lengthOf = function(exp, len, msg) {
-  new Assertion(exp, msg, assert2.lengthOf, true).to.have.lengthOf(len);
+assert.lengthOf = function(exp, len, msg) {
+  new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
 };
-assert2.hasAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.hasAnyKeys, true).to.have.any.keys(keys2);
+assert.hasAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys2);
 };
-assert2.hasAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.hasAllKeys, true).to.have.all.keys(keys2);
+assert.hasAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys2);
 };
-assert2.containsAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.containsAllKeys, true).to.contain.all.keys(
+assert.containsAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
     keys2
   );
 };
-assert2.doesNotHaveAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.doesNotHaveAnyKeys, true).to.not.have.any.keys(
+assert.doesNotHaveAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
     keys2
   );
 };
-assert2.doesNotHaveAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.doesNotHaveAllKeys, true).to.not.have.all.keys(
+assert.doesNotHaveAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
     keys2
   );
 };
-assert2.hasAnyDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.hasAnyDeepKeys, true).to.have.any.deep.keys(
+assert.hasAnyDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
     keys2
   );
 };
-assert2.hasAllDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert2.hasAllDeepKeys, true).to.have.all.deep.keys(
+assert.hasAllDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
     keys2
   );
 };
-assert2.containsAllDeepKeys = function(obj, keys2, msg) {
+assert.containsAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.containsAllDeepKeys,
+    assert.containsAllDeepKeys,
     true
   ).to.contain.all.deep.keys(keys2);
 };
-assert2.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
+assert.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.doesNotHaveAnyDeepKeys,
+    assert.doesNotHaveAnyDeepKeys,
     true
   ).to.not.have.any.deep.keys(keys2);
 };
-assert2.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
+assert.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert2.doesNotHaveAllDeepKeys,
+    assert.doesNotHaveAllDeepKeys,
     true
   ).to.not.have.all.deep.keys(keys2);
 };
-assert2.throws = function(fn2, errorLike, errMsgMatcher, msg) {
+assert.throws = function(fn2, errorLike, errMsgMatcher, msg) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  let assertErr = new Assertion(fn2, msg, assert2.throws, true).to.throw(
+  let assertErr = new Assertion(fn2, msg, assert.throws, true).to.throw(
     errorLike,
     errMsgMatcher
   );
   return flag(assertErr, "object");
 };
-assert2.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
+assert.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn2, message, assert2.doesNotThrow, true).to.not.throw(
+  new Assertion(fn2, message, assert.doesNotThrow, true).to.not.throw(
     errorLike,
     errMsgMatcher
   );
 };
-assert2.operator = function(val, operator, val2, msg) {
+assert.operator = function(val, operator, val2, msg) {
   let ok;
   switch (operator) {
     case "==":
@@ -10351,162 +10351,162 @@ assert2.operator = function(val, operator, val2, msg) {
       throw new AssertionError(
         msg + 'Invalid operator "' + operator + '"',
         void 0,
-        assert2.operator
+        assert.operator
       );
   }
-  let test22 = new Assertion(ok, msg, assert2.operator, true);
+  let test22 = new Assertion(ok, msg, assert.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)
   );
 };
-assert2.closeTo = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert2.closeTo, true).to.be.closeTo(exp, delta);
+assert.closeTo = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
 };
-assert2.approximately = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert2.approximately, true).to.be.approximately(
+assert.approximately = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert.approximately, true).to.be.approximately(
     exp,
     delta
   );
 };
-assert2.sameMembers = function(set1, set22, msg) {
-  new Assertion(set1, msg, assert2.sameMembers, true).to.have.same.members(set22);
+assert.sameMembers = function(set1, set22, msg) {
+  new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set22);
 };
-assert2.notSameMembers = function(set1, set22, msg) {
+assert.notSameMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.notSameMembers,
+    assert.notSameMembers,
     true
   ).to.not.have.same.members(set22);
 };
-assert2.sameDeepMembers = function(set1, set22, msg) {
+assert.sameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.sameDeepMembers,
+    assert.sameDeepMembers,
     true
   ).to.have.same.deep.members(set22);
 };
-assert2.notSameDeepMembers = function(set1, set22, msg) {
+assert.notSameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.notSameDeepMembers,
+    assert.notSameDeepMembers,
     true
   ).to.not.have.same.deep.members(set22);
 };
-assert2.sameOrderedMembers = function(set1, set22, msg) {
+assert.sameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.sameOrderedMembers,
+    assert.sameOrderedMembers,
     true
   ).to.have.same.ordered.members(set22);
 };
-assert2.notSameOrderedMembers = function(set1, set22, msg) {
+assert.notSameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.notSameOrderedMembers,
+    assert.notSameOrderedMembers,
     true
   ).to.not.have.same.ordered.members(set22);
 };
-assert2.sameDeepOrderedMembers = function(set1, set22, msg) {
+assert.sameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.sameDeepOrderedMembers,
+    assert.sameDeepOrderedMembers,
     true
   ).to.have.same.deep.ordered.members(set22);
 };
-assert2.notSameDeepOrderedMembers = function(set1, set22, msg) {
+assert.notSameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert2.notSameDeepOrderedMembers,
+    assert.notSameDeepOrderedMembers,
     true
   ).to.not.have.same.deep.ordered.members(set22);
 };
-assert2.includeMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert2.includeMembers, true).to.include.members(
+assert.includeMembers = function(superset, subset, msg) {
+  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
     subset
   );
 };
-assert2.notIncludeMembers = function(superset, subset, msg) {
+assert.notIncludeMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.notIncludeMembers,
+    assert.notIncludeMembers,
     true
   ).to.not.include.members(subset);
 };
-assert2.includeDeepMembers = function(superset, subset, msg) {
+assert.includeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.includeDeepMembers,
+    assert.includeDeepMembers,
     true
   ).to.include.deep.members(subset);
 };
-assert2.notIncludeDeepMembers = function(superset, subset, msg) {
+assert.notIncludeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.notIncludeDeepMembers,
+    assert.notIncludeDeepMembers,
     true
   ).to.not.include.deep.members(subset);
 };
-assert2.includeOrderedMembers = function(superset, subset, msg) {
+assert.includeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.includeOrderedMembers,
+    assert.includeOrderedMembers,
     true
   ).to.include.ordered.members(subset);
 };
-assert2.notIncludeOrderedMembers = function(superset, subset, msg) {
+assert.notIncludeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.notIncludeOrderedMembers,
+    assert.notIncludeOrderedMembers,
     true
   ).to.not.include.ordered.members(subset);
 };
-assert2.includeDeepOrderedMembers = function(superset, subset, msg) {
+assert.includeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.includeDeepOrderedMembers,
+    assert.includeDeepOrderedMembers,
     true
   ).to.include.deep.ordered.members(subset);
 };
-assert2.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert2.notIncludeDeepOrderedMembers,
+    assert.notIncludeDeepOrderedMembers,
     true
   ).to.not.include.deep.ordered.members(subset);
 };
-assert2.oneOf = function(inList, list, msg) {
-  new Assertion(inList, msg, assert2.oneOf, true).to.be.oneOf(list);
+assert.oneOf = function(inList, list, msg) {
+  new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
 };
-assert2.isIterable = function(obj, msg) {
+assert.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, assert2.isIterable);
+    throw new AssertionError(msg, void 0, assert.isIterable);
   }
 };
-assert2.changes = function(fn2, obj, prop, msg) {
+assert.changes = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.changes, true).to.change(obj, prop);
+  new Assertion(fn2, msg, assert.changes, true).to.change(obj, prop);
 };
-assert2.changesBy = function(fn2, obj, prop, delta, msg) {
+assert.changesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10515,19 +10515,19 @@ assert2.changesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.changesBy, true).to.change(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
 };
-assert2.doesNotChange = function(fn2, obj, prop, msg) {
+assert.doesNotChange = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.doesNotChange, true).to.not.change(
+  return new Assertion(fn2, msg, assert.doesNotChange, true).to.not.change(
     obj,
     prop
   );
 };
-assert2.changesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert.changesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10536,16 +10536,16 @@ assert2.changesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
 };
-assert2.increases = function(fn2, obj, prop, msg) {
+assert.increases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.increases, true).to.increase(obj, prop);
+  return new Assertion(fn2, msg, assert.increases, true).to.increase(obj, prop);
 };
-assert2.increasesBy = function(fn2, obj, prop, delta, msg) {
+assert.increasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10554,19 +10554,19 @@ assert2.increasesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.increasesBy, true).to.increase(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
 };
-assert2.doesNotIncrease = function(fn2, obj, prop, msg) {
+assert.doesNotIncrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.doesNotIncrease, true).to.not.increase(
+  return new Assertion(fn2, msg, assert.doesNotIncrease, true).to.not.increase(
     obj,
     prop
   );
 };
-assert2.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10575,16 +10575,16 @@ assert2.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
 };
-assert2.decreases = function(fn2, obj, prop, msg) {
+assert.decreases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.decreases, true).to.decrease(obj, prop);
+  return new Assertion(fn2, msg, assert.decreases, true).to.decrease(obj, prop);
 };
-assert2.decreasesBy = function(fn2, obj, prop, delta, msg) {
+assert.decreasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10593,19 +10593,19 @@ assert2.decreasesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.decreasesBy, true).to.decrease(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
 };
-assert2.doesNotDecrease = function(fn2, obj, prop, msg) {
+assert.doesNotDecrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.doesNotDecrease, true).to.not.decrease(
+  return new Assertion(fn2, msg, assert.doesNotDecrease, true).to.not.decrease(
     obj,
     prop
   );
 };
-assert2.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
+assert.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10614,9 +10614,9 @@ assert2.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert2.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+  return new Assertion(fn2, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
 };
-assert2.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     let tmpMsg = delta;
     delta = prop;
@@ -10625,41 +10625,41 @@ assert2.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert2.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
 };
-assert2.ifError = function(val) {
+assert.ifError = function(val) {
   if (val) {
     throw val;
   }
 };
-assert2.isExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isExtensible, true).to.be.extensible;
+assert.isExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
 };
-assert2.isNotExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isNotExtensible, true).to.not.be.extensible;
+assert.isNotExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
 };
-assert2.isSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isSealed, true).to.be.sealed;
+assert.isSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
 };
-assert2.isNotSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isNotSealed, true).to.not.be.sealed;
+assert.isNotSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
 };
-assert2.isFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isFrozen, true).to.be.frozen;
+assert.isFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
 };
-assert2.isNotFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert2.isNotFrozen, true).to.not.be.frozen;
+assert.isNotFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
 };
-assert2.isEmpty = function(val, msg) {
-  new Assertion(val, msg, assert2.isEmpty, true).to.be.empty;
+assert.isEmpty = function(val, msg) {
+  new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
 };
-assert2.isNotEmpty = function(val, msg) {
-  new Assertion(val, msg, assert2.isNotEmpty, true).to.not.be.empty;
+assert.isNotEmpty = function(val, msg) {
+  new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
 };
-assert2.containsSubset = function(val, exp, msg) {
+assert.containsSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.containSubset(exp);
 };
-assert2.doesNotContainSubset = function(val, exp, msg) {
+assert.doesNotContainSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.not.containSubset(exp);
 };
 var aliases = [
@@ -10680,7 +10680,7 @@ var aliases = [
   ["containsSubset", "containSubset"]
 ];
 for (const [name, as] of aliases) {
-  assert2[as] = assert2[name];
+  assert[as] = assert[name];
 }
 var used = [];
 function use(fn2) {
@@ -10690,7 +10690,7 @@ function use(fn2) {
     util: utils_exports,
     config,
     expect,
-    assert: assert2,
+    assert,
     Assertion
   }, should_exports);
   if (!~used.indexOf(fn2)) {
@@ -10835,71 +10835,71 @@ 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);
 }
 var functionToString = Function.prototype.toString;
 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]":
@@ -10907,32 +10907,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();
@@ -10941,12 +10941,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;
     }
@@ -10955,15 +10955,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) {
@@ -11017,34 +11017,34 @@ var IteratorSymbol = Symbol.iterator;
 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;
@@ -11062,9 +11062,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) {
@@ -11085,7 +11085,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)) {
@@ -11097,7 +11097,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;
     }
@@ -11136,22 +11136,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;
     }
@@ -11166,14 +11166,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`;
@@ -11861,7 +11861,7 @@ var JestChaiExpect = (chai2, utils) => {
     return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected, false);
   });
   function assertIsMock(assertion) {
-    if (!isMockFunction2(assertion._obj)) {
+    if (!isMockFunction(assertion._obj)) {
       throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
     }
   }
@@ -11901,8 +11901,8 @@ var JestChaiExpect = (chai2, utils) => {
       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);
@@ -11963,14 +11963,14 @@ var JestChaiExpect = (chai2, utils) => {
   }
   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);
@@ -12204,15 +12204,15 @@ var JestChaiExpect = (chai2, utils) => {
   });
 };
 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`;
@@ -12583,81 +12583,69 @@ function parseSingleV8Stack(raw) {
 
 // node_modules/strip-literal/dist/index.mjs
 var import_js_tokens = __toESM(require_js_tokens(), 1);
-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;
+var FILL_COMMENT = " ";
+function stripLiteralFromToken(token, fillChar, filter) {
+  if (token.type === "SingleLineComment") {
+    return FILL_COMMENT.repeat(token.value.length);
+  }
+  if (token.type === "MultiLineComment") {
+    return token.value.replace(/[^\n]/g, FILL_COMMENT);
+  }
+  if (token.type === "StringLiteral") {
+    if (!token.closed) {
+      return token.value;
     }
-    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;
 }
 
 // node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -13091,7 +13079,7 @@ var it = test3;
 var runner;
 var defaultSuite;
 var currentTestFilepath;
-function assert3(condition, message) {
+function assert2(condition, message) {
   if (!condition) {
     throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
   }
@@ -13100,12 +13088,12 @@ function getTestFilepath() {
   return currentTestFilepath;
 }
 function getRunner() {
-  assert3(runner, "the runner");
+  assert2(runner, "the runner");
   return runner;
 }
 function getCurrentSuite() {
   const currentSuite = collectorContext.currentSuite || defaultSuite;
-  assert3(currentSuite, "the current suite");
+  assert2(currentSuite, "the current suite");
   return currentSuite;
 }
 function createSuiteHooks() {
@@ -13505,8 +13493,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);
   }
@@ -13784,25 +13772,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];
     }
@@ -13906,8 +13894,8 @@ function waitForImportsToResolve() {
 
 // node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-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;
 }
 
 // node_modules/@vitest/snapshot/dist/index.js
@@ -14006,8 +13994,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];
 }
 var schemeRegex = /^[\w+.-]+:\/\//;
 var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
@@ -14221,8 +14209,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;
     }
   }
@@ -14233,8 +14221,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];
 }
 var found = false;
 function binarySearch(haystack, needle, low, high) {
@@ -14367,8 +14355,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";
@@ -14583,7 +14571,7 @@ 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;
@@ -14603,8 +14591,8 @@ try {
 } catch (notNode) {
 }
 var { AsymmetricMatcher: AsymmetricMatcher$1, DOMCollection: DOMCollection$1, DOMElement: DOMElement$1, Immutable: Immutable$1, ReactElement: ReactElement$1, ReactTestComponent: ReactTestComponent$1 } = plugins;
-function getDefaultExportFromCjs4(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;
 }
 var jsTokens_12;
 var hasRequiredJsTokens2;
@@ -15052,7 +15040,7 @@ var reservedWords2 = {
 };
 new Set(reservedWords2.keyword);
 new Set(reservedWords2.strict);
-var f2 = {
+var f3 = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
   dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -15095,7 +15083,7 @@ var f2 = {
   bgCyanBright: [106, 49],
   bgWhiteBright: [107, 49]
 };
-var h2 = Object.entries(f2);
+var h3 = Object.entries(f3);
 function a2(n2) {
   return String(n2);
 }
@@ -15107,27 +15095,27 @@ function C2(n2 = false) {
 }
 function p2(n2 = false) {
   let e = C2(n2), 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;
 }
 p2();
 var lineSplitRE = /\r?\n/;
@@ -15316,7 +15304,7 @@ var hasRequiredNaturalCompare;
 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) {
@@ -15326,12 +15314,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;
@@ -15523,14 +15511,14 @@ var CounterMap = class extends DefaultMap {
       return this._total;
     }
     let total = 0;
-    for (const x of this.values()) {
-      total += x;
+    for (const x2 of this.values()) {
+      total += x2;
     }
     return total;
   }
 };
-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;
 }
 var SnapshotState = class _SnapshotState {
   constructor(testFilePath, snapshotPath, snapshotContent, options) {
@@ -15957,7 +15945,7 @@ var SnapshotClient = class {
 var RealDate = Date;
 var now2 = null;
 var 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) {
@@ -15966,15 +15954,15 @@ var MockDate = class _MockDate extends RealDate {
         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);
@@ -16373,11 +16361,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]);
@@ -16403,7 +16391,7 @@ function createExpect(test5) {
   };
   expect2.poll = createExpectPoll(expect2);
   expect2.unreachable = (message) => {
-    assert2.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+    assert.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}`);
@@ -16520,10 +16508,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;
@@ -16531,9 +16519,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;
@@ -16630,15 +16618,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;
@@ -16965,11 +16953,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"
         );
@@ -16979,7 +16967,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;
     }
@@ -17218,29 +17206,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;
       }
     }
@@ -17351,10 +17339,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];
@@ -17385,14 +17373,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;
           }
         }
@@ -17897,7 +17885,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
         };
       }
-      clock.reset = function reset2() {
+      clock.reset = function reset() {
         nanos = 0;
         clock.timers = {};
         clock.jobs = [];
@@ -17968,7 +17956,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() {
@@ -18019,7 +18007,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);
@@ -18624,7 +18612,7 @@ function createVitest() {
       return item;
     },
     isMockFunction(fn2) {
-      return isMockFunction2(fn2);
+      return isMockFunction(fn2);
     },
     clearAllMocks() {
       [...mocks].reverse().forEach((spy) => spy.mockClear());
@@ -18714,7 +18702,7 @@ var import_expect_type = __toESM(require_dist(), 1);
 var import_node_crypto = require("crypto");
 
 // package.json
-var version = "2.0.4";
+var version = "2.1.1";
 
 // src/internal/blindpay-error.ts
 var BlindPayError = class extends Error {
@@ -19023,6 +19011,20 @@ function createReceiversResource(instanceId, client) {
     },
     getLimits(receiver_id) {
       return client.get(`/instances/${instanceId}/limits/receivers/${receiver_id}`);
+    },
+    getLimitIncreaseRequests(receiver_id) {
+      return client.get(`/instances/${instanceId}/receivers/${receiver_id}/limit-increase`);
+    },
+    requestLimitIncrease(_c) {
+      var _d = _c, {
+        receiver_id
+      } = _d, data = __objRest(_d, [
+        "receiver_id"
+      ]);
+      return client.post(
+        `/instances/${instanceId}/receivers/${receiver_id}/limit-increase`,
+        data
+      );
     }
   };
 }
@@ -19765,6 +19767,62 @@ describe("Receivers", () => {
       globalExpect(data).toEqual(mockedReceiverLimits);
     }));
   });
+  describe("Get limit increase requests", () => {
+    it("should get limit increase requests for a receiver", () => __async(null, null, function* () {
+      const mockedLimitIncreaseRequests = [
+        {
+          id: "rl_000000000000",
+          receiver_id: "re_YuaMcI2B8zbQ",
+          status: "in_review",
+          daily: 5e4,
+          monthly: 25e4,
+          per_transaction: 25e3,
+          supporting_document_file: "https://example.com/bank-statement.pdf",
+          supporting_document_type: "individual_bank_statement",
+          created_at: "2025-01-15T10:30:00.000Z",
+          updated_at: "2025-01-15T10:30:00.000Z"
+        },
+        {
+          id: "rl_000000000000",
+          receiver_id: "re_YuaMcI2B8zbQ",
+          status: "approved",
+          daily: 3e4,
+          monthly: 15e4,
+          per_transaction: 15e3,
+          supporting_document_file: "https://example.com/proof-of-income.pdf",
+          supporting_document_type: "individual_proof_of_income",
+          created_at: "2024-12-10T14:20:00.000Z",
+          updated_at: "2024-12-12T09:45:00.000Z"
+        }
+      ];
+      fetchMock.mockResponseOnce(JSON.stringify(mockedLimitIncreaseRequests), {
+        headers: { "Content-Type": "application/json" }
+      });
+      const { data, error } = yield blindpay.receivers.getLimitIncreaseRequests("re_YuaMcI2B8zbQ");
+      globalExpect(error).toBeNull();
+      globalExpect(data).toEqual(mockedLimitIncreaseRequests);
+    }));
+  });
+  describe("Request limit increase", () => {
+    it("should request a limit increase for a receiver", () => __async(null, null, function* () {
+      const mockedResponse = {
+        id: "rl_000000000000"
+      };
+      fetchMock.mockResponseOnce(JSON.stringify(mockedResponse), {
+        headers: { "Content-Type": "application/json" }
+      });
+      const { data, error } = yield blindpay.receivers.requestLimitIncrease({
+        receiver_id: "re_YuaMcI2B8zbQ",
+        daily: 1e5,
+        monthly: 5e5,
+        per_transaction: 5e4,
+        supporting_document_file: "https://example.com/tax-return.pdf",
+        supporting_document_type: "individual_tax_return"
+      });
+      globalExpect(error).toBeNull();
+      globalExpect(data).toEqual(mockedResponse);
+    }));
+  });
 });
 /*! Bundled license information: