@prisma/internals 7.7.0-dev.2 → 7.7.0-dev.4

package/dist/{chunk-3TFDMTMW.js → chunk-VFNP7Q3Y.js}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_3TFDMTMW_exports = {};
-__export(chunk_3TFDMTMW_exports, {
+var chunk_VFNP7Q3Y_exports = {};
+__export(chunk_VFNP7Q3Y_exports, {
   afterAll: () => afterAll,
   beforeEach: () => beforeEach,
   describe: () => describe,
@@ -35,16 +35,16 @@ __export(chunk_3TFDMTMW_exports, {
   test: () => test2,
   vi: () => vi
 });
-module.exports = __toCommonJS(chunk_3TFDMTMW_exports);
+module.exports = __toCommonJS(chunk_VFNP7Q3Y_exports);
 var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
 var require_branding = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/branding.js"(exports) {
+  "../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/branding.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
   }
 });
 var require_messages = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/messages.js"(exports) {
+  "../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/messages.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var inverted = Symbol("inverted");
@@ -66,13 +66,13 @@ var require_messages = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_overloads = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/overloads.js"(exports) {
+  "../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/overloads.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
   }
 });
 var require_utils = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/utils.js"(exports) {
+  "../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/utils.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var secret = Symbol("secret");
@@ -81,7 +81,7 @@ var require_utils = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_dist = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/index.js"(exports) {
+  "../../node_modules/.pnpm/expect-type@1.3.0/node_modules/expect-type/dist/index.js"(exports) {
     "use strict";
     var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
       if (k2 === void 0) k2 = k;
@@ -158,7 +158,7 @@ var require_dist = (0, import_chunk_4VNS5WPM.__commonJS)({
     exports.expectTypeOf = expectTypeOf2;
   }
 });
