@vitest/browser 3.0.9 → 3.1.0-beta.2

package/dist/client/__vitest_browser__/{tester-lo_P6U-u.js → tester-DRF-LncV.js}

@@ -74,7 +74,7 @@ const __vitePreload = function preload(baseModule, deps, importerUrl) {
 };
 function showPopupWarning(name, value, defaultValue) {
   return (...params) => {
-    const formattedParams = params.map((p) => JSON.stringify(p)).join(", ");
+    const formattedParams = params.map((p2) => JSON.stringify(p2)).join(", ");
     console.warn(`Vitest encountered a \`${name}(${formattedParams})\` call that it cannot handle by default, so it returned \`${value}\`. Read more in https://vitest.dev/guide/browser/#thread-blocking-dialogs.
 If needed, mock the \`${name}\` call manually like:
 
@@ -94,7 +94,7 @@ function setupDialogsSpy() {
   globalThis.prompt = showPopupWarning("prompt", null, "your value");
 }
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
+function getDefaultExportFromCjs$1(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var minIndent;
@@ -107,7 +107,7 @@ function requireMinIndent() {
     if (!match) {
       return 0;
     }
-    return match.reduce((r, a) => Math.min(r, a.length), Infinity);
+    return match.reduce((r, a2) => Math.min(r, a2.length), Infinity);
   };
   return minIndent;
 }
@@ -172,9 +172,9 @@ function requireRedent() {
   return redent$1;
 }
 var redentExports = requireRedent();
-const redent = /* @__PURE__ */ getDefaultExportFromCjs(redentExports);
-function $parcel$defineInteropFlag(a) {
-  Object.defineProperty(a, "__esModule", { value: true, configurable: true });
+const redent = /* @__PURE__ */ getDefaultExportFromCjs$1(redentExports);
+function $parcel$defineInteropFlag(a2) {
+  Object.defineProperty(a2, "__esModule", { value: true, configurable: true });
 }
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, { get: v, set: s, enumerable: true, configurable: true });
@@ -638,13 +638,13 @@ function toLength(value) {
   return Math.min(Math.max(len, 0), maxSafeInteger);
 }
 function arrayFrom(arrayLike, mapFn) {
-  var C = Array;
+  var C2 = Array;
   var items = Object(arrayLike);
   if (arrayLike == null) {
     throw new TypeError("Array.from requires an array-like object - not null or undefined");
   }
   var len = toLength(items.length);
-  var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+  var A = isCallable(C2) ? Object(new C2(len)) : new Array(len);
   var k = 0;
   var kValue;
   while (k < len) {
@@ -1466,15 +1466,15 @@ function requireIteratorProxy() {
   iteratorProxy.default = void 0;
   function iteratorProxy$1() {
     var values = this;
-    var index = 0;
+    var index2 = 0;
     var iter = {
       "@@iterator": function iterator() {
         return iter;
       },
       next: function next() {
-        if (index < values.length) {
-          var value = values[index];
-          index = index + 1;
+        if (index2 < values.length) {
+          var value = values[index2];
+          index2 = index2 + 1;
           return {
             done: false,
             value
@@ -1594,7 +1594,7 @@ function requireAriaPropsMap() {
     }, e: function e(_e3) {
       didErr = true;
       err = _e3;
-    }, f: function f() {
+    }, f: function f2() {
       try {
         if (!normalCompletion && it.return != null) it.return();
       } finally {
@@ -1850,7 +1850,7 @@ function requireDomMap() {
     }, e: function e(_e3) {
       didErr = true;
       err = _e3;
-    }, f: function f() {
+    }, f: function f2() {
       try {
         if (!normalCompletion && it.return != null) it.return();
       } finally {
@@ -7925,7 +7925,7 @@ function requireRolesMap() {
     }, e: function e(_e3) {
       didErr = true;
       err = _e3;
-    }, f: function f() {
+    }, f: function f2() {
       try {
         if (!normalCompletion && it.return != null) it.return();
       } finally {
@@ -8175,7 +8175,7 @@ function requireElementRoleMap() {
     }, e: function e(_e3) {
       didErr = true;
       err = _e3;
-    }, f: function f() {
+    }, f: function f2() {
       try {
         if (!normalCompletion && it.return != null) it.return();
       } finally {
@@ -8355,7 +8355,7 @@ function requireRoleElementMap() {
     }, e: function e(_e3) {
       didErr = true;
       err = _e3;
-    }, f: function f() {
+    }, f: function f2() {
       try {
         if (!normalCompletion && it.return != null) it.return();
       } finally {
@@ -8682,20 +8682,20 @@ function requireConversions() {
     const min = Math.min(r, g, b);
     const max = Math.max(r, g, b);
     const delta = max - min;
-    let h;
+    let h2;
     let s;
     if (max === min) {
-      h = 0;
+      h2 = 0;
     } else if (r === max) {
-      h = (g - b) / delta;
+      h2 = (g - b) / delta;
     } else if (g === max) {
-      h = 2 + (b - r) / delta;
+      h2 = 2 + (b - r) / delta;
     } else if (b === max) {
-      h = 4 + (r - g) / delta;
+      h2 = 4 + (r - g) / delta;
     }
-    h = Math.min(h * 60, 360);
-    if (h < 0) {
-      h += 360;
+    h2 = Math.min(h2 * 60, 360);
+    if (h2 < 0) {
+      h2 += 360;
     }
     const l = (min + max) / 2;
     if (max === min) {
@@ -8705,13 +8705,13 @@ function requireConversions() {
     } else {
       s = delta / (2 - max - min);
     }
-    return [h, s * 100, l * 100];
+    return [h2, s * 100, l * 100];
   };
   convert.rgb.hsv = function(rgb) {
     let rdif;
     let gdif;
     let bdif;
-    let h;
+    let h2;
     let s;
     const r = rgb[0] / 255;
     const g = rgb[1] / 255;
@@ -8722,7 +8722,7 @@ function requireConversions() {
       return (v - c) / 6 / diff + 1 / 2;
     };
     if (diff === 0) {
-      h = 0;
+      h2 = 0;
       s = 0;
     } else {
       s = diff / v;
@@ -8730,20 +8730,20 @@ function requireConversions() {
       gdif = diffc(g);
       bdif = diffc(b);
       if (r === v) {
-        h = bdif - gdif;
+        h2 = bdif - gdif;
       } else if (g === v) {
-        h = 1 / 3 + rdif - bdif;
+        h2 = 1 / 3 + rdif - bdif;
       } else if (b === v) {
-        h = 2 / 3 + gdif - rdif;
+        h2 = 2 / 3 + gdif - rdif;
       }
-      if (h < 0) {
-        h += 1;
-      } else if (h > 1) {
-        h -= 1;
+      if (h2 < 0) {
+        h2 += 1;
+      } else if (h2 > 1) {
+        h2 -= 1;
       }
     }
     return [
-      h * 360,
+      h2 * 360,
       s * 100,
       v * 100
     ];
@@ -8752,10 +8752,10 @@ function requireConversions() {
     const r = rgb[0];
     const g = rgb[1];
     let b = rgb[2];
-    const h = convert.rgb.hsl(rgb)[0];
+    const h2 = convert.rgb.hsl(rgb)[0];
     const w = 1 / 255 * Math.min(r, Math.min(g, b));
     b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
-    return [h, w * 100, b * 100];
+    return [h2, w * 100, b * 100];
   };
   convert.rgb.cmyk = function(rgb) {
     const r = rgb[0] / 255;
@@ -8814,12 +8814,12 @@ function requireConversions() {
     y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
     z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
     const l = 116 * y - 16;
-    const a = 500 * (x - y);
+    const a2 = 500 * (x - y);
     const b = 200 * (y - z);
-    return [l, a, b];
+    return [l, a2, b];
   };
   convert.hsl.rgb = function(hsl) {
-    const h = hsl[0] / 360;
+    const h2 = hsl[0] / 360;
     const s = hsl[1] / 100;
     const l = hsl[2] / 100;
     let t2;
@@ -8837,7 +8837,7 @@ function requireConversions() {
     const t1 = 2 * l - t2;
     const rgb = [0, 0, 0];
     for (let i = 0; i < 3; i++) {
-      t3 = h + 1 / 3 * -(i - 1);
+      t3 = h2 + 1 / 3 * -(i - 1);
       if (t3 < 0) {
         t3++;
       }
@@ -8858,7 +8858,7 @@ function requireConversions() {
     return rgb;
   };
   convert.hsl.hsv = function(hsl) {
-    const h = hsl[0];
+    const h2 = hsl[0];
     let s = hsl[1] / 100;
     let l = hsl[2] / 100;
     let smin = s;
@@ -8868,35 +8868,35 @@ function requireConversions() {
     smin *= lmin <= 1 ? lmin : 2 - lmin;
     const v = (l + s) / 2;
     const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
-    return [h, sv * 100, v * 100];
+    return [h2, sv * 100, v * 100];
   };
   convert.hsv.rgb = function(hsv) {
-    const h = hsv[0] / 60;
+    const h2 = hsv[0] / 60;
     const s = hsv[1] / 100;
     let v = hsv[2] / 100;
-    const hi = Math.floor(h) % 6;
-    const f = h - Math.floor(h);
-    const p = 255 * v * (1 - s);
-    const q = 255 * v * (1 - s * f);
-    const t = 255 * v * (1 - s * (1 - f));
+    const hi = Math.floor(h2) % 6;
+    const f2 = h2 - Math.floor(h2);
+    const p2 = 255 * v * (1 - s);
+    const q = 255 * v * (1 - s * f2);
+    const t = 255 * v * (1 - s * (1 - f2));
     v *= 255;
     switch (hi) {
       case 0:
-        return [v, t, p];
+        return [v, t, p2];
       case 1:
-        return [q, v, p];
+        return [q, v, p2];
       case 2:
-        return [p, v, t];
+        return [p2, v, t];
       case 3:
-        return [p, q, v];
+        return [p2, q, v];
       case 4:
-        return [t, p, v];
+        return [t, p2, v];
       case 5:
-        return [v, p, q];
+        return [v, p2, q];
     }
   };
   convert.hsv.hsl = function(hsv) {
-    const h = hsv[0];
+    const h2 = hsv[0];
     const s = hsv[1] / 100;
     const v = hsv[2] / 100;
     const vmin = Math.max(v, 0.01);
@@ -8908,25 +8908,25 @@ function requireConversions() {
     sl /= lmin <= 1 ? lmin : 2 - lmin;
     sl = sl || 0;
     l /= 2;
-    return [h, sl * 100, l * 100];
+    return [h2, sl * 100, l * 100];
   };
   convert.hwb.rgb = function(hwb) {
-    const h = hwb[0] / 360;
+    const h2 = hwb[0] / 360;
     let wh = hwb[1] / 100;
     let bl = hwb[2] / 100;
     const ratio = wh + bl;
-    let f;
+    let f2;
     if (ratio > 1) {
       wh /= ratio;
       bl /= ratio;
     }
-    const i = Math.floor(6 * h);
+    const i = Math.floor(6 * h2);
     const v = 1 - bl;
-    f = 6 * h - i;
+    f2 = 6 * h2 - i;
     if ((i & 1) !== 0) {
-      f = 1 - f;
+      f2 = 1 - f2;
     }
-    const n = wh + f * (v - wh);
+    const n = wh + f2 * (v - wh);
     let r;
     let g;
     let b;
@@ -9005,19 +9005,19 @@ function requireConversions() {
     y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
     z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
     const l = 116 * y - 16;
-    const a = 500 * (x - y);
+    const a2 = 500 * (x - y);
     const b = 200 * (y - z);
-    return [l, a, b];
+    return [l, a2, b];
   };
   convert.lab.xyz = function(lab) {
     const l = lab[0];
-    const a = lab[1];
+    const a2 = lab[1];
     const b = lab[2];
     let x;
     let y;
     let z;
     y = (l + 16) / 116;
-    x = a / 500 + y;
+    x = a2 / 500 + y;
     z = y - b / 200;
     const y2 = y ** 3;
     const x2 = x ** 3;
@@ -9032,25 +9032,25 @@ function requireConversions() {
   };
   convert.lab.lch = function(lab) {
     const l = lab[0];
-    const a = lab[1];
+    const a2 = lab[1];
     const b = lab[2];
-    let h;
-    const hr = Math.atan2(b, a);
-    h = hr * 360 / 2 / Math.PI;
-    if (h < 0) {
-      h += 360;
+    let h2;
+    const hr = Math.atan2(b, a2);
+    h2 = hr * 360 / 2 / Math.PI;
+    if (h2 < 0) {
+      h2 += 360;
     }
-    const c = Math.sqrt(a * a + b * b);
-    return [l, c, h];
+    const c = Math.sqrt(a2 * a2 + b * b);
+    return [l, c, h2];
   };
   convert.lch.lab = function(lch) {
     const l = lch[0];
     const c = lch[1];
-    const h = lch[2];
-    const hr = h / 360 * 2 * Math.PI;
-    const a = c * Math.cos(hr);
+    const h2 = lch[2];
+    const hr = h2 / 360 * 2 * Math.PI;
+    const a2 = c * Math.cos(hr);
     const b = c * Math.sin(hr);
-    return [l, a, b];
+    return [l, a2, b];
   };
   convert.rgb.ansi16 = function(args, saturation = null) {
     const [r, g, b] = args;
@@ -9164,31 +9164,31 @@ function requireConversions() {
     const s = hsl[1] / 100;
     const l = hsl[2] / 100;
     const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
-    let f = 0;
+    let f2 = 0;
     if (c < 1) {
-      f = (l - 0.5 * c) / (1 - c);
+      f2 = (l - 0.5 * c) / (1 - c);
     }
-    return [hsl[0], c * 100, f * 100];
+    return [hsl[0], c * 100, f2 * 100];
   };
   convert.hsv.hcg = function(hsv) {
     const s = hsv[1] / 100;
     const v = hsv[2] / 100;
     const c = s * v;
-    let f = 0;
+    let f2 = 0;
     if (c < 1) {
-      f = (v - c) / (1 - c);
+      f2 = (v - c) / (1 - c);
     }
-    return [hsv[0], c * 100, f * 100];
+    return [hsv[0], c * 100, f2 * 100];
   };
   convert.hcg.rgb = function(hcg) {
-    const h = hcg[0] / 360;
+    const h2 = hcg[0] / 360;
     const c = hcg[1] / 100;
     const g = hcg[2] / 100;
     if (c === 0) {
       return [g * 255, g * 255, g * 255];
     }
     const pure = [0, 0, 0];
-    const hi = h % 1 * 6;
+    const hi = h2 % 1 * 6;
     const v = hi % 1;
     const w = 1 - v;
     let mg = 0;
@@ -9234,11 +9234,11 @@ function requireConversions() {
     const c = hcg[1] / 100;
     const g = hcg[2] / 100;
     const v = c + g * (1 - c);
-    let f = 0;
+    let f2 = 0;
     if (v > 0) {
-      f = c / v;
+      f2 = c / v;
     }
-    return [hcg[0], f * 100, v * 100];
+    return [hcg[0], f2 * 100, v * 100];
   };
   convert.hcg.hsl = function(hcg) {
     const c = hcg[1] / 100;
@@ -9597,30 +9597,30 @@ function requireUtil() {
   if (hasRequiredUtil) return util;
   hasRequiredUtil = 1;
   const stringReplaceAll = (string, substring, replacer) => {
-    let index = string.indexOf(substring);
-    if (index === -1) {
+    let index2 = string.indexOf(substring);
+    if (index2 === -1) {
       return string;
     }
     const substringLength = substring.length;
     let endIndex = 0;
     let returnValue = "";
     do {
-      returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
-      endIndex = index + substringLength;
-      index = string.indexOf(substring, endIndex);
-    } while (index !== -1);
+      returnValue += string.substr(endIndex, index2 - endIndex) + substring + replacer;
+      endIndex = index2 + substringLength;
+      index2 = string.indexOf(substring, endIndex);
+    } while (index2 !== -1);
     returnValue += string.substr(endIndex);
     return returnValue;
   };
-  const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+  const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index2) => {
     let endIndex = 0;
     let returnValue = "";
     do {
-      const gotCR = string[index - 1] === "\r";
-      returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-      endIndex = index + 1;
-      index = string.indexOf("\n", endIndex);
-    } while (index !== -1);
+      const gotCR = string[index2 - 1] === "\r";
+      returnValue += string.substr(endIndex, (gotCR ? index2 - 1 : index2) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+      endIndex = index2 + 1;
+      index2 = string.indexOf("\n", endIndex);
+    } while (index2 !== -1);
     returnValue += string.substr(endIndex);
     return returnValue;
   };
@@ -9929,7 +9929,7 @@ function requireSource() {
   return source;
 }
 var sourceExports = requireSource();
-const chalk = /* @__PURE__ */ getDefaultExportFromCjs(sourceExports);
+const chalk = /* @__PURE__ */ getDefaultExportFromCjs$1(sourceExports);
 var _listCacheClear;
 var hasRequired_listCacheClear;
 function require_listCacheClear() {
@@ -9980,15 +9980,15 @@ function require_listCacheDelete() {
   var arrayProto = Array.prototype;
   var splice = arrayProto.splice;
   function listCacheDelete(key) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    if (index < 0) {
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    if (index2 < 0) {
       return false;
     }
     var lastIndex = data.length - 1;
-    if (index == lastIndex) {
+    if (index2 == lastIndex) {
       data.pop();
     } else {
-      splice.call(data, index, 1);
+      splice.call(data, index2, 1);
     }
     --this.size;
     return true;
@@ -10003,8 +10003,8 @@ function require_listCacheGet() {
   hasRequired_listCacheGet = 1;
   var assocIndexOf = require_assocIndexOf();
   function listCacheGet(key) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    return index < 0 ? void 0 : data[index][1];
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    return index2 < 0 ? void 0 : data[index2][1];
   }
   _listCacheGet = listCacheGet;
   return _listCacheGet;
@@ -10028,12 +10028,12 @@ function require_listCacheSet() {
   hasRequired_listCacheSet = 1;
   var assocIndexOf = require_assocIndexOf();
   function listCacheSet(key, value) {
-    var data = this.__data__, index = assocIndexOf(data, key);
-    if (index < 0) {
+    var data = this.__data__, index2 = assocIndexOf(data, key);
+    if (index2 < 0) {
       ++this.size;
       data.push([key, value]);
     } else {
-      data[index][1] = value;
+      data[index2][1] = value;
     }
     return this;
   }
@@ -10047,10 +10047,10 @@ function require_ListCache() {
   hasRequired_ListCache = 1;
   var listCacheClear = require_listCacheClear(), listCacheDelete = require_listCacheDelete(), listCacheGet = require_listCacheGet(), listCacheHas = require_listCacheHas(), listCacheSet = require_listCacheSet();
   function ListCache(entries) {
-    var index = -1, length = entries == null ? 0 : entries.length;
+    var index2 = -1, length = entries == null ? 0 : entries.length;
     this.clear();
-    while (++index < length) {
-      var entry = entries[index];
+    while (++index2 < length) {
+      var entry = entries[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -10430,10 +10430,10 @@ function require_Hash() {
   hasRequired_Hash = 1;
   var hashClear = require_hashClear(), hashDelete = require_hashDelete(), hashGet = require_hashGet(), hashHas = require_hashHas(), hashSet = require_hashSet();
   function Hash(entries) {
-    var index = -1, length = entries == null ? 0 : entries.length;
+    var index2 = -1, length = entries == null ? 0 : entries.length;
     this.clear();
-    while (++index < length) {
-      var entry = entries[index];
+    while (++index2 < length) {
+      var entry = entries[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -10547,10 +10547,10 @@ function require_MapCache() {
   hasRequired_MapCache = 1;
   var mapCacheClear = require_mapCacheClear(), mapCacheDelete = require_mapCacheDelete(), mapCacheGet = require_mapCacheGet(), mapCacheHas = require_mapCacheHas(), mapCacheSet = require_mapCacheSet();
   function MapCache(entries) {
-    var index = -1, length = entries == null ? 0 : entries.length;
+    var index2 = -1, length = entries == null ? 0 : entries.length;
     this.clear();
-    while (++index < length) {
-      var entry = entries[index];
+    while (++index2 < length) {
+      var entry = entries[index2];
       this.set(entry[0], entry[1]);
     }
   }
@@ -10636,10 +10636,10 @@ function require_SetCache() {
   hasRequired_SetCache = 1;
   var MapCache = require_MapCache(), setCacheAdd = require_setCacheAdd(), setCacheHas = require_setCacheHas();
   function SetCache(values) {
-    var index = -1, length = values == null ? 0 : values.length;
+    var index2 = -1, length = values == null ? 0 : values.length;
     this.__data__ = new MapCache();
-    while (++index < length) {
-      this.add(values[index]);
+    while (++index2 < length) {
+      this.add(values[index2]);
     }
   }
   SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
@@ -10653,9 +10653,9 @@ function require_arraySome() {
   if (hasRequired_arraySome) return _arraySome;
   hasRequired_arraySome = 1;
   function arraySome(array, predicate) {
-    var index = -1, length = array == null ? 0 : array.length;
-    while (++index < length) {
-      if (predicate(array[index], index, array)) {
+    var index2 = -1, length = array == null ? 0 : array.length;
+    while (++index2 < length) {
+      if (predicate(array[index2], index2, array)) {
         return true;
       }
     }
@@ -10692,13 +10692,13 @@ function require_equalArrays() {
     if (arrStacked && othStacked) {
       return arrStacked == other && othStacked == array;
     }
-    var index = -1, result = true, seen2 = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+    var index2 = -1, result = true, seen2 = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
     stack.set(array, other);
     stack.set(other, array);
-    while (++index < arrLength) {
-      var arrValue = array[index], othValue = other[index];
+    while (++index2 < arrLength) {
+      var arrValue = array[index2], othValue = other[index2];
       if (customizer) {
-        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        var compared = isPartial ? customizer(othValue, arrValue, index2, other, array, stack) : customizer(arrValue, othValue, index2, array, other, stack);
       }
       if (compared !== void 0) {
         if (compared) {
@@ -10744,9 +10744,9 @@ function require_mapToArray() {
   if (hasRequired_mapToArray) return _mapToArray;
   hasRequired_mapToArray = 1;
   function mapToArray(map) {
-    var index = -1, result = Array(map.size);
+    var index2 = -1, result = Array(map.size);
     map.forEach(function(value, key) {
-      result[++index] = [key, value];
+      result[++index2] = [key, value];
     });
     return result;
   }
@@ -10759,9 +10759,9 @@ function require_setToArray() {
   if (hasRequired_setToArray) return _setToArray;
   hasRequired_setToArray = 1;
   function setToArray(set) {
-    var index = -1, result = Array(set.size);
+    var index2 = -1, result = Array(set.size);
     set.forEach(function(value) {
-      result[++index] = value;
+      result[++index2] = value;
     });
     return result;
   }
@@ -10833,9 +10833,9 @@ function require_arrayPush() {
   if (hasRequired_arrayPush) return _arrayPush;
   hasRequired_arrayPush = 1;
   function arrayPush(array, values) {
-    var index = -1, length = values.length, offset = array.length;
-    while (++index < length) {
-      array[offset + index] = values[index];
+    var index2 = -1, length = values.length, offset = array.length;
+    while (++index2 < length) {
+      array[offset + index2] = values[index2];
     }
     return array;
   }
@@ -10870,10 +10870,10 @@ function require_arrayFilter() {
   if (hasRequired_arrayFilter) return _arrayFilter;
   hasRequired_arrayFilter = 1;
   function arrayFilter(array, predicate) {
-    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
-    while (++index < length) {
-      var value = array[index];
-      if (predicate(value, index, array)) {
+    var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+    while (++index2 < length) {
+      var value = array[index2];
+      if (predicate(value, index2, array)) {
         result[resIndex++] = value;
       }
     }
@@ -10920,9 +10920,9 @@ function require_baseTimes() {
   if (hasRequired_baseTimes) return _baseTimes;
   hasRequired_baseTimes = 1;
   function baseTimes(n, iteratee) {
-    var index = -1, result = Array(n);
-    while (++index < n) {
-      result[index] = iteratee(index);
+    var index2 = -1, result = Array(n);
+    while (++index2 < n) {
+      result[index2] = iteratee(index2);
     }
     return result;
   }
@@ -11226,9 +11226,9 @@ function require_equalObjects() {
     if (objLength != othLength && !isPartial) {
       return false;
     }
-    var index = objLength;
-    while (index--) {
-      var key = objProps[index];
+    var index2 = objLength;
+    while (index2--) {
+      var key = objProps[index2];
       if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
         return false;
       }
@@ -11242,8 +11242,8 @@ function require_equalObjects() {
     stack.set(object, other);
     stack.set(other, object);
     var skipCtor = isPartial;
-    while (++index < objLength) {
-      key = objProps[index];
+    while (++index2 < objLength) {
+      key = objProps[index2];
       var objValue = object[key], othValue = other[key];
       if (customizer) {
         var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
@@ -11416,7 +11416,7 @@ function requireIsEqualWith() {
   return isEqualWith_1;
 }
 var isEqualWithExports = requireIsEqualWith();
-const isEqualWith = /* @__PURE__ */ getDefaultExportFromCjs(isEqualWithExports);
+const isEqualWith = /* @__PURE__ */ getDefaultExportFromCjs$1(isEqualWithExports);
 var css_escape$1 = { exports: {} };
 /*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
 var css_escape = css_escape$1.exports;
@@ -11439,12 +11439,12 @@ function requireCss_escape() {
         }
         var string = String(value);
         var length = string.length;
-        var index = -1;
+        var index2 = -1;
         var codeUnit;
         var result = "";
         var firstCodeUnit = string.charCodeAt(0);
-        while (++index < length) {
-          codeUnit = string.charCodeAt(index);
+        while (++index2 < length) {
+          codeUnit = string.charCodeAt(index2);
           if (codeUnit == 0) {
             result += "�";
             continue;
@@ -11454,9 +11454,9 @@ function requireCss_escape() {
             // U+007F, […]
             codeUnit >= 1 && codeUnit <= 31 || codeUnit == 127 || // If the character is the first character and is in the range [0-9]
             // (U+0030 to U+0039), […]
-            index == 0 && codeUnit >= 48 && codeUnit <= 57 || // If the character is the second character and is in the range [0-9]
+            index2 == 0 && codeUnit >= 48 && codeUnit <= 57 || // If the character is the second character and is in the range [0-9]
             // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
-            index == 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit == 45
+            index2 == 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit == 45
           ) {
             result += "\\" + codeUnit.toString(16) + " ";
             continue;
@@ -11464,16 +11464,16 @@ function requireCss_escape() {
           if (
             // If the character is the first character and is a `-` (U+002D), and
             // there is no second character, […]
-            index == 0 && length == 1 && codeUnit == 45
+            index2 == 0 && length == 1 && codeUnit == 45
           ) {
-            result += "\\" + string.charAt(index);
+            result += "\\" + string.charAt(index2);
             continue;
           }
           if (codeUnit >= 128 || codeUnit == 45 || codeUnit == 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
-            result += string.charAt(index);
+            result += string.charAt(index2);
             continue;
           }
-          result += "\\" + string.charAt(index);
+          result += "\\" + string.charAt(index2);
         }
         return result;
       };
@@ -11487,7 +11487,7 @@ function requireCss_escape() {
   return css_escape$1.exports;
 }
 var css_escapeExports = requireCss_escape();
-const escape = /* @__PURE__ */ getDefaultExportFromCjs(css_escapeExports);
+const escape = /* @__PURE__ */ getDefaultExportFromCjs$1(css_escapeExports);
 class GenericTypeError extends Error {
   constructor(expectedString, received, matcherFn, context) {
     super();
@@ -13001,11 +13001,11 @@ function withSafeTimers(getTimers, fn) {
 const promises = /* @__PURE__ */ new Set();
 function createSafeRpc(client2) {
   return new Proxy(client2.rpc, {
-    get(target, p, handler) {
-      if (p === "then") {
+    get(target, p2, handler) {
+      if (p2 === "then") {
         return;
       }
-      const sendCall = get(target, p, handler);
+      const sendCall = get(target, p2, handler);
       const safeSendCall = (...args) => withSafeTimers(getSafeTimers, async () => {
         const result = sendCall(...args);
         promises.add(result);
@@ -13165,9 +13165,7 @@ class MockerRegistry {
     if (typeof typeOrEvent === "object") {
       const event = typeOrEvent;
       if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) {
-        throw new TypeError(
-          `[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`
-        );
+        throw new TypeError(`[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`);
       }
       if (event.type === "automock") {
         const module = AutomockedModule.fromJSON(event);
@@ -13294,16 +13292,12 @@ class ManualMockedModule {
     try {
       exports = await this.factory();
     } catch (err) {
-      const vitestError = new Error(
-        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock'
-      );
+      const vitestError = new Error('[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock');
       vitestError.cause = err;
       throw vitestError;
     }
     if (exports === null || typeof exports !== "object" || Array.isArray(exports)) {
-      throw new TypeError(
-        `[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`
-      );
+      throw new TypeError(`[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
     }
     return this.cache = exports;
   }
@@ -13332,11 +13326,7 @@ function mockObject(options, object, mockExports = {}) {
   const mockPropertiesOf = (container, newContainer) => {
     const containerType = getType(container);
     const isModule = containerType === "Module" || !!container.__esModule;
-    for (const { key: property, descriptor } of getAllMockableProperties(
-      container,
-      isModule,
-      options.globalConstructors
-    )) {
+    for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, options.globalConstructors)) {
       if (!isModule && descriptor.get) {
         try {
           Object.defineProperty(newContainer, property, descriptor);
@@ -13350,9 +13340,7 @@ function mockObject(options, object, mockExports = {}) {
       const value = container[property];
       const refId = refs.getId(value);
       if (refId !== void 0) {
-        finalizers.push(
-          () => define(newContainer, property, refs.getMockedValue(refId))
-        );
+        finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
         continue;
       }
       const type = getType(value);
@@ -13369,13 +13357,9 @@ function mockObject(options, object, mockExports = {}) {
         continue;
       }
       if (isFunction) {
-        let mockFunction2 = function() {
+        let mockFunction = function() {
           if (this instanceof newContainer[property]) {
-            for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
-              this,
-              false,
-              options.globalConstructors
-            )) {
+            for (const { key, descriptor: descriptor2 } of getAllMockableProperties(this, false, options.globalConstructors)) {
               if (descriptor2.get) {
                 continue;
               }
@@ -13396,18 +13380,16 @@ function mockObject(options, object, mockExports = {}) {
           }
         };
         if (!options.spyOn) {
-          throw new Error(
-            "[@vitest/mocker] `spyOn` is not defined. This is a Vitest error. Please open a new issue with reproduction."
-          );
+          throw new Error("[@vitest/mocker] `spyOn` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
         }
         const spyOn = options.spyOn;
         const mock = spyOn(newContainer, property);
         if (options.type === "automock") {
-          mock.mockImplementation(mockFunction2);
+          mock.mockImplementation(mockFunction);
           const origMockReset = mock.mockReset;
           mock.mockRestore = mock.mockReset = () => {
             origMockReset.call(mock);
-            mock.mockImplementation(mockFunction2);
+            mock.mockImplementation(mockFunction);
             return mock;
           };
         }
@@ -13446,7 +13428,13 @@ function getType(value) {
   return Object.prototype.toString.apply(value).slice(8, -1);
 }
 function isSpecialProp(prop, parentType) {
-  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+  return parentType.includes("Function") && typeof prop === "string" && [
+    "arguments",
+    "callee",
+    "caller",
+    "length",
+    "name"
+  ].includes(prop);
 }
 function getAllMockableProperties(obj, isModule, constructors) {
   const { Map: Map2, Object: Object2, Function: Function2, RegExp: RegExp2, Array: Array2 } = constructors;
@@ -13459,14 +13447,20 @@ function getAllMockableProperties(obj, isModule, constructors) {
     collectOwnProperties(curr, (key) => {
       const descriptor = Object2.getOwnPropertyDescriptor(curr, key);
       if (descriptor) {
-        allProps.set(key, { key, descriptor });
+        allProps.set(key, {
+          key,
+          descriptor
+        });
       }
     });
   } while (curr = Object2.getPrototypeOf(curr));
   if (isModule && !allProps.has("default") && "default" in obj) {
     const descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
     if (descriptor) {
-      allProps.set("default", { key: "default", descriptor });
+      allProps.set("default", {
+        key: "default",
+        descriptor
+      });
     }
   }
   return Array2.from(allProps.values());
@@ -13543,16 +13537,16 @@ function normalizeString(path, allowAboveRoot) {
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
+  for (let index2 = 0; index2 <= path.length; ++index2) {
+    if (index2 < path.length) {
+      char = path[index2];
     } else if (char === "/") {
       break;
     } else {
       char = "/";
     }
     if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ;
+      if (lastSlash === index2 - 1 || dots === 1) ;
       else if (dots === 2) {
         if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
           if (res.length > 2) {
@@ -13564,13 +13558,13 @@ function normalizeString(path, allowAboveRoot) {
               res = res.slice(0, lastSlashIndex);
               lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
             }
-            lastSlash = index;
+            lastSlash = index2;
             dots = 0;
             continue;
           } else if (res.length > 0) {
             res = "";
             lastSegmentLength = 0;
-            lastSlash = index;
+            lastSlash = index2;
             dots = 0;
             continue;
           }
@@ -13581,13 +13575,13 @@ function normalizeString(path, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
+          res += `/${path.slice(lastSlash + 1, index2)}`;
         } else {
-          res = path.slice(lastSlash + 1, index);
+          res = path.slice(lastSlash + 1, index2);
         }
-        lastSegmentLength = index - lastSlash - 1;
+        lastSegmentLength = index2 - lastSlash - 1;
       }
-      lastSlash = index;
+      lastSlash = index2;
       dots = 0;
     } else if (char === "." && dots !== -1) {
       ++dots;
@@ -13597,14 +13591,831 @@ function normalizeString(path, allowAboveRoot) {
   }
   return res;
 }
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
+const isAbsolute = function(p2) {
+  return _IS_ABSOLUTE_RE.test(p2);
 };
-const extname = function(p) {
-  if (p === "..") return "";
-  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+const extname = function(p2) {
+  if (p2 === "..") return "";
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p2));
   return match && match[1] || "";
 };
+var f = {
+  reset: [0, 0],
+  bold: [1, 22, "\x1B[22m\x1B[1m"],
+  dim: [2, 22, "\x1B[22m\x1B[2m"],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  blackBright: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49]
+}, h = Object.entries(f);
+function a(n) {
+  return String(n);
+}
+a.open = "";
+a.close = "";
+function C(n = false) {
+  let e = typeof process != "undefined" ? process : void 0, i = (e == null ? void 0 : e.env) || {}, g = (e == null ? void 0 : e.argv) || [];
+  return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window != "undefined" && !!window.chrome;
+}
+function p(n = false) {
+  let e = C(n), i = (r, t, c, o) => {
+    let l = "", s = 0;
+    do
+      l += r.substring(s, o) + c, s = o + t.length, o = r.indexOf(t, s);
+    while (~o);
+    return l + r.substring(s);
+  }, g = (r, t, c = r) => {
+    let o = (l) => {
+      let s = String(l), b = s.indexOf(t, r.length);
+      return ~b ? r + i(s, t, c, b) + t : r + s + t;
+    };
+    return o.open = r, o.close = t, o;
+  }, u = {
+    isColorSupported: e
+  }, d = (r) => `\x1B[${r}m`;
+  for (let [r, t] of h)
+    u[r] = e ? g(
+      d(t[0]),
+      d(t[1]),
+      t[2]
+    ) : a;
+  return u;
+}
+p();
+function _mergeNamespaces(n, m) {
+  m.forEach(function(e) {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+      if (k !== "default" && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function() {
+            return e[k];
+          }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var reactIs$1 = { exports: {} };
+var reactIs_production = {};
+/**
+* @license React
+* react-is.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var hasRequiredReactIs_production;
+function requireReactIs_production() {
+  if (hasRequiredReactIs_production) return reactIs_production;
+  hasRequiredReactIs_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+  var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+  function typeOf(object) {
+    if ("object" === typeof object && null !== object) {
+      var $$typeof = object.$$typeof;
+      switch ($$typeof) {
+        case REACT_ELEMENT_TYPE:
+          switch (object = object.type, object) {
+            case REACT_FRAGMENT_TYPE:
+            case REACT_PROFILER_TYPE:
+            case REACT_STRICT_MODE_TYPE:
+            case REACT_SUSPENSE_TYPE:
+            case REACT_SUSPENSE_LIST_TYPE:
+              return object;
+            default:
+              switch (object = object && object.$$typeof, object) {
+                case REACT_CONTEXT_TYPE:
+                case REACT_FORWARD_REF_TYPE:
+                case REACT_LAZY_TYPE:
+                case REACT_MEMO_TYPE:
+                  return object;
+                case REACT_CONSUMER_TYPE:
+                  return object;
+                default:
+                  return $$typeof;
+              }
+          }
+        case REACT_PORTAL_TYPE:
+          return $$typeof;
+      }
+    }
+  }
+  reactIs_production.ContextConsumer = REACT_CONSUMER_TYPE;
+  reactIs_production.ContextProvider = REACT_CONTEXT_TYPE;
+  reactIs_production.Element = REACT_ELEMENT_TYPE;
+  reactIs_production.ForwardRef = REACT_FORWARD_REF_TYPE;
+  reactIs_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactIs_production.Lazy = REACT_LAZY_TYPE;
+  reactIs_production.Memo = REACT_MEMO_TYPE;
+  reactIs_production.Portal = REACT_PORTAL_TYPE;
+  reactIs_production.Profiler = REACT_PROFILER_TYPE;
+  reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE;
+  reactIs_production.Suspense = REACT_SUSPENSE_TYPE;
+  reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+  reactIs_production.isContextConsumer = function(object) {
+    return typeOf(object) === REACT_CONSUMER_TYPE;
+  };
+  reactIs_production.isContextProvider = function(object) {
+    return typeOf(object) === REACT_CONTEXT_TYPE;
+  };
+  reactIs_production.isElement = function(object) {
+    return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+  };
+  reactIs_production.isForwardRef = function(object) {
+    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+  };
+  reactIs_production.isFragment = function(object) {
+    return typeOf(object) === REACT_FRAGMENT_TYPE;
+  };
+  reactIs_production.isLazy = function(object) {
+    return typeOf(object) === REACT_LAZY_TYPE;
+  };
+  reactIs_production.isMemo = function(object) {
+    return typeOf(object) === REACT_MEMO_TYPE;
+  };
+  reactIs_production.isPortal = function(object) {
+    return typeOf(object) === REACT_PORTAL_TYPE;
+  };
+  reactIs_production.isProfiler = function(object) {
+    return typeOf(object) === REACT_PROFILER_TYPE;
+  };
+  reactIs_production.isStrictMode = function(object) {
+    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+  };
+  reactIs_production.isSuspense = function(object) {
+    return typeOf(object) === REACT_SUSPENSE_TYPE;
+  };
+  reactIs_production.isSuspenseList = function(object) {
+    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+  };
+  reactIs_production.isValidElementType = function(type) {
+    return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+  };
+  reactIs_production.typeOf = typeOf;
+  return reactIs_production;
+}
+var hasRequiredReactIs$1;
+function requireReactIs$1() {
+  if (hasRequiredReactIs$1) return reactIs$1.exports;
+  hasRequiredReactIs$1 = 1;
+  {
+    reactIs$1.exports = requireReactIs_production();
+  }
+  return reactIs$1.exports;
+}
+var reactIsExports$1 = requireReactIs$1();
+var index$1 = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports$1);
+var ReactIs19 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: index$1
+}, [reactIsExports$1]);
+var reactIs = { exports: {} };
+var reactIs_production_min = {};
+/**
+* @license React
+* react-is.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+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"), f2 = Symbol.for("react.profiler"), g = 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"), p2 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
+  u = Symbol.for("react.module.reference");
+  function v(a2) {
+    if ("object" === typeof a2 && null !== a2) {
+      var r = a2.$$typeof;
+      switch (r) {
+        case b:
+          switch (a2 = a2.type, a2) {
+            case d:
+            case f2:
+            case e:
+            case m:
+            case n:
+              return a2;
+            default:
+              switch (a2 = a2 && a2.$$typeof, a2) {
+                case k:
+                case h2:
+                case l:
+                case q:
+                case p2:
+                case g:
+                  return a2;
+                default:
+                  return r;
+              }
+          }
+        case c:
+          return r;
+      }
+    }
+  }
+  reactIs_production_min.ContextConsumer = h2;
+  reactIs_production_min.ContextProvider = g;
+  reactIs_production_min.Element = b;
+  reactIs_production_min.ForwardRef = l;
+  reactIs_production_min.Fragment = d;
+  reactIs_production_min.Lazy = q;
+  reactIs_production_min.Memo = p2;
+  reactIs_production_min.Portal = c;
+  reactIs_production_min.Profiler = f2;
+  reactIs_production_min.StrictMode = e;
+  reactIs_production_min.Suspense = m;
+  reactIs_production_min.SuspenseList = n;
+  reactIs_production_min.isAsyncMode = function() {
+    return false;
+  };
+  reactIs_production_min.isConcurrentMode = function() {
+    return false;
+  };
+  reactIs_production_min.isContextConsumer = function(a2) {
+    return v(a2) === h2;
+  };
+  reactIs_production_min.isContextProvider = function(a2) {
+    return v(a2) === g;
+  };
+  reactIs_production_min.isElement = function(a2) {
+    return "object" === typeof a2 && null !== a2 && a2.$$typeof === b;
+  };
+  reactIs_production_min.isForwardRef = function(a2) {
+    return v(a2) === l;
+  };
+  reactIs_production_min.isFragment = function(a2) {
+    return v(a2) === d;
+  };
+  reactIs_production_min.isLazy = function(a2) {
+    return v(a2) === q;
+  };
+  reactIs_production_min.isMemo = function(a2) {
+    return v(a2) === p2;
+  };
+  reactIs_production_min.isPortal = function(a2) {
+    return v(a2) === c;
+  };
+  reactIs_production_min.isProfiler = function(a2) {
+    return v(a2) === f2;
+  };
+  reactIs_production_min.isStrictMode = function(a2) {
+    return v(a2) === e;
+  };
+  reactIs_production_min.isSuspense = function(a2) {
+    return v(a2) === m;
+  };
+  reactIs_production_min.isSuspenseList = function(a2) {
+    return v(a2) === n;
+  };
+  reactIs_production_min.isValidElementType = function(a2) {
+    return "string" === typeof a2 || "function" === typeof a2 || a2 === d || a2 === f2 || a2 === e || a2 === m || a2 === n || a2 === t || "object" === typeof a2 && null !== a2 && (a2.$$typeof === q || a2.$$typeof === p2 || a2.$$typeof === g || a2.$$typeof === h2 || a2.$$typeof === l || a2.$$typeof === u || void 0 !== a2.getModuleId) ? true : false;
+  };
+  reactIs_production_min.typeOf = v;
+  return reactIs_production_min;
+}
+var hasRequiredReactIs;
+function requireReactIs() {
+  if (hasRequiredReactIs) return reactIs.exports;
+  hasRequiredReactIs = 1;
+  {
+    reactIs.exports = requireReactIs_production_min();
+  }
+  return reactIs.exports;
+}
+var reactIsExports = requireReactIs();
+var index = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports);
+var ReactIs18 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [reactIsExports]);
+const reactIsMethods = [
+  "isAsyncMode",
+  "isConcurrentMode",
+  "isContextConsumer",
+  "isContextProvider",
+  "isElement",
+  "isForwardRef",
+  "isFragment",
+  "isLazy",
+  "isMemo",
+  "isPortal",
+  "isProfiler",
+  "isStrictMode",
+  "isSuspense",
+  "isSuspenseList",
+  "isValidElementType"
+];
+Object.fromEntries(reactIsMethods.map((m) => [m, (v) => ReactIs18[m](v) || ReactIs19[m](v)]));
+let getPromiseValue = () => "Promise{…}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
+let nodeInspect = false;
+try {
+  const nodeUtil = require("util");
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect = false;
+}
+var jsTokens_1;
+var hasRequiredJsTokens;
+function requireJsTokens() {
+  if (hasRequiredJsTokens) return jsTokens_1;
+  hasRequiredJsTokens = 1;
+  var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+  RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy;
+  Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+  Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy;
+  StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y;
+  NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+  Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+  WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy;
+  LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+  MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y;
+  SingleLineComment = /\/\/.*/y;
+  JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+  JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
+  JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y;
+  JSXText = /[^<>{}]+/y;
+  TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+  TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+  KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+  KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+  Newline = RegExp(LineTerminatorSequence.source);
+  jsTokens_1 = function* (input, { jsx = false } = {}) {
+    var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+    ({ length } = input);
+    lastIndex = 0;
+    lastSignificantToken = "";
+    stack = [{ tag: "JS" }];
+    braces = [];
+    parenNesting = 0;
+    postfixIncDec = false;
+    while (lastIndex < length) {
+      mode = stack[stack.length - 1];
+      switch (mode.tag) {
+        case "JS":
+        case "JSNonExpressionParen":
+        case "InterpolationInTemplate":
+        case "InterpolationInJSX":
+          if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+            RegularExpressionLiteral.lastIndex = lastIndex;
+            if (match = RegularExpressionLiteral.exec(input)) {
+              lastIndex = RegularExpressionLiteral.lastIndex;
+              lastSignificantToken = match[0];
+              postfixIncDec = true;
+              yield {
+                type: "RegularExpressionLiteral",
+                value: match[0],
+                closed: match[1] !== void 0 && match[1] !== "\\"
+              };
+              continue;
+            }
+          }
+          Punctuator.lastIndex = lastIndex;
+          if (match = Punctuator.exec(input)) {
+            punctuator = match[0];
+            nextLastIndex = Punctuator.lastIndex;
+            nextLastSignificantToken = punctuator;
+            switch (punctuator) {
+              case "(":
+                if (lastSignificantToken === "?NonExpressionParenKeyword") {
+                  stack.push({
+                    tag: "JSNonExpressionParen",
+                    nesting: parenNesting
+                  });
+                }
+                parenNesting++;
+                postfixIncDec = false;
+                break;
+              case ")":
+                parenNesting--;
+                postfixIncDec = true;
+                if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+                  stack.pop();
+                  nextLastSignificantToken = "?NonExpressionParenEnd";
+                  postfixIncDec = false;
+                }
+                break;
+              case "{":
+                Punctuator.lastIndex = 0;
+                isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+                braces.push(isExpression);
+                postfixIncDec = false;
+                break;
+              case "}":
+                switch (mode.tag) {
+                  case "InterpolationInTemplate":
+                    if (braces.length === mode.nesting) {
+                      Template.lastIndex = lastIndex;
+                      match = Template.exec(input);
+                      lastIndex = Template.lastIndex;
+                      lastSignificantToken = match[0];
+                      if (match[1] === "${") {
+                        lastSignificantToken = "?InterpolationInTemplate";
+                        postfixIncDec = false;
+                        yield {
+                          type: "TemplateMiddle",
+                          value: match[0]
+                        };
+                      } else {
+                        stack.pop();
+                        postfixIncDec = true;
+                        yield {
+                          type: "TemplateTail",
+                          value: match[0],
+                          closed: match[1] === "`"
+                        };
+                      }
+                      continue;
+                    }
+                    break;
+                  case "InterpolationInJSX":
+                    if (braces.length === mode.nesting) {
+                      stack.pop();
+                      lastIndex += 1;
+                      lastSignificantToken = "}";
+                      yield {
+                        type: "JSXPunctuator",
+                        value: "}"
+                      };
+                      continue;
+                    }
+                }
+                postfixIncDec = braces.pop();
+                nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+                break;
+              case "]":
+                postfixIncDec = true;
+                break;
+              case "++":
+              case "--":
+                nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+                break;
+              case "<":
+                if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+                  stack.push({ tag: "JSXTag" });
+                  lastIndex += 1;
+                  lastSignificantToken = "<";
+                  yield {
+                    type: "JSXPunctuator",
+                    value: punctuator
+                  };
+                  continue;
+                }
+                postfixIncDec = false;
+                break;
+              default:
+                postfixIncDec = false;
+            }
+            lastIndex = nextLastIndex;
+            lastSignificantToken = nextLastSignificantToken;
+            yield {
+              type: "Punctuator",
+              value: punctuator
+            };
+            continue;
+          }
+          Identifier.lastIndex = lastIndex;
+          if (match = Identifier.exec(input)) {
+            lastIndex = Identifier.lastIndex;
+            nextLastSignificantToken = match[0];
+            switch (match[0]) {
+              case "for":
+              case "if":
+              case "while":
+              case "with":
+                if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+                  nextLastSignificantToken = "?NonExpressionParenKeyword";
+                }
+            }
+            lastSignificantToken = nextLastSignificantToken;
+            postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+            yield {
+              type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+              value: match[0]
+            };
+            continue;
+          }
+          StringLiteral.lastIndex = lastIndex;
+          if (match = StringLiteral.exec(input)) {
+            lastIndex = StringLiteral.lastIndex;
+            lastSignificantToken = match[0];
+            postfixIncDec = true;
+            yield {
+              type: "StringLiteral",
+              value: match[0],
+              closed: match[2] !== void 0
+            };
+            continue;
+          }
+          NumericLiteral.lastIndex = lastIndex;
+          if (match = NumericLiteral.exec(input)) {
+            lastIndex = NumericLiteral.lastIndex;
+            lastSignificantToken = match[0];
+            postfixIncDec = true;
+            yield {
+              type: "NumericLiteral",
+              value: match[0]
+            };
+            continue;
+          }
+          Template.lastIndex = lastIndex;
+          if (match = Template.exec(input)) {
+            lastIndex = Template.lastIndex;
+            lastSignificantToken = match[0];
+            if (match[1] === "${") {
+              lastSignificantToken = "?InterpolationInTemplate";
+              stack.push({
+                tag: "InterpolationInTemplate",
+                nesting: braces.length
+              });
+              postfixIncDec = false;
+              yield {
+                type: "TemplateHead",
+                value: match[0]
+              };
+            } else {
+              postfixIncDec = true;
+              yield {
+                type: "NoSubstitutionTemplate",
+                value: match[0],
+                closed: match[1] === "`"
+              };
+            }
+            continue;
+          }
+          break;
+        case "JSXTag":
+        case "JSXTagEnd":
+          JSXPunctuator.lastIndex = lastIndex;
+          if (match = JSXPunctuator.exec(input)) {
+            lastIndex = JSXPunctuator.lastIndex;
+            nextLastSignificantToken = match[0];
+            switch (match[0]) {
+              case "<":
+                stack.push({ tag: "JSXTag" });
+                break;
+              case ">":
+                stack.pop();
+                if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+                  nextLastSignificantToken = "?JSX";
+                  postfixIncDec = true;
+                } else {
+                  stack.push({ tag: "JSXChildren" });
+                }
+                break;
+              case "{":
+                stack.push({
+                  tag: "InterpolationInJSX",
+                  nesting: braces.length
+                });
+                nextLastSignificantToken = "?InterpolationInJSX";
+                postfixIncDec = false;
+                break;
+              case "/":
+                if (lastSignificantToken === "<") {
+                  stack.pop();
+                  if (stack[stack.length - 1].tag === "JSXChildren") {
+                    stack.pop();
+                  }
+                  stack.push({ tag: "JSXTagEnd" });
+                }
+            }
+            lastSignificantToken = nextLastSignificantToken;
+            yield {
+              type: "JSXPunctuator",
+              value: match[0]
+            };
+            continue;
+          }
+          JSXIdentifier.lastIndex = lastIndex;
+          if (match = JSXIdentifier.exec(input)) {
+            lastIndex = JSXIdentifier.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXIdentifier",
+              value: match[0]
+            };
+            continue;
+          }
+          JSXString.lastIndex = lastIndex;
+          if (match = JSXString.exec(input)) {
+            lastIndex = JSXString.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXString",
+              value: match[0],
+              closed: match[2] !== void 0
+            };
+            continue;
+          }
+          break;
+        case "JSXChildren":
+          JSXText.lastIndex = lastIndex;
+          if (match = JSXText.exec(input)) {
+            lastIndex = JSXText.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXText",
+              value: match[0]
+            };
+            continue;
+          }
+          switch (input[lastIndex]) {
+            case "<":
+              stack.push({ tag: "JSXTag" });
+              lastIndex++;
+              lastSignificantToken = "<";
+              yield {
+                type: "JSXPunctuator",
+                value: "<"
+              };
+              continue;
+            case "{":
+              stack.push({
+                tag: "InterpolationInJSX",
+                nesting: braces.length
+              });
+              lastIndex++;
+              lastSignificantToken = "?InterpolationInJSX";
+              postfixIncDec = false;
+              yield {
+                type: "JSXPunctuator",
+                value: "{"
+              };
+              continue;
+          }
+      }
+      WhiteSpace.lastIndex = lastIndex;
+      if (match = WhiteSpace.exec(input)) {
+        lastIndex = WhiteSpace.lastIndex;
+        yield {
+          type: "WhiteSpace",
+          value: match[0]
+        };
+        continue;
+      }
+      LineTerminatorSequence.lastIndex = lastIndex;
+      if (match = LineTerminatorSequence.exec(input)) {
+        lastIndex = LineTerminatorSequence.lastIndex;
+        postfixIncDec = false;
+        if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+          lastSignificantToken = "?NoLineTerminatorHere";
+        }
+        yield {
+          type: "LineTerminatorSequence",
+          value: match[0]
+        };
+        continue;
+      }
+      MultiLineComment.lastIndex = lastIndex;
+      if (match = MultiLineComment.exec(input)) {
+        lastIndex = MultiLineComment.lastIndex;
+        if (Newline.test(match[0])) {
+          postfixIncDec = false;
+          if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+            lastSignificantToken = "?NoLineTerminatorHere";
+          }
+        }
+        yield {
+          type: "MultiLineComment",
+          value: match[0],
+          closed: match[1] !== void 0
+        };
+        continue;
+      }
+      SingleLineComment.lastIndex = lastIndex;
+      if (match = SingleLineComment.exec(input)) {
+        lastIndex = SingleLineComment.lastIndex;
+        postfixIncDec = false;
+        yield {
+          type: "SingleLineComment",
+          value: match[0]
+        };
+        continue;
+      }
+      firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+      lastIndex += firstCodePoint.length;
+      lastSignificantToken = firstCodePoint;
+      postfixIncDec = false;
+      yield {
+        type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+        value: firstCodePoint
+      };
+    }
+    return void 0;
+  };
+  return jsTokens_1;
+}
+requireJsTokens();
+var reservedWords = {
+  keyword: [
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "debugger",
+    "default",
+    "do",
+    "else",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "var",
+    "const",
+    "while",
+    "with",
+    "new",
+    "this",
+    "super",
+    "class",
+    "extends",
+    "export",
+    "import",
+    "null",
+    "true",
+    "false",
+    "in",
+    "instanceof",
+    "typeof",
+    "void",
+    "delete"
+  ],
+  strict: [
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield"
+  ]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
 const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 const intToChar = new Uint8Array(64);
 const charToInt = new Uint8Array(128);
@@ -13670,9 +14481,7 @@ class ModuleMocker {
   async importActual(id, importer) {
     const resolved = await this.rpc.resolveId(id, importer);
     if (resolved == null) {
-      throw new Error(
-        `[vitest] Cannot resolve "${id}" imported from "${importer}"`
-      );
+      throw new Error(`[vitest] Cannot resolve "${id}" imported from "${importer}"`);
     }
     const ext = extname(resolved.id);
     const url2 = new URL(resolved.url, location.href);
@@ -13686,16 +14495,15 @@ class ModuleMocker {
         return mod;
       }
       const m = mod.default;
-      return (m == null ? void 0 : m.__esModule) ? m : { ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, default: m };
+      return (m === null || m === void 0 ? void 0 : m.__esModule) ? m : {
+        ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {},
+        default: m
+      };
     });
   }
   async importMock(rawId, importer) {
     await this.prepare();
-    const { resolvedId, resolvedUrl, redirectUrl } = await this.rpc.resolveMock(
-      rawId,
-      importer,
-      { mock: "auto" }
-    );
+    const { resolvedId, resolvedUrl, redirectUrl } = await this.rpc.resolveMock(rawId, importer, { mock: "auto" });
     const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl));
     let mock = this.registry.get(mockUrl);
     if (!mock) {
@@ -13737,9 +14545,7 @@ class ModuleMocker {
     }, object);
   }
   queueMock(rawId, importer, factoryOrOptions) {
-    const promise = this.rpc.resolveMock(rawId, importer, {
-      mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions == null ? void 0 : factoryOrOptions.spy) ? "spy" : "auto"
-    }).then(async ({ redirectUrl, resolvedId, resolvedUrl, needsInterop, mockType }) => {
+    const promise = this.rpc.resolveMock(rawId, importer, { mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions === null || factoryOrOptions === void 0 ? void 0 : factoryOrOptions.spy) ? "spy" : "auto" }).then(async ({ redirectUrl, resolvedId, resolvedUrl, needsInterop, mockType }) => {
       const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl));
       this.mockedIds.add(resolvedId);
       const factory = typeof factoryOrOptions === "function" ? async () => {
@@ -13777,8 +14583,6 @@ class ModuleMocker {
     });
     this.queue.add(promise);
   }
-  // We need to await mock registration before importing the actual module
-  // In case there is a mocked module in the import chain
   wrapDynamicImport(moduleFactory) {
     if (typeof moduleFactory === "function") {
       const promise = new Promise((resolve2, reject) => {
@@ -13842,11 +14646,7 @@ class ModuleMockerMSWInterceptor {
     }).join("\n");
     const text = `${module}
 ${keys}`;
-    return new Response(text, {
-      headers: {
-        "Content-Type": "application/javascript"
-      }
-    });
+    return new Response(text, { headers: { "Content-Type": "application/javascript" } });
   }
   async init() {
     if (this.worker) {
@@ -13856,35 +14656,28 @@ ${keys}`;
       return this.startPromise;
     }
     const worker = this.options.mswWorker;
-    this.startPromise = Promise.all([
-      worker ? {
-        setupWorker(handler) {
-          worker.use(handler);
-          return worker;
+    this.startPromise = Promise.all([worker ? { setupWorker(handler) {
+      worker.use(handler);
+      return worker;
+    } } : __vitePreload(() => import("msw/browser"), true ? [] : void 0), __vitePreload(() => import("msw/core/http"), true ? [] : void 0)]).then(([{ setupWorker }, { http }]) => {
+      const worker2 = setupWorker(http.get(/.+/, async ({ request }) => {
+        const path = cleanQuery(request.url.slice(location.origin.length));
+        if (!this.mocks.has(path)) {
+          return passthrough();
         }
-      } : __vitePreload(() => import("msw/browser"), true ? [] : void 0),
-      __vitePreload(() => import("msw/core/http"), true ? [] : void 0)
-    ]).then(([{ setupWorker }, { http }]) => {
-      const worker2 = setupWorker(
-        http.get(/.+/, async ({ request }) => {
-          const path = cleanQuery(request.url.slice(location.origin.length));
-          if (!this.mocks.has(path)) {
-            return passthrough();
-          }
-          const mock = this.mocks.get(path);
-          switch (mock.type) {
-            case "manual":
-              return this.resolveManualMock(mock);
-            case "automock":
-            case "autospy":
-              return Response.redirect(injectQuery(path, `mock=${mock.type}`));
-            case "redirect":
-              return Response.redirect(mock.redirect);
-            default:
-              throw new Error(`Unknown mock type: ${mock.type}`);
-          }
-        })
-      );
+        const mock = this.mocks.get(path);
+        switch (mock.type) {
+          case "manual":
+            return this.resolveManualMock(mock);
+          case "automock":
+          case "autospy":
+            return Response.redirect(injectQuery(path, `mock=${mock.type}`));
+          case "redirect":
+            return Response.redirect(mock.redirect);
+          default:
+            throw new Error(`Unknown mock type: ${mock.type}`);
+        }
+      }));
       return worker2.start(this.options.mswOptions).then(() => worker2);
     }).finally(() => {
       this.worker = worker;
@@ -13903,17 +14696,12 @@ function passthrough() {
   return new Response(null, {
     status: 302,
     statusText: "Passthrough",
-    headers: {
-      "x-msw-intention": "passthrough"
-    }
+    headers: { "x-msw-intention": "passthrough" }
   });
 }
 const replacePercentageRE = /%/g;
 function injectQuery(url2, queryToInject) {
-  const resolvedUrl = new URL(
-    url2.replace(replacePercentageRE, "%25"),
-    location.href
-  );
+  const resolvedUrl = new URL(url2.replace(replacePercentageRE, "%25"), location.href);
   const { search, hash } = resolvedUrl;
   const pathname = cleanUrl(url2);
   return `${pathname}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
@@ -14090,10 +14878,10 @@ function requireSourcemapCodec_umd() {
         }
         return writer.flush();
       }
-      function _encodeOriginalScopes(scopes, index, writer, state) {
-        const scope = scopes[index];
+      function _encodeOriginalScopes(scopes, index2, writer, state) {
+        const scope = scopes[index2];
         const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
-        if (index > 0)
+        if (index2 > 0)
           writer.write(comma);
         state[0] = encodeInteger(writer, startLine, state[0]);
         encodeInteger(writer, startColumn, 0);
@@ -14105,18 +14893,18 @@ function requireSourcemapCodec_umd() {
         for (const v of vars) {
           encodeInteger(writer, v, 0);
         }
-        for (index++; index < scopes.length; ) {
-          const next = scopes[index];
+        for (index2++; index2 < scopes.length; ) {
+          const next = scopes[index2];
           const { 0: l, 1: c } = next;
           if (l > endLine || l === endLine && c >= endColumn) {
             break;
           }
-          index = _encodeOriginalScopes(scopes, index, writer, state);
+          index2 = _encodeOriginalScopes(scopes, index2, writer, state);
         }
         writer.write(comma);
         state[0] = encodeInteger(writer, endLine, state[0]);
         encodeInteger(writer, endColumn, 0);
-        return index;
+        return index2;
       }
       function decodeGeneratedRanges(input) {
         const { length } = input;
@@ -14208,14 +14996,14 @@ function requireSourcemapCodec_umd() {
         }
         return writer.flush();
       }
-      function _encodeGeneratedRanges(ranges, index, writer, state) {
-        const range = ranges[index];
+      function _encodeGeneratedRanges(ranges, index2, writer, state) {
+        const range = ranges[index2];
         const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings } = range;
         if (state[0] < startLine) {
           catchupLine(writer, state[0], startLine);
           state[0] = startLine;
           state[1] = 0;
-        } else if (index > 0) {
+        } else if (index2 > 0) {
           writer.write(comma);
         }
         state[1] = encodeInteger(writer, range[1], state[1]);
@@ -14257,13 +15045,13 @@ function requireSourcemapCodec_umd() {
             }
           }
         }
-        for (index++; index < ranges.length; ) {
-          const next = ranges[index];
+        for (index2++; index2 < ranges.length; ) {
+          const next = ranges[index2];
           const { 0: l, 1: c } = next;
           if (l > endLine || l === endLine && c >= endColumn) {
             break;
           }
-          index = _encodeGeneratedRanges(ranges, index, writer, state);
+          index2 = _encodeGeneratedRanges(ranges, index2, writer, state);
         }
         if (state[0] < endLine) {
           catchupLine(writer, state[0], endLine);
@@ -14273,7 +15061,7 @@ function requireSourcemapCodec_umd() {
           writer.write(comma);
         }
         state[1] = encodeInteger(writer, endColumn, state[1]);
-        return index;
+        return index2;
       }
       function catchupLine(writer, lastLine, line) {
         do {
@@ -14327,8 +15115,8 @@ function requireSourcemapCodec_umd() {
       function sort(line) {
         line.sort(sortComparator);
       }
-      function sortComparator(a, b) {
-        return a[0] - b[0];
+      function sortComparator(a2, b) {
+        return a2[0] - b[0];
       }
       function encode(decoded) {
         const writer = new StringWriter();
@@ -14457,8 +15245,8 @@ function requireResolveUri_umd() {
       function stripPathFilename(path) {
         if (path.endsWith("/.."))
           return path;
-        const index = path.lastIndexOf("/");
-        return path.slice(0, index + 1);
+        const index2 = path.lastIndexOf("/");
+        return path.slice(0, index2 + 1);
       }
       function mergePaths(url2, base) {
         normalizePath(base, base.type);
@@ -14580,8 +15368,8 @@ function requireTraceMapping_umd() {
       function stripFilename(path) {
         if (!path)
           return "";
-        const index = path.lastIndexOf("/");
-        return path.slice(0, index + 1);
+        const index2 = path.lastIndexOf("/");
+        return path.slice(0, index2 + 1);
       }
       const COLUMN = 0;
       const SOURCES_INDEX = 1;
@@ -14621,8 +15409,8 @@ function requireTraceMapping_umd() {
           line = line.slice();
         return line.sort(sortComparator);
       }
-      function sortComparator(a, b) {
-        return a[COLUMN] - b[COLUMN];
+      function sortComparator(a2, b) {
+        return a2[COLUMN] - b[COLUMN];
       }
       let found = false;
       function binarySearch(haystack, needle, low, high) {
@@ -14642,19 +15430,19 @@ function requireTraceMapping_umd() {
         found = false;
         return low - 1;
       }
-      function upperBound(haystack, needle, index) {
-        for (let i = index + 1; i < haystack.length; index = i++) {
+      function upperBound(haystack, needle, index2) {
+        for (let i = index2 + 1; i < haystack.length; index2 = i++) {
           if (haystack[i][COLUMN] !== needle)
             break;
         }
-        return index;
+        return index2;
       }
-      function lowerBound(haystack, needle, index) {
-        for (let i = index - 1; i >= 0; index = i--) {
+      function lowerBound(haystack, needle, index2) {
+        for (let i = index2 - 1; i >= 0; index2 = i--) {
           if (haystack[i][COLUMN] !== needle)
             break;
         }
-        return index;
+        return index2;
       }
       function memoizedState() {
         return {
@@ -14696,18 +15484,18 @@ function requireTraceMapping_umd() {
             const originalSource = sources[sourceIndex2];
             const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
             const memo = memos[sourceIndex2];
-            let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
-            memo.lastIndex = ++index;
-            insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
+            let index2 = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+            memo.lastIndex = ++index2;
+            insert(originalLine, index2, [sourceColumn, i, seg[COLUMN]]);
           }
         }
         return sources;
       }
-      function insert(array, index, value) {
-        for (let i = array.length; i > index; i--) {
+      function insert(array, index2, value) {
+        for (let i = array.length; i > index2; i--) {
           array[i] = array[i - 1];
         }
-        array[index] = value;
+        array[index2] = value;
       }
       function buildNullArray() {
         return { __proto__: null };
@@ -14801,10 +15589,10 @@ function requireTraceMapping_umd() {
         for (let i = 0; i < other.length; i++)
           arr.push(other[i]);
       }
-      function getLine(arr, index) {
-        for (let i = arr.length; i <= index; i++)
+      function getLine(arr, index2) {
+        for (let i = arr.length; i <= index2; i++)
           arr[i] = [];
-        return arr[index];
+        return arr[index2];
       }
       const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
       const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
@@ -14856,8 +15644,8 @@ function requireTraceMapping_umd() {
         if (line >= decoded.length)
           return null;
         const segments = decoded[line];
-        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
-        return index === -1 ? null : segments[index];
+        const index2 = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+        return index2 === -1 ? null : segments[index2];
       }
       function originalPositionFor2(map, needle) {
         let { line, column, bias } = needle;
@@ -14870,10 +15658,10 @@ function requireTraceMapping_umd() {
         if (line >= decoded.length)
           return OMapping(null, null, null, null);
         const segments = decoded[line];
-        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-        if (index === -1)
+        const index2 = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+        if (index2 === -1)
           return OMapping(null, null, null, null);
-        const segment = segments[index];
+        const segment = segments[index2];
         if (segment.length === 1)
           return OMapping(null, null, null, null);
         const { names, resolvedSources } = map;
@@ -14920,24 +15708,24 @@ function requireTraceMapping_umd() {
       }
       function sourceIndex(map, source2) {
         const { sources, resolvedSources } = map;
-        let index = sources.indexOf(source2);
-        if (index === -1)
-          index = resolvedSources.indexOf(source2);
-        return index;
+        let index2 = sources.indexOf(source2);
+        if (index2 === -1)
+          index2 = resolvedSources.indexOf(source2);
+        return index2;
       }
       function sourceContentFor(map, source2) {
         const { sourcesContent } = map;
         if (sourcesContent == null)
           return null;
-        const index = sourceIndex(map, source2);
-        return index === -1 ? null : sourcesContent[index];
+        const index2 = sourceIndex(map, source2);
+        return index2 === -1 ? null : sourcesContent[index2];
       }
       function isIgnored(map, source2) {
         const { ignoreList } = map;
         if (ignoreList == null)
           return false;
-        const index = sourceIndex(map, source2);
-        return index === -1 ? false : ignoreList.includes(index);
+        const index2 = sourceIndex(map, source2);
+        return index2 === -1 ? false : ignoreList.includes(index2);
       }
       function presortedDecodedMap(map, mapUrl) {
         const tracer = new TraceMap2(clone(map, []), mapUrl);
@@ -14969,14 +15757,14 @@ function requireTraceMapping_umd() {
         return { line, column };
       }
       function traceSegmentInternal(segments, memo, line, column, bias) {
-        let index = memoizedBinarySearch(segments, column, memo, line);
+        let index2 = memoizedBinarySearch(segments, column, memo, line);
         if (found) {
-          index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+          index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
         } else if (bias === LEAST_UPPER_BOUND)
-          index++;
-        if (index === -1 || index === segments.length)
+          index2++;
+        if (index2 === -1 || index2 === segments.length)
           return -1;
-        return index;
+        return index2;
       }
       function sliceGeneratedPositions(segments, memo, line, column, bias) {
         let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
@@ -15015,10 +15803,10 @@ function requireTraceMapping_umd() {
         const memo = cast(map)._bySourceMemos[sourceIndex2];
         if (all)
           return sliceGeneratedPositions(segments, memo, line, column, bias);
-        const index = traceSegmentInternal(segments, memo, line, column, bias);
-        if (index === -1)
+        const index2 = traceSegmentInternal(segments, memo, line, column, bias);
+        if (index2 === -1)
           return GMapping(null, null);
-        const segment = segments[index];
+        const segment = segments[index2];
         return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
       }
       exports2.AnyMap = AnyMap;
@@ -15203,7 +15991,7 @@ function parseStacktrace(stack, options = {}) {
   }).filter((s) => s != null);
 }
 function shouldFilter(ignoreStackEntries, file) {
-  return ignoreStackEntries.some((p) => file.match(p));
+  return ignoreStackEntries.some((p2) => file.match(p2));
 }
 function parseFFOrSafariStackTrace(stack) {
   return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);