-var d = {
+var b = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
   dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -201,42 +201,43 @@ var d = {
   bgCyanBright: [106, 49],
   bgWhiteBright: [107, 49]
 };
-function g(e) {
+function i(e) {
   return String(e);
 }
-g.open = "";
-g.close = "";
-function h() {
-  let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
-  return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+i.open = "";
+i.close = "";
+function B() {
+  let e = typeof process != "undefined" ? process : void 0, r = (e == null ? void 0 : e.env) || {}, a = r.FORCE_TTY !== "false", l = (e == null ? void 0 : e.argv) || [];
+  return !("NO_COLOR" in r || l.includes("--no-color")) && ("FORCE_COLOR" in r || l.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && r.TERM !== "dumb" || "CI" in r) || typeof window != "undefined" && !!window.chrome;
 }
-function f() {
-  let e = h(), n = (r, t, u, o) => {
-    let l = "", s = 0;
+function C({ force: e } = {}) {
+  let r = e || B(), a = (t, o, u, n) => {
+    let g = "", s = 0;
     do
-      l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
-    while (~o);
-    return l + r.substring(s);
-  }, a = (r, t, u = r) => {
-    let o = (l) => {
-      let s = String(l), b = s.indexOf(t, r.length);
-      return ~b ? r + n(s, t, u, b) + t : r + s + t;
+      g += t.substring(s, n) + u, s = n + o.length, n = t.indexOf(o, s);
+    while (~n);
+    return g + t.substring(s);
+  }, l = (t, o, u = t) => {
+    let n = (g) => {
+      let s = String(g), h = s.indexOf(o, t.length);
+      return ~h ? t + a(s, o, u, h) + o : t + s + o;
     };
-    return o.open = r, o.close = t, o;
-  }, i = {
-    isColorSupported: e
-  }, c = (r) => `\x1B[${r}m`;
-  for (let r in d) {
-    let t = d[r];
-    i[r] = e ? a(
-      c(t[0]),
-      c(t[1]),
-      t[2]
-    ) : g;
-  }
-  return i;
-}
-var C = f();
+    return n.open = t, n.close = o, n;
+  }, c = {
+    isColorSupported: r
+  }, f = (t) => `\x1B[${t}m`;
+  for (let t in b) {
+    let o = b[t];
+    c[t] = r ? l(
+      f(o[0]),
+      f(o[1]),
+      o[2]
+    ) : i;
+  }
+  return c;
+}
+var d = C();
+var y = d;
 function _mergeNamespaces(n, m) {
   m.forEach(function(e) {
     e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
@@ -325,16 +326,16 @@ function printListItems(list, config2, indentation, depth, refs, printer2) {
   if (length > 0) {
     result += config2.spacingOuter;
     const indentationNext = indentation + config2.indent;
-    for (let i = 0; i < length; i++) {
+    for (let i2 = 0; i2 < length; i2++) {
       result += indentationNext;
-      if (i === config2.maxWidth) {
+      if (i2 === config2.maxWidth) {
         result += "\u2026";
         break;
       }
-      if (isDataView(list) || i in list) {
-        result += printer2(isDataView(list) ? list.getInt8(i) : list[i], config2, indentationNext, depth, refs);
+      if (isDataView(list) || i2 in list) {
+        result += printer2(isDataView(list) ? list.getInt8(i2) : list[i2], config2, indentationNext, depth, refs);
       }
-      if (i < length - 1) {
+      if (i2 < length - 1) {
         result += `,${config2.spacingInner}`;
       } else if (!config2.min) {
         result += ",";
@@ -350,12 +351,12 @@ function printObjectProperties(val, config2, indentation, depth, refs, printer2)
   if (keys2.length > 0) {
     result += config2.spacingOuter;
     const indentationNext = indentation + config2.indent;
-    for (let i = 0; i < keys2.length; i++) {
-      const key = keys2[i];
+    for (let i2 = 0; i2 < keys2.length; i2++) {
+      const key = keys2[i2];
       const name = printer2(key, config2, indentationNext, depth, refs);
       const value = printer2(val[key], config2, indentationNext, depth, refs);
       result += `${indentationNext + name}: ${value}`;
-      if (i < keys2.length - 1) {
+      if (i2 < keys2.length - 1) {
         result += `,${config2.spacingInner}`;
       } else if (!config2.min) {
         result += ",";
@@ -532,10 +533,10 @@ function printImmutableEntries(val, config2, indentation, depth, refs, printer2,
   return ++depth > config2.maxDepth ? printAsLeaf(getImmutableName(type3)) : `${getImmutableName(type3) + SPACE}{${printIteratorEntries(val.entries(), config2, indentation, depth, refs, printer2)}}`;
 }
 function getRecordEntries(val) {
-  let i = 0;
+  let i2 = 0;
   return { next() {
-    if (i < val._keys.length) {
-      const key = val._keys[i++];
+    if (i2 < val._keys.length) {
+      const key = val._keys[i2++];
       return {
         done: false,
         value: [key, val.get(key)]
@@ -703,16 +704,16 @@ 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"), d2 = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f2 = Symbol.for("react.profiler"), g2 = Symbol.for("react.provider"), h2 = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
+  var b2 = Symbol.for("react.element"), c = Symbol.for("react.portal"), d2 = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
   u = Symbol.for("react.module.reference");
   function v(a) {
     if ("object" === typeof a && null !== a) {
       var r = a.$$typeof;
       switch (r) {
-        case b:
+        case b2:
           switch (a = a.type, a) {
             case d2:
-            case f2:
+            case f:
             case e:
             case m:
             case n:
@@ -720,11 +721,11 @@ function requireReactIs_production_min() {
             default:
               switch (a = a && a.$$typeof, a) {
                 case k:
-                case h2:
+                case h:
                 case l:
                 case q:
                 case p:
-                case g2:
+                case g:
                   return a;
                 default:
                   return r;
@@ -735,15 +736,15 @@ function requireReactIs_production_min() {
       }
     }
   }
-  reactIs_production_min.ContextConsumer = h2;
-  reactIs_production_min.ContextProvider = g2;
-  reactIs_production_min.Element = b;
+  reactIs_production_min.ContextConsumer = h;
+  reactIs_production_min.ContextProvider = g;
+  reactIs_production_min.Element = b2;
   reactIs_production_min.ForwardRef = l;
   reactIs_production_min.Fragment = d2;
   reactIs_production_min.Lazy = q;
   reactIs_production_min.Memo = p;
   reactIs_production_min.Portal = c;
-  reactIs_production_min.Profiler = f2;
+  reactIs_production_min.Profiler = f;
   reactIs_production_min.StrictMode = e;
   reactIs_production_min.Suspense = m;
   reactIs_production_min.SuspenseList = n;
@@ -754,13 +755,13 @@ function requireReactIs_production_min() {
     return false;
   };
   reactIs_production_min.isContextConsumer = function(a) {
-    return v(a) === h2;
+    return v(a) === h;
   };
   reactIs_production_min.isContextProvider = function(a) {
-    return v(a) === g2;
+    return v(a) === g;
   };
   reactIs_production_min.isElement = function(a) {
-    return "object" === typeof a && null !== a && a.$$typeof === b;
+    return "object" === typeof a && null !== a && a.$$typeof === b2;
   };
   reactIs_production_min.isForwardRef = function(a) {
     return v(a) === l;
@@ -778,7 +779,7 @@ function requireReactIs_production_min() {
     return v(a) === c;
   };
   reactIs_production_min.isProfiler = function(a) {
-    return v(a) === f2;
+    return v(a) === f;
   };
   reactIs_production_min.isStrictMode = function(a) {
     return v(a) === e;
@@ -790,7 +791,7 @@ function requireReactIs_production_min() {
     return v(a) === n;
   };
   reactIs_production_min.isValidElementType = function(a) {
-    return "string" === typeof a || "function" === typeof a || a === d2 || a === f2 || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g2 || a.$$typeof === h2 || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+    return "string" === typeof a || "function" === typeof a || a === d2 || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
   };
   reactIs_production_min.typeOf = v;
   return reactIs_production_min;
@@ -1121,7 +1122,7 @@ function validateOptions(options) {
 function getColorsHighlight() {
   return DEFAULT_THEME_KEYS.reduce((colors, key) => {
     const value = DEFAULT_THEME[key];
-    const color = value && C[value];
+    const color = value && y[value];
     if (color && typeof color.close === "string" && typeof color.open === "string") {
       colors[key] = color;
     } else {
@@ -1303,11 +1304,11 @@ function inspectList(list, options, inspectItem, separator = ", ") {
   let output = "";
   let peek = "";
   let truncated = "";
-  for (let i = 0; i < size; i += 1) {
-    const last = i + 1 === list.length;
-    const secondToLast = i + 2 === list.length;
-    truncated = `${truncator}(${list.length - i})`;
-    const value = list[i];
+  for (let i2 = 0; i2 < size; i2 += 1) {
+    const last = i2 + 1 === list.length;
+    const secondToLast = i2 + 2 === list.length;
+    truncated = `${truncator}(${list.length - i2})`;
+    const value = list[i2];
     options.truncate = originalLength - output.length - (last ? 0 : separator.length);
     const string2 = peek || inspectItem(value, options) + (last ? "" : separator);
     const nextLength = output.length + string2.length;
@@ -1318,13 +1319,13 @@ function inspectList(list, options, inspectItem, separator = ", ") {
     if (!last && !secondToLast && truncatedLength > originalLength) {
       break;
     }
-    peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);
+    peek = last ? "" : inspectItem(list[i2 + 1], options) + (secondToLast ? "" : separator);
     if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
       break;
     }
     output += string2;
     if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
-      truncated = `${truncator}(${list.length - i - 1})`;
+      truncated = `${truncator}(${list.length - i2 - 1})`;
       break;
     }
     truncated = "";
@@ -1377,11 +1378,11 @@ function inspectTypedArray(array2, options) {
   if (!array2.length && !nonIndexProperties.length)
     return `${name}[]`;
   let output = "";
-  for (let i = 0; i < array2.length; i++) {
-    const string2 = `${options.stylize(truncate(array2[i], options.truncate), "number")}${i === array2.length - 1 ? "" : ", "}`;
+  for (let i2 = 0; i2 < array2.length; i2++) {
+    const string2 = `${options.stylize(truncate(array2[i2], options.truncate), "number")}${i2 === array2.length - 1 ? "" : ", "}`;
     options.truncate -= string2.length;
-    if (array2[i] !== array2.length && options.truncate <= 3) {
-      output += `${truncator}(${array2.length - array2[i] + 1})`;
+    if (array2[i2] !== array2.length && options.truncate <= 3) {
+      output += `${truncator}(${array2.length - array2[i2] + 1})`;
       break;
     }
     output += string2;
@@ -1429,7 +1430,7 @@ function inspectMap(map2, options) {
   options.truncate -= 7;
   return `Map{ ${inspectList(mapToEntries(map2), options, inspectMapEntry)} }`;
 }
-var isNaN = Number.isNaN || ((i) => i !== i);
+var isNaN = Number.isNaN || ((i2) => i2 !== i2);
 function inspectNumber(number, options) {
   if (isNaN(number)) {
     return options.stylize("NaN", "number");
@@ -1758,8 +1759,8 @@ function baseFormat(args, options = {}) {
   };
   if (typeof args[0] !== "string") {
     const objects = [];
-    for (let i2 = 0; i2 < args.length; i2++) {
-      objects.push(formatArg(args[i2], {
+    for (let i3 = 0; i3 < args.length; i3++) {
+      objects.push(formatArg(args[i3], {
         depth: 0,
         colors: false
       }));
@@ -1767,18 +1768,18 @@ function baseFormat(args, options = {}) {
     return objects.join(" ");
   }
   const len = args.length;
-  let i = 1;
+  let i2 = 1;
   const template = args[0];
   let str = String(template).replace(formatRegExp, (x) => {
     if (x === "%%") {
       return "%";
     }
-    if (i >= len) {
+    if (i2 >= len) {
       return x;
     }
     switch (x) {
       case "%s": {
-        const value = args[i++];
+        const value = args[i2++];
         if (typeof value === "bigint") {
           return `${value.toString()}n`;
         }
@@ -1797,35 +1798,35 @@ function baseFormat(args, options = {}) {
         return String(value);
       }
       case "%d": {
-        const value = args[i++];
+        const value = args[i2++];
         if (typeof value === "bigint") {
           return `${value.toString()}n`;
         }
         return Number(value).toString();
       }
       case "%i": {
-        const value = args[i++];
+        const value = args[i2++];
         if (typeof value === "bigint") {
           return `${value.toString()}n`;
         }
         return Number.parseInt(String(value)).toString();
       }
       case "%f":
-        return Number.parseFloat(String(args[i++])).toString();
+        return Number.parseFloat(String(args[i2++])).toString();
       case "%o":
-        return formatArg(args[i++], {
+        return formatArg(args[i2++], {
           showHidden: true,
           showProxy: true
         });
       case "%O":
-        return formatArg(args[i++]);
+        return formatArg(args[i2++]);
       case "%c": {
-        i++;
+        i2++;
         return "";
       }
       case "%j":
         try {
-          return JSON.stringify(args[i++]);
+          return JSON.stringify(args[i2++]);
         } catch (err) {
           const m = err.message;
           if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) {
@@ -1837,7 +1838,7 @@ function baseFormat(args, options = {}) {
         return x;
     }
   });
-  for (let x = args[i]; i < len; x = args[++i]) {
+  for (let x = args[i2]; i2 < len; x = args[++i2]) {
     if (x === null || typeof x !== "object") {
       str += ` ${x}`;
     } else {
@@ -2851,34 +2852,34 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   let jLength = iLength;
   let hasExcessAtStartOrEnd = false;
   let nExcessesBetweenChanges = 0;
-  let i = 0;
-  while (i !== iLength) {
-    const iStart = i;
-    while (i !== iLength && diffs[i][0] === DIFF_EQUAL) {
-      i += 1;
+  let i2 = 0;
+  while (i2 !== iLength) {
+    const iStart = i2;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_EQUAL) {
+      i2 += 1;
     }
-    if (iStart !== i) {
+    if (iStart !== i2) {
       if (iStart === 0) {
-        if (i > nContextLines) {
-          jLength -= i - nContextLines;
+        if (i2 > nContextLines) {
+          jLength -= i2 - nContextLines;
           hasExcessAtStartOrEnd = true;
         }
-      } else if (i === iLength) {
-        const n = i - iStart;
+      } else if (i2 === iLength) {
+        const n = i2 - iStart;
         if (n > nContextLines) {
           jLength -= n - nContextLines;
           hasExcessAtStartOrEnd = true;
         }
       } else {
-        const n = i - iStart;
+        const n = i2 - iStart;
         if (n > nContextLines2) {
           jLength -= n - nContextLines2;
           nExcessesBetweenChanges += 1;
         }
       }
     }
-    while (i !== iLength && diffs[i][0] !== DIFF_EQUAL) {
-      i += 1;
+    while (i2 !== iLength && diffs[i2][0] !== DIFF_EQUAL) {
+      i2 += 1;
     }
   }
   const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
@@ -2913,31 +2914,31 @@ function joinAlignedDiffsNoExpand(diffs, options) {
     lines.push(printInsertLine(line, j === 0 || j === jLast, options));
     bEnd += 1;
   };
-  i = 0;
-  while (i !== iLength) {
-    let iStart = i;
-    while (i !== iLength && diffs[i][0] === DIFF_EQUAL) {
-      i += 1;
+  i2 = 0;
+  while (i2 !== iLength) {
+    let iStart = i2;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_EQUAL) {
+      i2 += 1;
     }
-    if (iStart !== i) {
+    if (iStart !== i2) {
       if (iStart === 0) {
-        if (i > nContextLines) {
-          iStart = i - nContextLines;
+        if (i2 > nContextLines) {
+          iStart = i2 - nContextLines;
           aStart = iStart;
           bStart = iStart;
           aEnd = aStart;
           bEnd = bStart;
         }
-        for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
+        for (let iCommon = iStart; iCommon !== i2; iCommon += 1) {
           pushCommonLine(diffs[iCommon][1]);
         }
-      } else if (i === iLength) {
-        const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
+      } else if (i2 === iLength) {
+        const iEnd = i2 - iStart > nContextLines ? iStart + nContextLines : i2;
         for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
           pushCommonLine(diffs[iCommon][1]);
         }
       } else {
-        const nCommon = i - iStart;
+        const nCommon = i2 - iStart;
         if (nCommon > nContextLines2) {
           const iEnd = iStart + nContextLines;
           for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
@@ -2951,23 +2952,23 @@ function joinAlignedDiffsNoExpand(diffs, options) {
           bStart = bEnd + nOmit;
           aEnd = aStart;
           bEnd = bStart;
-          for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) {
+          for (let iCommon = i2 - nContextLines; iCommon !== i2; iCommon += 1) {
             pushCommonLine(diffs[iCommon][1]);
           }
         } else {
-          for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
+          for (let iCommon = iStart; iCommon !== i2; iCommon += 1) {
             pushCommonLine(diffs[iCommon][1]);
           }
         }
       }
     }
-    while (i !== iLength && diffs[i][0] === DIFF_DELETE) {
-      pushDeleteLine(diffs[i][1]);
-      i += 1;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_DELETE) {
+      pushDeleteLine(diffs[i2][1]);
+      i2 += 1;
     }
-    while (i !== iLength && diffs[i][0] === DIFF_INSERT) {
-      pushInsertLine(diffs[i][1]);
-      i += 1;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_INSERT) {
+      pushInsertLine(diffs[i2][1]);
+      i2 += 1;
     }
   }
   if (hasPatch) {
@@ -2976,9 +2977,9 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   return lines.join("\n");
 }
 function joinAlignedDiffsExpand(diffs, options) {
-  return diffs.map((diff2, i, diffs2) => {
+  return diffs.map((diff2, i2, diffs2) => {
     const line = diff2[1];
-    const isFirstOrLast = i === 0 || i === diffs2.length - 1;
+    const isFirstOrLast = i2 === 0 || i2 === diffs2.length - 1;
     switch (diff2[0]) {
       case DIFF_DELETE:
         return printDeleteLine(line, isFirstOrLast, options);
@@ -2995,14 +2996,14 @@ var DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;
 function getDefaultOptions() {
   return {
     aAnnotation: "Expected",
-    aColor: C.green,
+    aColor: y.green,
     aIndicator: "-",
     bAnnotation: "Received",
-    bColor: C.red,
+    bColor: y.red,
     bIndicator: "+",
-    changeColor: C.inverse,
+    changeColor: y.inverse,
     changeLineTrailingSpaceColor: noColor,
-    commonColor: C.dim,
+    commonColor: y.dim,
     commonIndicator: " ",
     commonLineTrailingSpaceColor: noColor,
     compareKeys: void 0,
@@ -3011,7 +3012,7 @@ function getDefaultOptions() {
     expand: false,
     includeChangeCounts: false,
     omitAnnotationLines: false,
-    patchColor: C.yellow,
+    patchColor: y.yellow,
     printBasicPrototype: false,
     truncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,
     truncateAnnotation: "... Diff result is truncated",
@@ -3037,20 +3038,20 @@ function isEmptyString(lines) {
 }
 function countChanges(diffs) {
   let a = 0;
-  let b = 0;
+  let b2 = 0;
   diffs.forEach((diff2) => {
     switch (diff2[0]) {
       case DIFF_DELETE:
         a += 1;
         break;
       case DIFF_INSERT:
-        b += 1;
+        b2 += 1;
         break;
     }
   });
   return {
     a,
-    b
+    b: b2
   };
 }
 function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
@@ -3072,9 +3073,9 @@ function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor,
     bRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;
   }
   const a = `${aIndicator} ${aAnnotation}${aRest}`;
-  const b = `${bIndicator} ${bAnnotation}${bRest}`;
+  const b2 = `${bIndicator} ${bAnnotation}${bRest}`;
   return `${aColor(a)}
-${bColor(b)}
+${bColor(b2)}
 
 `;
 }
@@ -3188,25 +3189,25 @@ function getType3(value) {
 function getNewLineSymbol(string2) {
   return string2.includes("\r\n") ? "\r\n" : "\n";
 }
-function diffStrings(a, b, options) {
+function diffStrings(a, b2, options) {
   const truncate3 = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
   const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? 0), 0);
   let aLength = a.length;
-  let bLength = b.length;
+  let bLength = b2.length;
   if (truncate3) {
     const aMultipleLines = a.includes("\n");
-    const bMultipleLines = b.includes("\n");
+    const bMultipleLines = b2.includes("\n");
     const aNewLineSymbol = getNewLineSymbol(a);
-    const bNewLineSymbol = getNewLineSymbol(b);
+    const bNewLineSymbol = getNewLineSymbol(b2);
     const _a = aMultipleLines ? `${a.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
 ` : a;
-    const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
-` : b;
+    const _b = bMultipleLines ? `${b2.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
+` : b2;
     aLength = _a.length;
     bLength = _b.length;
   }
-  const truncated = aLength !== a.length || bLength !== b.length;
-  const isCommon = (aIndex2, bIndex2) => a[aIndex2] === b[bIndex2];
+  const truncated = aLength !== a.length || bLength !== b2.length;
+  const isCommon = (aIndex2, bIndex2) => a[aIndex2] === b2[bIndex2];
   let aIndex = 0;
   let bIndex = 0;
   const diffs = [];
@@ -3215,18 +3216,18 @@ function diffStrings(a, b, options) {
       diffs.push(new Diff(DIFF_DELETE, a.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, a.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];
 }
@@ -3264,8 +3265,8 @@ var ChangeBuffer = class {
     if (string2.includes("\n")) {
       const substrings = string2.split("\n");
       const iLast = substrings.length - 1;
-      substrings.forEach((substring, i) => {
-        if (i < iLast) {
+      substrings.forEach((substring, i2) => {
+        if (i2 < iLast) {
           this.pushSubstring(substring);
           this.pushLine();
         } else if (substring.length !== 0) {
@@ -3317,8 +3318,8 @@ var CommonBuffer = class {
     if (string2.includes("\n")) {
       const substrings = string2.split("\n");
       const iLast = substrings.length - 1;
-      substrings.forEach((substring, i) => {
-        if (i === 0) {
+      substrings.forEach((substring, i2) => {
+        if (i2 === 0) {
           const subdiff = new Diff(op, substring);
           if (this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty()) {
             this.flushChangeLines();
@@ -3327,7 +3328,7 @@ var CommonBuffer = class {
             this.pushDiffChangeLines(subdiff);
             this.flushChangeLines();
           }
-        } else if (i < iLast) {
+        } else if (i2 < iLast) {
           this.pushDiffCommonLine(new Diff(op, substring));
         } else if (substring.length !== 0) {
           this.pushDiffChangeLines(new Diff(op, substring));
@@ -3364,26 +3365,26 @@ function getAlignedDiffs(diffs, changeColor) {
 function hasCommonDiff(diffs, isMultiline) {
   if (isMultiline) {
     const iLast = diffs.length - 1;
-    return diffs.some((diff2, i) => diff2[0] === DIFF_EQUAL && (i !== iLast || diff2[1] !== "\n"));
+    return diffs.some((diff2, i2) => diff2[0] === DIFF_EQUAL && (i2 !== iLast || diff2[1] !== "\n"));
   }
   return diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
 }
-function diffStringsUnified(a, b, options) {
-  if (a !== b && a.length !== 0 && b.length !== 0) {
-    const isMultiline = a.includes("\n") || b.includes("\n");
+function diffStringsUnified(a, b2, options) {
+  if (a !== b2 && a.length !== 0 && b2.length !== 0) {
+    const isMultiline = a.includes("\n") || b2.includes("\n");
     const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a}
-` : a, isMultiline ? `${b}
-` : b, true, options);
+` : a, 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(a.split("\n"), b.split("\n"), options);
+  return diffLinesUnified(a.split("\n"), b2.split("\n"), options);
 }
-function diffStringsRaw(a, b, cleanup, options) {
-  const [diffs, truncated] = diffStrings(a, b, options);
+function diffStringsRaw(a, b2, cleanup, options) {
+  const [diffs, truncated] = diffStrings(a, b2, options);
   if (cleanup) {
     diff_cleanupSemantic(diffs);
   }
@@ -3412,8 +3413,8 @@ var FALLBACK_FORMAT_OPTIONS = {
   maxDepth: 8,
   plugins: PLUGINS2
 };
-function diff(a, b, options) {
-  if (Object.is(a, b)) {
+function diff(a, b2, options) {
+  if (Object.is(a, b2)) {
     return "";
   }
   const aType = getType3(a);
@@ -3429,7 +3430,7 @@ function diff(a, b, options) {
     expectedType = a.getExpectedType();
     omitDifference = expectedType === "string";
   }
-  if (expectedType !== getType3(b)) {
+  if (expectedType !== getType3(b2)) {
     let truncate4 = function(s) {
       return s.length <= MAX_LENGTH ? s : `${s.slice(0, MAX_LENGTH)}...`;
     };
@@ -3437,7 +3438,7 @@ function diff(a, b, options) {
     const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
     let aDisplay = format(a, formatOptions);
-    let bDisplay = format(b, formatOptions);
+    let bDisplay = format(b2, formatOptions);
     const MAX_LENGTH = 1e5;
     aDisplay = truncate4(aDisplay);
     bDisplay = truncate4(bDisplay);
@@ -3454,21 +3455,21 @@ ${bDiff}`;
   }
   switch (aType) {
     case "string":
-      return diffLinesUnified(a.split("\n"), b.split("\n"), options);
+      return diffLinesUnified(a.split("\n"), b2.split("\n"), options);
     case "boolean":
     case "number":
-      return comparePrimitive(a, b, options);
+      return comparePrimitive(a, b2, options);
     case "map":
-      return compareObjects(sortMap(a), sortMap(b), options);
+      return compareObjects(sortMap(a), sortMap(b2), options);
     case "set":
-      return compareObjects(sortSet(a), sortSet(b), options);
+      return compareObjects(sortSet(a), sortSet(b2), options);
     default:
-      return compareObjects(a, b, options);
+      return compareObjects(a, b2, options);
   }
 }
-function comparePrimitive(a, b, options) {
+function comparePrimitive(a, b2, options) {
   const aFormat = format(a, 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) {
@@ -3477,19 +3478,19 @@ function sortMap(map2) {
 function sortSet(set3) {
   return new Set(Array.from(set3.values()).sort());
 }
-function compareObjects(a, b, options) {
+function compareObjects(a, b2, options) {
   let difference;
   let hasThrown = false;
   try {
     const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a, b, formatOptions, options);
+    difference = getObjectsDifference(a, b2, formatOptions, options);
   } catch {
     hasThrown = true;
   }
   const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
   if (difference === void 0 || difference === noDiffMessage) {
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a, b, formatOptions, options);
+    difference = getObjectsDifference(a, b2, formatOptions, options);
     if (difference !== noDiffMessage && !hasThrown) {
       difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
 
@@ -3507,18 +3508,18 @@ function getFormatOptions(formatOptions, options) {
     maxDepth: maxDepth ?? formatOptions.maxDepth
   };
 }
-function getObjectsDifference(a, b, formatOptions, options) {
+function getObjectsDifference(a, b2, formatOptions, options) {
   const formatOptionsZeroIndent = {
     ...formatOptions,
     indent: 0
   };
   const aCompare = format(a, formatOptionsZeroIndent);
-  const bCompare = format(b, formatOptionsZeroIndent);
+  const bCompare = format(b2, formatOptionsZeroIndent);
   if (aCompare === bCompare) {
     return getCommonMessage(NO_DIFF_MESSAGE, options);
   } else {
     const aDisplay = format(a, 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);
   }
 }
@@ -3613,13 +3614,13 @@ function replaceTrailingSpaces(text) {
   return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
 }
 function printReceived(object2) {
-  return C.red(replaceTrailingSpaces(stringify(object2)));
+  return y.red(replaceTrailingSpaces(stringify(object2)));
 }
 function printExpected(value) {
-  return C.green(replaceTrailingSpaces(stringify(value)));
+  return y.green(replaceTrailingSpaces(stringify(value)));
 }
 function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
-  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? C.inverse(diff2[1]) : diff2[1] : ""), "");
+  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? y.inverse(diff2[1]) : diff2[1] : ""), "");
 }
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
@@ -3691,11 +3692,11 @@ function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
   if (Array.isArray(val)) {
     const clone2 = new Array(val.length);
     seen.set(val, clone2);
-    val.forEach((e, i) => {
+    val.forEach((e, i2) => {
       try {
-        clone2[i] = serializeValue(e, seen);
+        clone2[i2] = serializeValue(e, seen);
       } catch (err) {
-        clone2[i] = getUnserializableMessage(err);
+        clone2[i2] = getUnserializableMessage(err);
       }
     });
     return clone2;
@@ -3880,10 +3881,10 @@ var comma = ",".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar = new Uint8Array(64);
 var charToInt = new Uint8Array(128);
-for (let i = 0; i < chars.length; i++) {
-  const c = chars.charCodeAt(i);
-  intToChar[i] = c;
-  charToInt[c] = i;
+for (let i2 = 0; i2 < chars.length; i2++) {
+  const c = chars.charCodeAt(i2);
+  intToChar[i2] = c;
+  charToInt[c] = i2;
 }
 var CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
 var SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
@@ -3930,13 +3931,13 @@ function parseSingleFFOrSafariStack(raw) {
   let atIndex = -1;
   let locationPart = "";
   let functionName2;
-  for (let i = 0; i < line.length; i++) {
-    if (line[i] === "@") {
-      const candidateLocation = line.slice(i + 1);
+  for (let i2 = 0; i2 < line.length; i2++) {
+    if (line[i2] === "@") {
+      const candidateLocation = line.slice(i2 + 1);
       if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
-        atIndex = i;
+        atIndex = i2;
         locationPart = candidateLocation;
-        functionName2 = i > 0 ? line.slice(0, i) : void 0;
+        functionName2 = i2 > 0 ? line.slice(0, i2) : void 0;
         break;
       }
     }
@@ -4409,23 +4410,23 @@ function getUsedProps(fn2) {
 function filterOutComments(s) {
   const result = [];
   let commentState = "none";
-  for (let i = 0; i < s.length; ++i) {
+  for (let i2 = 0; i2 < s.length; ++i2) {
     if (commentState === "singleline") {
-      if (s[i] === "\n") {
+      if (s[i2] === "\n") {
         commentState = "none";
       }
     } else if (commentState === "multiline") {
-      if (s[i - 1] === "*" && s[i] === "/") {
+      if (s[i2 - 1] === "*" && s[i2] === "/") {
         commentState = "none";
       }
     } else if (commentState === "none") {
-      if (s[i] === "/" && s[i + 1] === "/") {
+      if (s[i2] === "/" && s[i2 + 1] === "/") {
         commentState = "singleline";
-      } else if (s[i] === "/" && s[i + 1] === "*") {
+      } else if (s[i2] === "/" && s[i2 + 1] === "*") {
         commentState = "multiline";
-        i += 2;
+        i2 += 2;
       } else {
-        result.push(s[i]);
+        result.push(s[i2]);
       }
     }
   }
@@ -4435,17 +4436,17 @@ function splitByComma(s) {
   const result = [];
   const stack = [];
   let start = 0;
-  for (let i = 0; i < s.length; i++) {
-    if (s[i] === "{" || s[i] === "[") {
-      stack.push(s[i] === "{" ? "}" : "]");
-    } else if (s[i] === stack.at(-1)) {
+  for (let i2 = 0; i2 < s.length; i2++) {
+    if (s[i2] === "{" || s[i2] === "[") {
+      stack.push(s[i2] === "{" ? "}" : "]");
+    } else if (s[i2] === stack.at(-1)) {
       stack.pop();
-    } else if (!stack.length && s[i] === ",") {
-      const token = s.substring(start, i).trim();
+    } else if (!stack.length && s[i2] === ",") {
+      const token = s.substring(start, i2).trim();
       if (token) {
         result.push(token);
       }
-      start = i + 1;
+      start = i2 + 1;
     }
   }
   const lastToken = s.substring(start).trim();
@@ -4719,8 +4720,8 @@ function createSuiteCollector(name, factory = () => {
       await runWithSuite(collector, () => factory(test5));
     }
     const allChildren = [];
-    for (const i of tasks) {
-      allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    for (const i2 of tasks) {
+      allChildren.push(i2.type === "collector" ? await i2.collect(file) : i2);
     }
     suite2.tasks = allChildren;
     return suite2;
@@ -4777,19 +4778,19 @@ function createSuite() {
       const arrayOnlyCases = cases.every(Array.isArray);
       const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
-      cases.forEach((i, idx) => {
-        const items = Array.isArray(i) ? i : [i];
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
         if (fnFirst) {
           if (arrayOnlyCases) {
             suite2(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
           } else {
-            suite2(formatTitle(_name, items, idx), handler ? () => handler(i) : void 0, options.timeout);
+            suite2(formatTitle(_name, items, idx), handler ? () => handler(i2) : void 0, options.timeout);
           }
         } else {
           if (arrayOnlyCases) {
             suite2(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
           } else {
-            suite2(formatTitle(_name, items, idx), options, handler ? () => handler(i) : void 0);
+            suite2(formatTitle(_name, items, idx), options, handler ? () => handler(i2) : void 0);
           }
         }
       });
@@ -4832,19 +4833,19 @@ function createTaskCollector(fn2, context) {
       const arrayOnlyCases = cases.every(Array.isArray);
       const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
-      cases.forEach((i, idx) => {
-        const items = Array.isArray(i) ? i : [i];
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
         if (fnFirst) {
           if (arrayOnlyCases) {
             test5(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
           } else {
-            test5(formatTitle(_name, items, idx), handler ? () => handler(i) : void 0, options.timeout);
+            test5(formatTitle(_name, items, idx), handler ? () => handler(i2) : void 0, options.timeout);
           }
         } else {
           if (arrayOnlyCases) {
             test5(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
           } else {
-            test5(formatTitle(_name, items, idx), options, handler ? () => handler(i) : void 0);
+            test5(formatTitle(_name, items, idx), options, handler ? () => handler(i2) : void 0);
           }
         }
       });
@@ -4922,12 +4923,12 @@ function formatTitle(template, items, idx) {
   const count = template.split("%").length - 1;
   if (template.includes("%f")) {
     const placeholders = template.match(/%f/g) || [];
-    placeholders.forEach((_, i2) => {
-      if (isNegativeNaN(items[i2]) || Object.is(items[i2], -0)) {
+    placeholders.forEach((_, i3) => {
+      if (isNegativeNaN(items[i3]) || Object.is(items[i3], -0)) {
         let occurrence = 0;
         template = template.replace(/%f/g, (match) => {
           occurrence++;
-          return occurrence === i2 + 1 ? "-%f" : match;
+          return occurrence === i3 + 1 ? "-%f" : match;
         });
       }
     });
@@ -4946,14 +4947,14 @@ function formatTitle(template, items, idx) {
     });
   }
   let output = "";
-  let i = 0;
+  let i2 = 0;
   handleRegexMatch(
     template,
     formatRegExp,
     // format "%"
     (match) => {
-      if (i < count) {
-        output += format2(match[0], items[i++]);
+      if (i2 < count) {
+        output += format2(match[0], items[i2++]);
       } else {
         output += match[0];
       }
@@ -4979,12 +4980,12 @@ function handleRegexMatch(input, regex, onMatch, onNonMatch) {
   }
 }
 function formatTemplateString(cases, args) {
-  const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i) => i.split("|"))[0];
+  const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i2) => i2.split("|"))[0];
   const res = [];
-  for (let i = 0; i < Math.floor(args.length / header.length); i++) {
+  for (let i2 = 0; i2 < Math.floor(args.length / header.length); i2++) {
     const oneCase = {};
     for (let j = 0; j < header.length; j++) {
-      oneCase[header[j]] = args[i * header.length + j];
+      oneCase[header[j]] = args[i2 * header.length + j];
     }
     res.push(oneCase);
   }
@@ -5218,41 +5219,41 @@ async function recordArtifact(task, artifact) {
   return resolvedArtifact;
 }
 var table = [];
-for (let i = 65; i < 91; i++) {
-  table.push(String.fromCharCode(i));
+for (let i2 = 65; i2 < 91; i2++) {
+  table.push(String.fromCharCode(i2));
 }
-for (let i = 97; i < 123; i++) {
-  table.push(String.fromCharCode(i));
+for (let i2 = 97; i2 < 123; i2++) {
+  table.push(String.fromCharCode(i2));
 }
-for (let i = 0; i < 10; i++) {
-  table.push(i.toString(10));
+for (let i2 = 0; i2 < 10; i2++) {
+  table.push(i2.toString(10));
 }
 table.push("+", "/");
 function encodeUint8Array(bytes) {
   let base64 = "";
   const len = bytes.byteLength;
-  for (let i = 0; i < len; i += 3) {
-    if (len === i + 1) {
-      const a = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4;
+  for (let i2 = 0; i2 < len; i2 += 3) {
+    if (len === i2 + 1) {
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4;
       base64 += table[a];
-      base64 += table[b];
+      base64 += table[b2];
       base64 += "==";
-    } else if (len === i + 2) {
-      const a = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
-      const c = (bytes[i + 1] & 15) << 2;
+    } else if (len === i2 + 2) {
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4 | (bytes[i2 + 1] & 240) >> 4;
+      const c = (bytes[i2 + 1] & 15) << 2;
       base64 += table[a];
-      base64 += table[b];
+      base64 += table[b2];
       base64 += table[c];
       base64 += "=";
     } else {
-      const a = (bytes[i] & 252) >> 2;
-      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
-      const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
-      const d2 = bytes[i + 2] & 63;
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4 | (bytes[i2 + 1] & 240) >> 4;
+      const c = (bytes[i2 + 1] & 15) << 2 | (bytes[i2 + 2] & 192) >> 6;
+      const d2 = bytes[i2 + 2] & 63;
       base64 += table[a];
-      base64 += table[b];
+      base64 += table[b2];
       base64 += table[c];
       base64 += table[d2];
     }
@@ -6020,11 +6021,11 @@ function inspectList2(list, options, inspectItem, separator = ", ") {
   let output = "";
   let peek = "";
   let truncated = "";
-  for (let i = 0; i < size; i += 1) {
-    const last = i + 1 === list.length;
-    const secondToLast = i + 2 === list.length;
-    truncated = `${truncator2}(${list.length - i})`;
-    const value = list[i];
+  for (let i2 = 0; i2 < size; i2 += 1) {
+    const last = i2 + 1 === list.length;
+    const secondToLast = i2 + 2 === list.length;
+    truncated = `${truncator2}(${list.length - i2})`;
+    const value = list[i2];
     options.truncate = originalLength - output.length - (last ? 0 : separator.length);
     const string2 = peek || inspectItem(value, options) + (last ? "" : separator);
     const nextLength = output.length + string2.length;
@@ -6035,13 +6036,13 @@ function inspectList2(list, options, inspectItem, separator = ", ") {
     if (!last && !secondToLast && truncatedLength > originalLength) {
       break;
     }
-    peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);
+    peek = last ? "" : inspectItem(list[i2 + 1], options) + (secondToLast ? "" : separator);
     if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
       break;
     }
     output += string2;
     if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
-      truncated = `${truncator2}(${list.length - i - 1})`;
+      truncated = `${truncator2}(${list.length - i2 - 1})`;
       break;
     }
     truncated = "";
@@ -6098,11 +6099,11 @@ function inspectTypedArray2(array2, options) {
   if (!array2.length && !nonIndexProperties.length)
     return `${name}[]`;
   let output = "";
-  for (let i = 0; i < array2.length; i++) {
-    const string2 = `${options.stylize(truncate2(array2[i], options.truncate), "number")}${i === array2.length - 1 ? "" : ", "}`;
+  for (let i2 = 0; i2 < array2.length; i2++) {
+    const string2 = `${options.stylize(truncate2(array2[i2], options.truncate), "number")}${i2 === array2.length - 1 ? "" : ", "}`;
     options.truncate -= string2.length;
-    if (array2[i] !== array2.length && options.truncate <= 3) {
-      output += `${truncator2}(${array2.length - array2[i] + 1})`;
+    if (array2[i2] !== array2.length && options.truncate <= 3) {
+      output += `${truncator2}(${array2.length - array2[i2] + 1})`;
       break;
     }
     output += string2;
@@ -6156,7 +6157,7 @@ function inspectMap2(map2, options) {
   return `Map{ ${inspectList2(mapToEntries2(map2), options, inspectMapEntry2)} }`;
 }
 __name(inspectMap2, "inspectMap");
-var isNaN2 = Number.isNaN || ((i) => i !== i);
+var isNaN2 = Number.isNaN || ((i2) => i2 !== i2);
 function inspectNumber2(number, options) {
   if (isNaN2(number)) {
     return options.stylize("NaN", "number");
@@ -6887,8 +6888,8 @@ __name(getEnumerableKeys, "getEnumerableKeys");
 function getEnumerableSymbols(target) {
   var keys2 = [];
   var allKeys = Object.getOwnPropertySymbols(target);
-  for (var i = 0; i < allKeys.length; i += 1) {
-    var key = allKeys[i];
+  for (var i2 = 0; i2 < allKeys.length; i2 += 1) {
+    var key = allKeys[i2];
     if (Object.getOwnPropertyDescriptor(target, key).enumerable) {
       keys2.push(key);
     }
@@ -6901,8 +6902,8 @@ function keysEqual(leftHandOperand, rightHandOperand, keys2, options) {
   if (length === 0) {
     return true;
   }
-  for (var i = 0; i < length; i += 1) {
-    if (deepEqual(leftHandOperand[keys2[i]], rightHandOperand[keys2[i]], options) === false) {
+  for (var i2 = 0; i2 < length; i2 += 1) {
+    if (deepEqual(leftHandOperand[keys2[i2]], rightHandOperand[keys2[i2]], options) === false) {
       return false;
     }
   }
@@ -6978,15 +6979,15 @@ function internalGetPathValue(obj, parsed, pathDepth) {
   let temporaryValue = obj;
   let res = null;
   pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth;
-  for (let i = 0; i < pathDepth; i++) {
-    const part = parsed[i];
+  for (let i2 = 0; i2 < pathDepth; i2++) {
+    const part = parsed[i2];
     if (temporaryValue) {
       if (typeof part.p === "undefined") {
         temporaryValue = temporaryValue[part.i];
       } else {
         temporaryValue = temporaryValue[part.p];
       }
-      if (i === pathDepth - 1) {
+      if (i2 === pathDepth - 1) {
         res = temporaryValue;
       }
     }
@@ -7296,24 +7297,24 @@ function stringDistanceCapped(strA, strB, cap) {
     return cap;
   }
   let memo = [];
-  for (let i = 0; i <= strA.length; i++) {
-    memo[i] = Array(strB.length + 1).fill(0);
-    memo[i][0] = i;
+  for (let i2 = 0; i2 <= strA.length; i2++) {
+    memo[i2] = Array(strB.length + 1).fill(0);
+    memo[i2][0] = i2;
   }
   for (let j = 0; j < strB.length; j++) {
     memo[0][j] = j;
   }
-  for (let i = 1; i <= strA.length; i++) {
-    let ch = strA.charCodeAt(i - 1);
+  for (let i2 = 1; i2 <= strA.length; i2++) {
+    let ch = strA.charCodeAt(i2 - 1);
     for (let j = 1; j <= strB.length; j++) {
-      if (Math.abs(i - j) >= cap) {
-        memo[i][j] = cap;
+      if (Math.abs(i2 - j) >= cap) {
+        memo[i2][j] = cap;
         continue;
       }
-      memo[i][j] = Math.min(
-        memo[i - 1][j] + 1,
-        memo[i][j - 1] + 1,
-        memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
+      memo[i2][j] = Math.min(
+        memo[i2 - 1][j] + 1,
+        memo[i2][j - 1] + 1,
+        memo[i2 - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
       );
     }
   }
@@ -7485,8 +7486,8 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   }, "overwritingChainableMethodWrapper");
 }
 __name(overwriteChainableMethod, "overwriteChainableMethod");
-function compareByInspect(a, b) {
-  return inspect22(a) < inspect22(b) ? -1 : 1;
+function compareByInspect(a, b2) {
+  return inspect22(a) < inspect22(b2) ? -1 : 1;
 }
 __name(compareByInspect, "compareByInspect");
 function getOwnEnumerablePropertySymbols(obj) {
@@ -7620,8 +7621,8 @@ function an(type3, msg) {
 __name(an, "an");
 Assertion.addChainableMethod("an", an);
 Assertion.addChainableMethod("a", an);
-function SameValueZero(a, b) {
-  return isNaN22(a) && isNaN22(b) || a === b;
+function SameValueZero(a, b2) {
+  return isNaN22(a) && isNaN22(b2) || a === b2;
 }
 __name(SameValueZero, "SameValueZero");
 function includeChainingBehavior() {
@@ -9809,11 +9810,11 @@ ${printReceived3(actual)}`
     };
   }
 };
-var EXPECTED_COLOR = C.green;
-var RECEIVED_COLOR = C.red;
-var INVERTED_COLOR = C.inverse;
-var BOLD_WEIGHT = C.bold;
-var DIM_COLOR = C.dim;
+var EXPECTED_COLOR = y.green;
+var RECEIVED_COLOR = y.red;
+var INVERTED_COLOR = y.inverse;
+var BOLD_WEIGHT = y.bold;
+var DIM_COLOR = y.dim;
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
   const { comment = "", isDirectExpectCall = false, isNot = false, promise = "", secondArgument = "", expectedColor = EXPECTED_COLOR, receivedColor = RECEIVED_COLOR, secondArgumentColor = EXPECTED_COLOR } = options;
   let hint = "";
@@ -9894,71 +9895,71 @@ function addCustomEqualityTesters(newTesters) {
 function getCustomEqualityTesters() {
   return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
 }
-function equals(a, b, customTesters, strictCheck) {
+function equals(a, b2, customTesters, strictCheck) {
   customTesters = customTesters || [];
-  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+  return eq(a, 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(a, b, customTesters) {
+function asymmetricMatch(a, b2, customTesters) {
   const asymmetricA = isAsymmetric(a);
-  const asymmetricB = isAsymmetric(b);
+  const asymmetricB = isAsymmetric(b2);
   if (asymmetricA && asymmetricB) {
     return void 0;
   }
   if (asymmetricA) {
-    return a.asymmetricMatch(b, customTesters);
+    return a.asymmetricMatch(b2, customTesters);
   }
   if (asymmetricB) {
-    return b.asymmetricMatch(a, customTesters);
+    return b2.asymmetricMatch(a, customTesters);
   }
 }
-function eq(a, b, aStack, bStack, customTesters, hasKey2) {
+function eq(a, b2, aStack, bStack, customTesters, hasKey2) {
   let result = true;
-  const asymmetricResult = asymmetricMatch(a, b, customTesters);
+  const asymmetricResult = asymmetricMatch(a, b2, customTesters);
   if (asymmetricResult !== void 0) {
     return asymmetricResult;
   }
   const testerContext = { equals };
-  for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i].call(testerContext, a, b, customTesters);
+  for (let i2 = 0; i2 < customTesters.length; i2++) {
+    const customTesterResult = customTesters[i2].call(testerContext, a, b2, customTesters);
     if (customTesterResult !== void 0) {
       return customTesterResult;
     }
   }
-  if (typeof URL === "function" && a instanceof URL && b instanceof URL) {
-    return a.href === b.href;
+  if (typeof URL === "function" && a instanceof URL && b2 instanceof URL) {
+    return a.href === b2.href;
   }
-  if (Object.is(a, b)) {
+  if (Object.is(a, b2)) {
     return true;
   }
-  if (a === null || b === null) {
-    return a === b;
+  if (a === null || b2 === null) {
+    return a === b2;
   }
   const className = Object.prototype.toString.call(a);
-  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 a !== typeof b) {
+      if (typeof a !== typeof b2) {
         return false;
-      } else if (typeof a !== "object" && typeof b !== "object") {
-        return Object.is(a, b);
+      } else if (typeof a !== "object" && typeof b2 !== "object") {
+        return Object.is(a, b2);
       } else {
-        return Object.is(a.valueOf(), b.valueOf());
+        return Object.is(a.valueOf(), b2.valueOf());
       }
     case "[object Date]": {
       const numA = +a;
-      const numB = +b;
+      const numB = +b2;
       return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
     }
     case "[object RegExp]":
-      return a.source === b.source && a.flags === b.flags;
+      return a.source === b2.source && a.flags === b2.flags;
     case "[object Temporal.Instant]":
     case "[object Temporal.ZonedDateTime]":
     case "[object Temporal.PlainDateTime]":
@@ -9966,32 +9967,32 @@ function eq(a, b, aStack, bStack, customTesters, hasKey2) {
     case "[object Temporal.PlainTime]":
     case "[object Temporal.PlainYearMonth]":
     case "[object Temporal.PlainMonthDay]":
-      return a.equals(b);
+      return a.equals(b2);
     case "[object Temporal.Duration]":
-      return a.toString() === b.toString();
+      return a.toString() === b2.toString();
   }
-  if (typeof a !== "object" || typeof b !== "object") {
+  if (typeof a !== "object" || typeof b2 !== "object") {
     return false;
   }
-  if (isDomNode(a) && isDomNode(b)) {
-    return a.isEqualNode(b);
+  if (isDomNode(a) && isDomNode(b2)) {
+    return a.isEqualNode(b2);
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a) {
-      return bStack[length] === b;
-    } else if (bStack[length] === b) {
+      return bStack[length] === b2;
+    } else if (bStack[length] === b2) {
       return false;
     }
   }
   aStack.push(a);
-  bStack.push(b);
-  if (className === "[object Array]" && a.length !== b.length) {
+  bStack.push(b2);
+  if (className === "[object Array]" && a.length !== b2.length) {
     return false;
   }
-  if (a instanceof Error && b instanceof Error) {
+  if (a instanceof Error && b2 instanceof Error) {
     try {
-      return isErrorEqual(a, b, aStack, bStack, customTesters, hasKey2);
+      return isErrorEqual(a, b2, aStack, bStack, customTesters, hasKey2);
     } finally {
       aStack.pop();
       bStack.pop();
@@ -10000,12 +10001,12 @@ function eq(a, b, aStack, bStack, customTesters, hasKey2) {
   const aKeys = keys(a, 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(a[key], b[key], aStack, bStack, customTesters, hasKey2);
+    result = hasKey2(b2, key) && eq(a[key], b2[key], aStack, bStack, customTesters, hasKey2);
     if (!result) {
       return false;
     }
@@ -10014,15 +10015,15 @@ function eq(a, b, aStack, bStack, customTesters, hasKey2) {
   bStack.pop();
   return result;
 }
-function isErrorEqual(a, b, aStack, bStack, customTesters, hasKey2) {
-  let result = Object.getPrototypeOf(a) === Object.getPrototypeOf(b) && a.name === b.name && a.message === b.message;
-  if (typeof b.cause !== "undefined") {
-    result && (result = eq(a.cause, b.cause, aStack, bStack, customTesters, hasKey2));
+function isErrorEqual(a, b2, aStack, bStack, customTesters, hasKey2) {
+  let result = Object.getPrototypeOf(a) === Object.getPrototypeOf(b2) && a.name === b2.name && a.message === b2.message;
+  if (typeof b2.cause !== "undefined") {
+    result && (result = eq(a.cause, b2.cause, aStack, bStack, customTesters, hasKey2));
   }
-  if (a instanceof AggregateError && b instanceof AggregateError) {
-    result && (result = eq(a.errors, b.errors, aStack, bStack, customTesters, hasKey2));
+  if (a instanceof AggregateError && b2 instanceof AggregateError) {
+    result && (result = eq(a.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
   }
-  result && (result = eq({ ...a }, { ...b }, aStack, bStack, customTesters, hasKey2));
+  result && (result = eq({ ...a }, { ...b2 }, aStack, bStack, customTesters, hasKey2));
   return result;
 }
 function keys(obj, hasKey2) {
@@ -10076,34 +10077,34 @@ var IteratorSymbol = Symbol.iterator;
 function hasIterator(object2) {
   return !!(object2 != null && object2[IteratorSymbol]);
 }
-function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
-  if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b)) {
+function iterableEquality(a, b2, customTesters = [], aStack = [], bStack = []) {
+  if (typeof a !== "object" || typeof b2 !== "object" || Array.isArray(a) || Array.isArray(b2) || !hasIterator(a) || !hasIterator(b2)) {
     return void 0;
   }
-  if (a.constructor !== b.constructor) {
+  if (a.constructor !== b2.constructor) {
     return false;
   }
   let length = aStack.length;
   while (length--) {
     if (aStack[length] === a) {
-      return bStack[length] === b;
+      return bStack[length] === b2;
     }
   }
   aStack.push(a);
-  bStack.push(b);
+  bStack.push(b2);
   const filteredCustomTesters = [...customTesters.filter((t) => t !== iterableEquality), iterableEqualityWithStack];
-  function iterableEqualityWithStack(a2, b2) {
-    return iterableEquality(a2, b2, [...customTesters], [...aStack], [...bStack]);
+  function iterableEqualityWithStack(a2, b3) {
+    return iterableEquality(a2, b3, [...customTesters], [...aStack], [...bStack]);
   }
   if (a.size !== void 0) {
-    if (a.size !== b.size) {
+    if (a.size !== b2.size) {
       return false;
     } else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
       let allFound = true;
       for (const aValue of a) {
-        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;
@@ -10121,9 +10122,9 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
     } else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
       let allFound = true;
       for (const aEntry of a) {
-        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) {
@@ -10144,7 +10145,7 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
       return allFound;
     }
   }
-  const bIterator = b[IteratorSymbol]();
+  const bIterator = b2[IteratorSymbol]();
   for (const aValue of a) {
     const nextB = bIterator.next();
     if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) {
@@ -10156,7 +10157,7 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
   }
   if (!isImmutableList(a) && !isImmutableOrderedKeyed(a) && !isImmutableOrderedSet(a) && !isImmutableRecord(a)) {
     const aEntries = Object.entries(a);
-    const bEntries = Object.entries(b);
+    const bEntries = Object.entries(b2);
     if (!equals(aEntries, bEntries, filteredCustomTesters)) {
       return false;
     }
@@ -10195,22 +10196,22 @@ function subsetEquality(object2, subset, customTesters = []) {
   };
   return subsetEqualityWithContext()(object2, subset);
 }
-function typeEquality(a, b) {
-  if (a == null || b == null || a.constructor === b.constructor) {
+function typeEquality(a, b2) {
+  if (a == null || b2 == null || a.constructor === b2.constructor) {
     return void 0;
   }
   return false;
 }
-function arrayBufferEquality(a, b) {
+function arrayBufferEquality(a, b2) {
   let dataViewA = a;
-  let dataViewB = b;
-  if (!(a instanceof DataView && b instanceof DataView)) {
-    if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
+  let dataViewB = b2;
+  if (!(a instanceof DataView && b2 instanceof DataView)) {
+    if (!(a instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) {
       return void 0;
     }
     try {
       dataViewA = new DataView(a);
-      dataViewB = new DataView(b);
+      dataViewB = new DataView(b2);
     } catch {
       return void 0;
     }
@@ -10218,21 +10219,21 @@ function arrayBufferEquality(a, b) {
   if (dataViewA.byteLength !== dataViewB.byteLength) {
     return false;
   }
-  for (let i = 0; i < dataViewA.byteLength; i++) {
-    if (dataViewA.getUint8(i) !== dataViewB.getUint8(i)) {
+  for (let i2 = 0; i2 < dataViewA.byteLength; i2++) {
+    if (dataViewA.getUint8(i2) !== dataViewB.getUint8(i2)) {
       return false;
     }
   }
   return true;
 }
-function sparseArrayEquality(a, b, customTesters = []) {
-  if (!Array.isArray(a) || !Array.isArray(b)) {
+function sparseArrayEquality(a, b2, customTesters = []) {
+  if (!Array.isArray(a) || !Array.isArray(b2)) {
     return void 0;
   }
   const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
+  const bKeys = Object.keys(b2);
   const filteredCustomTesters = customTesters.filter((t) => t !== sparseArrayEquality);
-  return equals(a, b, filteredCustomTesters, true) && equals(aKeys, bKeys);
+  return equals(a, b2, filteredCustomTesters, true) && equals(aKeys, bKeys);
 }
 function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
@@ -10261,7 +10262,7 @@ function getObjectSubset(object2, subset, customTesters) {
   const getObjectSubsetWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object3, subset2) => {
     if (Array.isArray(object3)) {
       if (Array.isArray(subset2) && subset2.length === object3.length) {
-        return subset2.map((sub, i) => getObjectSubsetWithContext(seenReferences)(object3[i], sub));
+        return subset2.map((sub, i2) => getObjectSubsetWithContext(seenReferences)(object3[i2], sub));
       }
     } else if (object3 instanceof Date) {
       return object3;
@@ -11018,8 +11019,8 @@ var JestChaiExpect = (chai, utils) => {
       throw new AssertionError2(msg);
     }
   });
-  function equalsArgumentArray(a, b) {
-    return a.length === b.length && a.every((aItem, i) => equals(aItem, b[i], [...customTesters, iterableEquality]));
+  function equalsArgumentArray(a, b2) {
+    return a.length === b2.length && a.every((aItem, i2) => equals(aItem, b2[i2], [...customTesters, iterableEquality]));
   }
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
@@ -11320,28 +11321,28 @@ var JestChaiExpect = (chai, utils) => {
     return proxy;
   });
 };
-function ordinalOf(i) {
-  const j = i % 10;
-  const k = i % 100;
+function ordinalOf(i2) {
+  const j = i2 % 10;
+  const k = i2 % 100;
   if (j === 1 && k !== 11) {
-    return `${i}st`;
+    return `${i2}st`;
   }
   if (j === 2 && k !== 12) {
-    return `${i}nd`;
+    return `${i2}nd`;
   }
   if (j === 3 && k !== 13) {
-    return `${i}rd`;
+    return `${i2}rd`;
   }
-  return `${i}th`;
+  return `${i2}th`;
 }
 function formatCalls(spy, msg, showActualCall) {
   if (spy.mock.calls.length) {
-    msg += C.gray(`
+    msg += y.gray(`
 
 Received: 
 
-${spy.mock.calls.map((callArg, i) => {
-      let methodCall = C.bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call:
+${spy.mock.calls.map((callArg, i2) => {
+      let methodCall = y.bold(`  ${ordinalOf(i2 + 1)} ${spy.getMockName()} call:
 
 `);
       if (showActualCall) {
@@ -11353,20 +11354,20 @@ ${spy.mock.calls.map((callArg, i) => {
       return methodCall;
     }).join("\n")}`);
   }
-  msg += C.gray(`
+  msg += y.gray(`
 
-Number of calls: ${C.bold(spy.mock.calls.length)}
+Number of calls: ${y.bold(spy.mock.calls.length)}
 `);
   return msg;
 }
 function formatReturns(spy, results, msg, showActualReturn) {
   if (results.length) {
-    msg += C.gray(`
+    msg += y.gray(`
 
 Received: 
 
-${results.map((callReturn, i) => {
-      let methodCall = C.bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
+${results.map((callReturn, i2) => {
+      let methodCall = y.bold(`  ${ordinalOf(i2 + 1)} ${spy.getMockName()} call return:
 
 `);
       if (showActualReturn) {
@@ -11378,9 +11379,9 @@ ${results.map((callReturn, i) => {
       return methodCall;
     }).join("\n")}`);
   }
-  msg += C.gray(`
+  msg += y.gray(`
 
-Number of calls: ${C.bold(spy.mock.calls.length)}
+Number of calls: ${y.bold(spy.mock.calls.length)}
 `);
   return msg;
 }
@@ -11539,10 +11540,10 @@ var comma2 = ",".charCodeAt(0);
 var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar2 = new Uint8Array(64);
 var charToInt2 = new Uint8Array(128);
-for (let i = 0; i < chars2.length; i++) {
-  const c = chars2.charCodeAt(i);
-  intToChar2[i] = c;
-  charToInt2[c] = i;
+for (let i2 = 0; i2 < chars2.length; i2++) {
+  const c = chars2.charCodeAt(i2);
+  intToChar2[i2] = c;
+  charToInt2[c] = i2;
 }
 function decodeInteger(reader, relative2) {
   let value = 0;
@@ -11627,8 +11628,8 @@ function decode(mappings) {
 function sort(line) {
   line.sort(sortComparator);
 }
-function sortComparator(a, b) {
-  return a[0] - b[0];
+function sortComparator(a, b2) {
+  return a[0] - b2[0];
 }
 var COLUMN = 0;
 var SOURCES_INDEX = 1;
@@ -11654,14 +11655,14 @@ function binarySearch(haystack, needle, low, high) {
   return low - 1;
 }
 function upperBound(haystack, needle, index2) {
-  for (let i = index2 + 1; i < haystack.length; index2 = i++) {
-    if (haystack[i][COLUMN] !== needle) break;
+  for (let i2 = index2 + 1; i2 < haystack.length; index2 = i2++) {
+    if (haystack[i2][COLUMN] !== needle) break;
   }
   return index2;
 }
 function lowerBound(haystack, needle, index2) {
-  for (let i = index2 - 1; i >= 0; index2 = i--) {
-    if (haystack[i][COLUMN] !== needle) break;
+  for (let i2 = index2 - 1; i2 >= 0; index2 = i2--) {
+    if (haystack[i2][COLUMN] !== needle) break;
   }
   return index2;
 }
@@ -11840,13 +11841,13 @@ function parseSingleFFOrSafariStack2(raw) {
   let atIndex = -1;
   let locationPart = "";
   let functionName2;
-  for (let i = 0; i < line.length; i++) {
-    if (line[i] === "@") {
-      const candidateLocation = line.slice(i + 1);
+  for (let i2 = 0; i2 < line.length; i2++) {
+    if (line[i2] === "@") {
+      const candidateLocation = line.slice(i2 + 1);
       if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
-        atIndex = i;
+        atIndex = i2;
         locationPart = candidateLocation;
-        functionName2 = i > 0 ? line.slice(0, i) : void 0;
+        functionName2 = i2 > 0 ? line.slice(0, i2) : void 0;
         break;
       }
     }
@@ -11963,7 +11964,7 @@ function parseErrorStacktrace(e, options = {}) {
     }
   }
   if (options.frameFilter) {
-    stackFrames = stackFrames.filter((f2) => options.frameFilter(e, f2) !== false);
+    stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
   }
   e.stacks = stackFrames;
   return stackFrames;
@@ -12009,8 +12010,8 @@ function positionToOffset(source, lineNumber, columnNumber) {
   if (lineNumber > lines.length) {
     return source.length;
   }
-  for (let i = 0; i < lineNumber - 1; i++) {
-    start += lines[i].length + nl;
+  for (let i2 = 0; i2 < lineNumber - 1; i2++) {
+    start += lines[i2].length + nl;
   }
   return start + columnNumber;
 }
@@ -12033,9 +12034,9 @@ function offsetToLineNumber(source, offset) {
 }
 async function saveInlineSnapshots(environment, snapshots) {
   const MagicString = (await import("./magic-string.es-B2CP4FDB.js")).default;
-  const files = new Set(snapshots.map((i) => i.file));
+  const files = new Set(snapshots.map((i2) => i2.file));
   await Promise.all(Array.from(files).map(async (file) => {
-    const snaps = snapshots.filter((i) => i.file === file);
+    const snaps = snapshots.filter((i2) => i2.file === file);
     const code = await environment.readSnapshotFile(file);
     const s = new MagicString(code);
     for (const snap of snaps) {
@@ -12096,7 +12097,7 @@ function prepareSnapString(snap, source, index2) {
     return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
   }
   return `${quote}
-${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
+${lines.map((i2) => i2 ? indentNext + i2 : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
 ${indent}${quote}`;
 }
 var toMatchInlineName = "toMatchInlineSnapshot";
@@ -12160,12 +12161,12 @@ function stripSnapshotIndentation(inlineSnapshot) {
   if (lines[0].trim() !== "" || ((_lines$at = lines.at(-1)) === null || _lines$at === void 0 ? void 0 : _lines$at.trim()) !== "") {
     return inlineSnapshot;
   }
-  for (let i = 1; i < lines.length - 1; i++) {
-    if (lines[i] !== "") {
-      if (lines[i].indexOf(indentation) !== 0) {
+  for (let i2 = 1; i2 < lines.length - 1; i2++) {
+    if (lines[i2] !== "") {
+      if (lines[i2].indexOf(indentation) !== 0) {
         return inlineSnapshot;
       }
-      lines[i] = lines[i].substring(indentation.length);
+      lines[i2] = lines[i2].substring(indentation.length);
     }
   }
   lines[lines.length - 1] = "";
@@ -12187,23 +12188,23 @@ var hasRequiredNaturalCompare;
 function requireNaturalCompare() {
   if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
   hasRequiredNaturalCompare = 1;
-  var naturalCompare2 = function(a, b) {
-    var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+  var naturalCompare2 = function(a, b2) {
+    var i2, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
     function getCode(str, pos, code) {
       if (code) {
-        for (i = pos; code = getCode(str, i), code < 76 && code > 65; ) ++i;
-        return +str.slice(pos - 1, i);
+        for (i2 = pos; code = getCode(str, i2), code < 76 && code > 65; ) ++i2;
+        return +str.slice(pos - 1, i2);
       }
       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 ((a += "") != (b += "")) for (; codeB; ) {
+    if ((a += "") != (b2 += "")) for (; codeB; ) {
       codeA = getCode(a, posA++);
-      codeB = getCode(b, posB++);
+      codeB = getCode(b2, posB++);
       if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
         codeA = getCode(a, posA, posA);
-        codeB = getCode(b, posB, posA = i);
-        posB = i;
+        codeB = getCode(b2, posB, posA = i2);
+        posB = i2;
       }
       if (codeA != codeB) return codeA < codeB ? -1 : 1;
     }
@@ -12399,8 +12400,8 @@ var CounterMap = class extends DefaultMap {
     return total;
   }
 };
-function isSameStackPosition(x, y) {
-  return x.file === y.file && x.column === y.column && x.line === y.line;
+function isSameStackPosition(x, y2) {
+  return x.file === y2.file && x.column === y2.column && x.line === y2.line;
 }
 var SnapshotState = class _SnapshotState {
   _counters = new CounterMap();
@@ -12503,11 +12504,11 @@ var SnapshotState = class _SnapshotState {
     this.unmatched.delete(testId);
   }
   _inferInlineSnapshotStack(stacks) {
-    const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
+    const promiseIndex = stacks.findIndex((i2) => i2.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
     if (promiseIndex !== -1) {
       return stacks[promiseIndex + 3];
     }
-    const stackIndex = stacks.findIndex((i) => i.method.includes("__INLINE_SNAPSHOT__"));
+    const stackIndex = stacks.findIndex((i2) => i2.method.includes("__INLINE_SNAPSHOT__"));
     return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
   }
   _addSnapshot(key, receivedSerialized, options) {
@@ -12816,7 +12817,7 @@ var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof win
 var RealDate = Date;
 var now2 = null;
 var MockDate = class _MockDate extends RealDate {
-  constructor(y, m, d2, h2, M, s, ms) {
+  constructor(y2, m, d2, h, M, s, ms) {
     super();
     let date;
     switch (arguments.length) {
@@ -12825,15 +12826,15 @@ var MockDate = class _MockDate extends RealDate {
         else date = new RealDate();
         break;
       case 1:
-        date = new RealDate(y);
+        date = new RealDate(y2);
         break;
       default:
         d2 = typeof d2 === "undefined" ? 1 : d2;
-        h2 = h2 || 0;
+        h = h || 0;
         M = M || 0;
         s = s || 0;
         ms = ms || 0;
-        date = new RealDate(y, m, d2, h2, M, s, ms);
+        date = new RealDate(y2, m, d2, h, M, s, ms);
         break;
     }
     Object.setPrototypeOf(date, _MockDate.prototype);
@@ -13392,9 +13393,9 @@ function requireOrderByFirstCall() {
   hasRequiredOrderByFirstCall = 1;
   var sort2 = requireArray().sort;
   var slice = requireArray().slice;
-  function comparator(a, b) {
+  function comparator(a, b2) {
     var aCall = a.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;
@@ -13714,8 +13715,8 @@ function requireFakeTimersSrc() {
       return isFinite(num);
     }
     let isNearInfiniteLimit = false;
-    function checkIsNearInfiniteLimit(clock, i) {
-      if (clock.loopLimit && i === clock.loopLimit - 1) {
+    function checkIsNearInfiniteLimit(clock, i2) {
+      if (clock.loopLimit && i2 === clock.loopLimit - 1) {
         isNearInfiniteLimit = true;
       }
     }
@@ -13728,7 +13729,7 @@ function requireFakeTimersSrc() {
       }
       const strings = str.split(":");
       const l = strings.length;
-      let i = l;
+      let i2 = l;
       let ms = 0;
       let parsed;
       if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
@@ -13736,12 +13737,12 @@ function requireFakeTimersSrc() {
           "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
         );
       }
-      while (i--) {
-        parsed = parseInt(strings[i], 10);
+      while (i2--) {
+        parsed = parseInt(strings[i2], 10);
         if (parsed >= 60) {
           throw new Error(`Invalid time ${str}`);
         }
-        ms += parsed * Math.pow(60, l - i - 1);
+        ms += parsed * Math.pow(60, l - i2 - 1);
       }
       return ms * 1e3;
     }
@@ -13783,15 +13784,15 @@ function requireFakeTimersSrc() {
         );
       }
       let matchedLineIndex = -1;
-      job.error.stack.split("\n").some(function(line, i) {
+      job.error.stack.split("\n").some(function(line, i2) {
         const matchedComputedTarget = line.match(computedTargetPattern);
         if (matchedComputedTarget) {
-          matchedLineIndex = i;
+          matchedLineIndex = i2;
           return true;
         }
         const matchedClockMethod = line.match(clockMethodPattern);
         if (matchedClockMethod) {
-          matchedLineIndex = i;
+          matchedLineIndex = i2;
           return false;
         }
         return matchedLineIndex >= 0;
@@ -13898,11 +13899,11 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       if (!clock.jobs) {
         return;
       }
-      for (let i = 0; i < clock.jobs.length; i++) {
-        const job = clock.jobs[i];
+      for (let i2 = 0; i2 < clock.jobs.length; i2++) {
+        const job = clock.jobs[i2];
         job.func.apply(null, job.args);
-        checkIsNearInfiniteLimit(clock, i);
-        if (clock.loopLimit && i > clock.loopLimit) {
+        checkIsNearInfiniteLimit(clock, i2);
+        if (clock.loopLimit && i2 > clock.loopLimit) {
           throw getInfiniteLoopError(clock, job);
         }
       }
@@ -13980,29 +13981,29 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return timer.id;
     }
-    function compareTimers(a, b) {
-      if (a.callAt < b.callAt) {
+    function compareTimers(a, b2) {
+      if (a.callAt < b2.callAt) {
         return -1;
       }
-      if (a.callAt > b.callAt) {
+      if (a.callAt > b2.callAt) {
         return 1;
       }
-      if (a.immediate && !b.immediate) {
+      if (a.immediate && !b2.immediate) {
         return -1;
       }
-      if (!a.immediate && b.immediate) {
+      if (!a.immediate && b2.immediate) {
         return 1;
       }
-      if (a.createdAt < b.createdAt) {
+      if (a.createdAt < b2.createdAt) {
         return -1;
       }
-      if (a.createdAt > b.createdAt) {
+      if (a.createdAt > b2.createdAt) {
         return 1;
       }
-      if (a.id < b.id) {
+      if (a.id < b2.id) {
         return -1;
       }
-      if (a.id > b.id) {
+      if (a.id > b2.id) {
         return 1;
       }
     }
@@ -14113,11 +14114,11 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       }
     }
     function uninstall(clock, config2) {
-      let method, i, l;
+      let method, i2, l;
       const installedHrTime = "_hrtime";
       const installedNextTick = "_nextTick";
-      for (i = 0, l = clock.methods.length; i < l; i++) {
-        method = clock.methods[i];
+      for (i2 = 0, l = clock.methods.length; i2 < l; i2++) {
+        method = clock.methods[i2];
         if (method === "hrtime" && _global.process) {
           _global.process.hrtime = clock[installedHrTime];
         } else if (method === "nextTick" && _global.process) {
@@ -14572,9 +14573,9 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         };
       }
       clock.runAll = function runAll() {
-        let numTimers, i;
+        let numTimers, i2;
         runJobs(clock);
-        for (i = 0; i < clock.loopLimit; i++) {
+        for (i2 = 0; i2 < clock.loopLimit; i2++) {
           if (!clock.timers) {
             resetIsNearInfiniteLimit();
             return clock.now;
@@ -14585,7 +14586,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
             return clock.now;
           }
           clock.next();
-          checkIsNearInfiniteLimit(clock, i);
+          checkIsNearInfiniteLimit(clock, i2);
         }
         const excessJob = firstTimer(clock);
         throw getInfiniteLoopError(clock, excessJob);
@@ -14596,13 +14597,13 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       if (typeof _global.Promise !== "undefined") {
         clock.runAllAsync = function runAllAsync() {
           return new _global.Promise(function(resolve3, reject) {
-            let i = 0;
+            let i2 = 0;
             function doRun() {
               originalSetTimeout(function() {
                 try {
                   runJobs(clock);
                   let numTimers;
-                  if (i < clock.loopLimit) {
+                  if (i2 < clock.loopLimit) {
                     if (!clock.timers) {
                       resetIsNearInfiniteLimit();
                       resolve3(clock.now);
@@ -14617,9 +14618,9 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
                       return;
                     }
                     clock.next();
-                    i++;
+                    i2++;
                     doRun();
-                    checkIsNearInfiniteLimit(clock, i);
+                    checkIsNearInfiniteLimit(clock, i2);
                     return;
                   }
                   const excessJob = firstTimer(clock);
@@ -14730,7 +14731,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           `non-existent timers and/or objects cannot be faked: '${timer}'`
         );
       }
-      let i, l;
+      let i2, l;
       const clock = createClock(config2.now, config2.loopLimit);
       clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
       clock.uninstall = function() {
@@ -14781,8 +14782,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       if (_global === globalObject && timersPromisesModule) {
         clock.timersPromisesModuleMethods = [];
       }
-      for (i = 0, l = clock.methods.length; i < l; i++) {
-        const nameOfMethodToReplace = clock.methods[i];
+      for (i2 = 0, l = clock.methods.length; i2 < l; i2++) {
+        const nameOfMethodToReplace = clock.methods[i2];
         if (!isPresent[nameOfMethodToReplace]) {
           handleMissingTimer(nameOfMethodToReplace);
           continue;
@@ -15052,14 +15053,14 @@ var FakeTimers = class {
     if (this._checkFakeTimers()) await this._clock.runToLastAsync();
   }
   advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+    if (this._checkFakeTimers()) for (let i2 = steps; i2 > 0; i2--) {
       this._clock.next();
       this._clock.tick(0);
       if (this._clock.countTimers() === 0) break;
     }
   }
   async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+    if (this._checkFakeTimers()) for (let i2 = steps; i2 > 0; i2--) {
       await this._clock.nextAsync();
       this._clock.tick(0);
       if (this._clock.countTimers() === 0) break;
@@ -15459,27 +15460,41 @@ var AsyncFunction = async function() {
 var chars3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar3 = new Uint8Array(64);
 var charToInt3 = new Uint8Array(128);
-for (let i = 0; i < chars3.length; i++) {
-  const c = chars3.charCodeAt(i);
-  intToChar3[i] = c, charToInt3[c] = i;
+for (let i2 = 0; i2 < chars3.length; i2++) {
+  let c = chars3.charCodeAt(i2);
+  intToChar3[i2] = c, charToInt3[c] = i2;
 }
-var MODULE_RUNNER_SOURCEMAPPING_REGEXP = new RegExp(
-  `//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`
-);
+var MODULE_RUNNER_SOURCEMAPPING_REGEXP = /* @__PURE__ */ RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
 var retrieveFileHandlers = /* @__PURE__ */ new Set();
 var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
 var createExecHandlers = (handlers) => (...args) => {
-  for (const handler of handlers) {
-    const result = handler(...args);
+  for (let handler of handlers) {
+    let result = handler(...args);
     if (result) return result;
   }
   return null;
 };
 var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
-var retrieveSourceMapFromHandlers = createExecHandlers(
-  retrieveSourceMapHandlers
-);
+var retrieveSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
 var originalPrepare = Error.prepareStackTrace;
+var customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
+var customizationHooksModule = `
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+  return nextResolve(specifier, context)
+}
+
+`;
+`${customizationHookNamespace}`;
+var envProxy = new Proxy({}, { get(_, p) {
+  throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+} });
 var import_expect_type = (0, import_chunk_4VNS5WPM.__toESM)(require_dist(), 1);
 /*! Bundled license information: