@procore/hammer-test-jest 0.1.0 → 0.2.0

package/dist/transforms/reactSvg.test.mjs

@@ -278,16 +278,16 @@ var require_collections = __commonJS({
       if (list.length) {
         result += config2.spacingOuter;
         const indentationNext = indentation + config2.indent;
-        for (let i = 0; i < list.length; i++) {
+        for (let i2 = 0; i2 < list.length; i2++) {
           result += indentationNext;
-          if (i === config2.maxWidth) {
+          if (i2 === config2.maxWidth) {
             result += "\u2026";
             break;
           }
-          if (i in list) {
-            result += printer(list[i], config2, indentationNext, depth, refs);
+          if (i2 in list) {
+            result += printer(list[i2], config2, indentationNext, depth, refs);
           }
-          if (i < list.length - 1) {
+          if (i2 < list.length - 1) {
             result += `,${config2.spacingInner}`;
           } else if (!config2.min) {
             result += ",";
@@ -303,12 +303,12 @@ var require_collections = __commonJS({
       if (keys2.length) {
         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 = printer(key, config2, indentationNext, depth, refs);
           const value = printer(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 += ",";
@@ -629,11 +629,11 @@ var require_Immutable = __commonJS({
       printer
     )}}`;
     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)]
@@ -761,62 +761,62 @@ var require_react_is_production_min = __commonJS({
     "use strict";
     init_esm_shims();
     var b2 = Symbol.for("react.element");
-    var c = Symbol.for("react.portal");
-    var d2 = Symbol.for("react.fragment");
+    var c2 = Symbol.for("react.portal");
+    var d = Symbol.for("react.fragment");
     var e = Symbol.for("react.strict_mode");
-    var f = Symbol.for("react.profiler");
-    var g = Symbol.for("react.provider");
+    var f2 = Symbol.for("react.profiler");
+    var g2 = Symbol.for("react.provider");
     var h = Symbol.for("react.context");
-    var k = Symbol.for("react.server_context");
+    var k2 = Symbol.for("react.server_context");
     var l = Symbol.for("react.forward_ref");
-    var m2 = Symbol.for("react.suspense");
+    var m = Symbol.for("react.suspense");
     var n2 = Symbol.for("react.suspense_list");
-    var p2 = Symbol.for("react.memo");
+    var p = Symbol.for("react.memo");
     var q = Symbol.for("react.lazy");
     var t = Symbol.for("react.offscreen");
     var u2;
     u2 = Symbol.for("react.module.reference");
-    function v2(a) {
+    function v(a) {
       if ("object" === typeof a && null !== a) {
         var r = a.$$typeof;
         switch (r) {
           case b2:
             switch (a = a.type, a) {
-              case d2:
-              case f:
+              case d:
+              case f2:
               case e:
-              case m2:
+              case m:
               case n2:
                 return a;
               default:
                 switch (a = a && a.$$typeof, a) {
-                  case k:
+                  case k2:
                   case h:
                   case l:
                   case q:
-                  case p2:
-                  case g:
+                  case p:
+                  case g2:
                     return a;
                   default:
                     return r;
                 }
             }
-          case c:
+          case c2:
             return r;
         }
       }
     }
     exports.ContextConsumer = h;
-    exports.ContextProvider = g;
+    exports.ContextProvider = g2;
     exports.Element = b2;
     exports.ForwardRef = l;
-    exports.Fragment = d2;
+    exports.Fragment = d;
     exports.Lazy = q;
-    exports.Memo = p2;
-    exports.Portal = c;
-    exports.Profiler = f;
+    exports.Memo = p;
+    exports.Portal = c2;
+    exports.Profiler = f2;
     exports.StrictMode = e;
-    exports.Suspense = m2;
+    exports.Suspense = m;
     exports.SuspenseList = n2;
     exports.isAsyncMode = function() {
       return false;
@@ -825,45 +825,45 @@ var require_react_is_production_min = __commonJS({
       return false;
     };
     exports.isContextConsumer = function(a) {
-      return v2(a) === h;
+      return v(a) === h;
     };
     exports.isContextProvider = function(a) {
-      return v2(a) === g;
+      return v(a) === g2;
     };
     exports.isElement = function(a) {
       return "object" === typeof a && null !== a && a.$$typeof === b2;
     };
     exports.isForwardRef = function(a) {
-      return v2(a) === l;
+      return v(a) === l;
     };
     exports.isFragment = function(a) {
-      return v2(a) === d2;
+      return v(a) === d;
     };
     exports.isLazy = function(a) {
-      return v2(a) === q;
+      return v(a) === q;
     };
     exports.isMemo = function(a) {
-      return v2(a) === p2;
+      return v(a) === p;
     };
     exports.isPortal = function(a) {
-      return v2(a) === c;
+      return v(a) === c2;
     };
     exports.isProfiler = function(a) {
-      return v2(a) === f;
+      return v(a) === f2;
     };
     exports.isStrictMode = function(a) {
-      return v2(a) === e;
+      return v(a) === e;
     };
     exports.isSuspense = function(a) {
-      return v2(a) === m2;
+      return v(a) === m;
     };
     exports.isSuspenseList = function(a) {
-      return v2(a) === n2;
+      return v(a) === n2;
     };
     exports.isValidElementType = function(a) {
-      return "string" === typeof a || "function" === typeof a || a === d2 || a === f || a === e || a === m2 || a === n2 || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p2 || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u2 || void 0 !== a.getModuleId) ? true : false;
+      return "string" === typeof a || "function" === typeof a || a === d || a === f2 || a === e || a === m || a === n2 || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g2 || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u2 || void 0 !== a.getModuleId) ? true : false;
     };
-    exports.typeOf = v2;
+    exports.typeOf = v;
   }
 });
 
@@ -1460,10 +1460,10 @@ ${indentationNext}`);
       return printed;
     }
     function findPlugin(plugins5, val) {
-      for (let p2 = 0; p2 < plugins5.length; p2++) {
+      for (let p = 0; p < plugins5.length; p++) {
         try {
-          if (plugins5[p2].test(val)) {
-            return plugins5[p2];
+          if (plugins5[p].test(val)) {
+            return plugins5[p];
           }
         } catch (error) {
           throw new PrettyFormatPluginError(error.message, error.stack);
@@ -1676,11 +1676,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 string3 = peek || inspectItem(value, options) + (last ? "" : separator);
     const nextLength = output.length + string3.length;
@@ -1691,13 +1691,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 += string3;
     if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
-      truncated = `${truncator}(${list.length - i - 1})`;
+      truncated = `${truncator}(${list.length - i2 - 1})`;
       break;
     }
     truncated = "";
@@ -1836,11 +1836,11 @@ function inspectTypedArray(array2, options) {
   if (!array2.length && !nonIndexProperties.length)
     return `${name}[]`;
   let output = "";
-  for (let i = 0; i < array2.length; i++) {
-    const string3 = `${options.stylize(truncate(array2[i], options.truncate), "number")}${i === array2.length - 1 ? "" : ", "}`;
+  for (let i2 = 0; i2 < array2.length; i2++) {
+    const string3 = `${options.stylize(truncate(array2[i2], options.truncate), "number")}${i2 === array2.length - 1 ? "" : ", "}`;
     options.truncate -= string3.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 += string3;
@@ -1963,7 +1963,7 @@ var init_number = __esm({
     "use strict";
     init_esm_shims();
     init_helpers();
-    isNaN2 = Number.isNaN || ((i) => i !== i);
+    isNaN2 = Number.isNaN || ((i2) => i2 !== i2);
   }
 });
 
@@ -2465,9 +2465,9 @@ var require_build2 = __commonJS({
       }
       return nCommon;
     };
-    var extendPathsF = (d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
+    var extendPathsF = (d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
       let iF = 0;
-      let kF = -d2;
+      let kF = -d;
       let aFirst = aIndexesF[iF];
       let aIndexPrev1 = aFirst;
       aIndexesF[iF] += countCommonItemsF(
@@ -2477,9 +2477,9 @@ var require_build2 = __commonJS({
         bEnd,
         isCommon
       );
-      const nF = d2 < iMaxF ? d2 : iMaxF;
+      const nF = d < iMaxF ? d : iMaxF;
       for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
-        if (iF !== d2 && aIndexPrev1 < aIndexesF[iF]) {
+        if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {
           aFirst = aIndexesF[iF];
         } else {
           aFirst = aIndexPrev1 + 1;
@@ -2492,9 +2492,9 @@ var require_build2 = __commonJS({
       }
       return iMaxF;
     };
-    var extendPathsR = (d2, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
+    var extendPathsR = (d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
       let iR = 0;
-      let kR = d2;
+      let kR = d;
       let aFirst = aIndexesR[iR];
       let aIndexPrev1 = aFirst;
       aIndexesR[iR] -= countCommonItemsR(
@@ -2504,9 +2504,9 @@ var require_build2 = __commonJS({
         bR + aFirst - kR - 1,
         isCommon
       );
-      const nR = d2 < iMaxR ? d2 : iMaxR;
+      const nR = d < iMaxR ? d : iMaxR;
       for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
-        if (iR !== d2 && aIndexesR[iR] < aIndexPrev1) {
+        if (iR !== d && aIndexesR[iR] < aIndexPrev1) {
           aFirst = aIndexesR[iR];
         } else {
           aFirst = aIndexPrev1 - 1;
@@ -2525,17 +2525,17 @@ var require_build2 = __commonJS({
       }
       return iMaxR;
     };
-    var extendOverlappablePathsF = (d2, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+    var extendOverlappablePathsF = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
       const bF = bStart - aStart;
       const aLength = aEnd - aStart;
       const bLength = bEnd - bStart;
       const baDeltaLength = bLength - aLength;
-      const kMinOverlapF = -baDeltaLength - (d2 - 1);
-      const kMaxOverlapF = -baDeltaLength + (d2 - 1);
+      const kMinOverlapF = -baDeltaLength - (d - 1);
+      const kMaxOverlapF = -baDeltaLength + (d - 1);
       let aIndexPrev1 = NOT_YET_SET;
-      const nF = d2 < iMaxF ? d2 : iMaxF;
-      for (let iF = 0, kF = -d2; iF <= nF; iF += 1, kF += 2) {
-        const insert2 = iF === 0 || iF !== d2 && aIndexPrev1 < aIndexesF[iF];
+      const nF = d < iMaxF ? d : iMaxF;
+      for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
+        const insert2 = iF === 0 || iF !== d && aIndexPrev1 < aIndexesF[iF];
         const aLastPrev = insert2 ? aIndexesF[iF] : aIndexPrev1;
         const aFirst = insert2 ? aLastPrev : aLastPrev + 1;
         const bFirst = bF + aFirst - kF;
@@ -2550,7 +2550,7 @@ var require_build2 = __commonJS({
         aIndexPrev1 = aIndexesF[iF];
         aIndexesF[iF] = aLast;
         if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {
-          const iR = (d2 - 1 - (kF + baDeltaLength)) / 2;
+          const iR = (d - 1 - (kF + baDeltaLength)) / 2;
           if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
             const bLastPrev = bF + aLastPrev - (insert2 ? kF + 1 : kF - 1);
             const nCommonR = countCommonItemsR(
@@ -2564,8 +2564,8 @@ var require_build2 = __commonJS({
             const bIndexPrevFirst = bLastPrev - nCommonR;
             const aEndPreceding = aIndexPrevFirst + 1;
             const bEndPreceding = bIndexPrevFirst + 1;
-            division.nChangePreceding = d2 - 1;
-            if (d2 - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
+            division.nChangePreceding = d - 1;
+            if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
               division.aEndPreceding = aStart;
               division.bEndPreceding = bStart;
             } else {
@@ -2584,8 +2584,8 @@ var require_build2 = __commonJS({
             }
             const aStartFollowing = aLast + 1;
             const bStartFollowing = bFirst + nCommonF + 1;
-            division.nChangeFollowing = d2 - 1;
-            if (d2 - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+            division.nChangeFollowing = d - 1;
+            if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
               division.aStartFollowing = aEnd;
               division.bStartFollowing = bEnd;
             } else {
@@ -2598,17 +2598,17 @@ var require_build2 = __commonJS({
       }
       return false;
     };
-    var extendOverlappablePathsR = (d2, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+    var extendOverlappablePathsR = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
       const bR = bEnd - aEnd;
       const aLength = aEnd - aStart;
       const bLength = bEnd - bStart;
       const baDeltaLength = bLength - aLength;
-      const kMinOverlapR = baDeltaLength - d2;
-      const kMaxOverlapR = baDeltaLength + d2;
+      const kMinOverlapR = baDeltaLength - d;
+      const kMaxOverlapR = baDeltaLength + d;
       let aIndexPrev1 = NOT_YET_SET;
-      const nR = d2 < iMaxR ? d2 : iMaxR;
-      for (let iR = 0, kR = d2; iR <= nR; iR += 1, kR -= 2) {
-        const insert2 = iR === 0 || iR !== d2 && aIndexesR[iR] < aIndexPrev1;
+      const nR = d < iMaxR ? d : iMaxR;
+      for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
+        const insert2 = iR === 0 || iR !== d && aIndexesR[iR] < aIndexPrev1;
         const aLastPrev = insert2 ? aIndexesR[iR] : aIndexPrev1;
         const aFirst = insert2 ? aLastPrev : aLastPrev - 1;
         const bFirst = bR + aFirst - kR;
@@ -2623,11 +2623,11 @@ var require_build2 = __commonJS({
         aIndexPrev1 = aIndexesR[iR];
         aIndexesR[iR] = aLast;
         if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {
-          const iF = (d2 + (kR - baDeltaLength)) / 2;
+          const iF = (d + (kR - baDeltaLength)) / 2;
           if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
             const bLast = bFirst - nCommonR;
-            division.nChangePreceding = d2;
-            if (d2 === aLast + bLast - aStart - bStart) {
+            division.nChangePreceding = d;
+            if (d === aLast + bLast - aStart - bStart) {
               division.aEndPreceding = aStart;
               division.bEndPreceding = bStart;
             } else {
@@ -2639,8 +2639,8 @@ var require_build2 = __commonJS({
               division.aCommonPreceding = aLast;
               division.bCommonPreceding = bLast;
             }
-            division.nChangeFollowing = d2 - 1;
-            if (d2 === 1) {
+            division.nChangeFollowing = d - 1;
+            if (d === 1) {
               division.nCommonFollowing = 0;
               division.aStartFollowing = aEnd;
               division.bStartFollowing = bEnd;
@@ -2660,7 +2660,7 @@ var require_build2 = __commonJS({
               }
               const aStartFollowing = aLastPrev + nCommonF;
               const bStartFollowing = bLastPrev + nCommonF;
-              if (d2 - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+              if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
                 division.aStartFollowing = aEnd;
                 division.bStartFollowing = bEnd;
               } else {
@@ -2687,15 +2687,15 @@ var require_build2 = __commonJS({
       if (baDeltaLength % 2 === 0) {
         const dMin = (nChange || baDeltaLength) / 2;
         const dMax = (aLength + bLength) / 2;
-        for (let d2 = 1; d2 <= dMax; d2 += 1) {
-          iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
-          if (d2 < dMin) {
-            iMaxR = extendPathsR(d2, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
+        for (let d = 1; d <= dMax; d += 1) {
+          iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+          if (d < dMin) {
+            iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
           } else if (
             // If a reverse path overlaps a forward path in the same diagonal,
             // return a division of the index intervals at the middle change.
             extendOverlappablePathsR(
-              d2,
+              d,
               aStart,
               aEnd,
               bStart,
@@ -2714,11 +2714,11 @@ var require_build2 = __commonJS({
       } else {
         const dMin = ((nChange || baDeltaLength) + 1) / 2;
         const dMax = (aLength + bLength + 1) / 2;
-        let d2 = 1;
-        iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
-        for (d2 += 1; d2 <= dMax; d2 += 1) {
+        let d = 1;
+        iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+        for (d += 1; d <= dMax; d += 1) {
           iMaxR = extendPathsR(
-            d2 - 1,
+            d - 1,
             aStart,
             bStart,
             bR,
@@ -2726,13 +2726,13 @@ var require_build2 = __commonJS({
             aIndexesR,
             iMaxR
           );
-          if (d2 < dMin) {
-            iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+          if (d < dMin) {
+            iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
           } else if (
             // If a forward path overlaps a reverse path in the same diagonal,
             // return a division of the index intervals at the middle change.
             extendOverlappablePathsF(
-              d2,
+              d,
               aStart,
               aEnd,
               bStart,
@@ -2932,9 +2932,9 @@ var require_assertion_error = __commonJS({
         });
       }
       return function extendExclude() {
-        var args = [].slice.call(arguments), i = 0, res = {};
-        for (; i < args.length; i++) {
-          excludeProps(res, args[i]);
+        var args = [].slice.call(arguments), i2 = 0, res = {};
+        for (; i2 < args.length; i2++) {
+          excludeProps(res, args[i2]);
         }
         return res;
       };
@@ -3004,15 +3004,15 @@ var require_pathval = __commonJS({
       var temporaryValue = obj;
       var res = null;
       pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth;
-      for (var i = 0; i < pathDepth; i++) {
-        var part = parsed[i];
+      for (var i2 = 0; i2 < pathDepth; i2++) {
+        var 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;
           }
         }
@@ -3023,11 +3023,11 @@ var require_pathval = __commonJS({
       var tempObj = obj;
       var pathDepth = parsed.length;
       var part = null;
-      for (var i = 0; i < pathDepth; i++) {
+      for (var i2 = 0; i2 < pathDepth; i2++) {
         var propName = null;
         var propVal = null;
-        part = parsed[i];
-        if (i === pathDepth - 1) {
+        part = parsed[i2];
+        if (i2 === pathDepth - 1) {
           propName = typeof part.p === "undefined" ? part.i : part.p;
           tempObj[propName] = val;
         } else if (typeof part.p !== "undefined" && tempObj[part.p]) {
@@ -3035,7 +3035,7 @@ var require_pathval = __commonJS({
         } else if (typeof part.i !== "undefined" && tempObj[part.i]) {
           tempObj = tempObj[part.i];
         } else {
-          var next = parsed[i + 1];
+          var next = parsed[i2 + 1];
           propName = typeof part.p === "undefined" ? part.i : part.p;
           propVal = typeof next.p === "undefined" ? [] : {};
           tempObj[propName] = propVal;
@@ -3711,8 +3711,8 @@ var require_deep_eql = __commonJS({
     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);
         }
@@ -3724,8 +3724,8 @@ var require_deep_eql = __commonJS({
       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;
         }
       }
@@ -3913,24 +3913,24 @@ var require_proxify = __commonJS({
         return cap;
       }
       var memo = [];
-      for (var i = 0; i <= strA.length; i++) {
-        memo[i] = Array(strB.length + 1).fill(0);
-        memo[i][0] = i;
+      for (var i2 = 0; i2 <= strA.length; i2++) {
+        memo[i2] = Array(strB.length + 1).fill(0);
+        memo[i2][0] = i2;
       }
       for (var j = 0; j < strB.length; j++) {
         memo[0][j] = j;
       }
-      for (var i = 1; i <= strA.length; i++) {
-        var ch = strA.charCodeAt(i - 1);
+      for (var i2 = 1; i2 <= strA.length; i2++) {
+        var ch = strA.charCodeAt(i2 - 1);
         for (var 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)
           );
         }
       }
@@ -6341,9 +6341,9 @@ function encode(decoded) {
   const sub = buf.subarray(0, subLength);
   let pos = 0;
   let out = "";
-  for (let i = 0; i < decoded.length; i++) {
-    const line = decoded[i];
-    if (i > 0) {
+  for (let i2 = 0; i2 < decoded.length; i2++) {
+    const line = decoded[i2];
+    if (i2 > 0) {
       if (pos === bufLength) {
         out += td.decode(buf);
         pos = 0;
@@ -6399,10 +6399,10 @@ var init_sourcemap_codec = __esm({
     chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     intToChar = new Uint8Array(64);
     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 c2 = chars.charCodeAt(i2);
+      intToChar[i2] = c2;
+      charToInt[c2] = i2;
     }
     td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
       decode(buf) {
@@ -6412,8 +6412,8 @@ var init_sourcemap_codec = __esm({
     } : {
       decode(buf) {
         let out = "";
-        for (let i = 0; i < buf.length; i++) {
-          out += String.fromCharCode(buf[i]);
+        for (let i2 = 0; i2 < buf.length; i2++) {
+          out += String.fromCharCode(buf[i2]);
         }
         return out;
       }
@@ -6429,8 +6429,8 @@ __export(magic_string_es_exports, {
   default: () => MagicString
 });
 function getBtoa() {
-  if (typeof window !== "undefined" && typeof window.btoa === "function") {
-    return (str) => window.btoa(unescape(encodeURIComponent(str)));
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
   } else if (typeof Buffer === "function") {
     return (str) => Buffer.from(str, "utf-8").toString("base64");
   } else {
@@ -6464,9 +6464,9 @@ function getRelativePath(from, to) {
     toParts.shift();
   }
   if (fromParts.length) {
-    let i = fromParts.length;
-    while (i--)
-      fromParts[i] = "..";
+    let i2 = fromParts.length;
+    while (i2--)
+      fromParts[i2] = "..";
   }
   return fromParts.concat(toParts).join("/");
 }
@@ -6476,22 +6476,22 @@ function isObject2(thing) {
 function getLocator(source) {
   const originalLines = source.split("\n");
   const lineOffsets = [];
-  for (let i = 0, pos = 0; i < originalLines.length; i++) {
+  for (let i2 = 0, pos = 0; i2 < originalLines.length; i2++) {
     lineOffsets.push(pos);
-    pos += originalLines[i].length + 1;
+    pos += originalLines[i2].length + 1;
   }
   return function locate(index) {
-    let i = 0;
+    let i2 = 0;
     let j = lineOffsets.length;
-    while (i < j) {
-      const m2 = i + j >> 1;
-      if (index < lineOffsets[m2]) {
-        j = m2;
+    while (i2 < j) {
+      const m = i2 + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
       } else {
-        i = m2 + 1;
+        i2 = m + 1;
       }
     }
-    const line = i - 1;
+    const line = i2 - 1;
     const column = index - lineOffsets[line];
     return { line, column };
   };
@@ -6576,6 +6576,15 @@ var init_magic_string_es = __esm({
       prependRight(content) {
         this.intro = content + this.intro;
       }
+      reset() {
+        this.intro = "";
+        this.outro = "";
+        if (this.edited) {
+          this.content = this.original;
+          this.storeName = false;
+          this.edited = false;
+        }
+      }
       split(index) {
         const sliceIndex = index - this.start;
         const originalBefore = this.original.slice(0, sliceIndex);
@@ -6676,9 +6685,10 @@ var init_magic_string_es = __esm({
       }
       addEdit(sourceIndex, content, loc, nameIndex) {
         if (content.length) {
+          const contentLengthMinusOne = content.length - 1;
           let contentLineEnd = content.indexOf("\n", 0);
           let previousContentLineEnd = -1;
-          while (contentLineEnd >= 0) {
+          while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
             const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
             if (nameIndex >= 0) {
               segment2.push(nameIndex);
@@ -6744,7 +6754,7 @@ var init_magic_string_es = __esm({
           return;
         const lines = str.split("\n");
         if (lines.length > 1) {
-          for (let i = 0; i < lines.length - 1; i++) {
+          for (let i2 = 0; i2 < lines.length - 1; i2++) {
             this.generatedCodeLine++;
             this.raw[this.generatedCodeLine] = this.rawSegments = [];
           }
@@ -6909,8 +6919,8 @@ var init_magic_string_es = __esm({
         if (options.exclude) {
           const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
           exclusions.forEach((exclusion) => {
-            for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
-              isExcluded[i] = true;
+            for (let i2 = exclusion[0]; i2 < exclusion[1]; i2 += 1) {
+              isExcluded[i2] = true;
             }
           });
         }
@@ -7128,6 +7138,26 @@ var init_magic_string_es = __esm({
         }
         return this;
       }
+      reset(start, end) {
+        while (start < 0)
+          start += this.original.length;
+        while (end < 0)
+          end += this.original.length;
+        if (start === end)
+          return this;
+        if (start < 0 || end > this.original.length)
+          throw new Error("Character is out of bounds");
+        if (start > end)
+          throw new Error("end must be greater than start");
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while (chunk) {
+          chunk.reset();
+          chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+      }
       lastChar() {
         if (this.outro.length)
           return this.outro[this.outro.length - 1];
@@ -7335,15 +7365,15 @@ var init_magic_string_es = __esm({
       _replaceRegexp(searchValue, replacement) {
         function getReplacement(match, str) {
           if (typeof replacement === "string") {
-            return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
-              if (i === "$")
+            return replacement.replace(/\$(\$|&|\d+)/g, (_, i2) => {
+              if (i2 === "$")
                 return "$";
-              if (i === "&")
+              if (i2 === "&")
                 return match[0];
-              const num = +i;
+              const num = +i2;
               if (num < match.length)
-                return match[+i];
-              return `$${i}`;
+                return match[+i2];
+              return `$${i2}`;
             });
           } else {
             return replacement(...match, match.index, str, match.groups);
@@ -7489,8 +7519,8 @@ var init_magic_string_es = __esm({
         if (this.intro) {
           mappings.advance(this.intro);
         }
-        this.sources.forEach((source, i) => {
-          if (i > 0) {
+        this.sources.forEach((source, i2) => {
+          if (i2 > 0) {
             mappings.advance(this.separator);
           }
           const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
@@ -7573,9 +7603,9 @@ var init_magic_string_es = __esm({
         if (indentStr === "")
           return this;
         let trailingNewline = !this.intro || this.intro.slice(-1) === "\n";
-        this.sources.forEach((source, i) => {
+        this.sources.forEach((source, i2) => {
           const separator = source.separator !== void 0 ? source.separator : this.separator;
-          const indentStart = trailingNewline || i > 0 && /\r?\n$/.test(separator);
+          const indentStart = trailingNewline || i2 > 0 && /\r?\n$/.test(separator);
           source.content.indent(indentStr, {
             exclude: source.indentExclusionRanges,
             indentStart
@@ -7595,9 +7625,9 @@ var init_magic_string_es = __esm({
         return this;
       }
       toString() {
-        const body = this.sources.map((source, i) => {
+        const body = this.sources.map((source, i2) => {
           const separator = source.separator !== void 0 ? source.separator : this.separator;
-          const str = (i > 0 ? separator : "") + source.content.toString();
+          const str = (i2 > 0 ? separator : "") + source.content.toString();
           return str;
         }).join("");
         return this.intro + body;
@@ -7626,9 +7656,9 @@ var init_magic_string_es = __esm({
         this.intro = this.intro.replace(rx, "");
         if (!this.intro) {
           let source;
-          let i = 0;
+          let i2 = 0;
           do {
-            source = this.sources[i++];
+            source = this.sources[i2++];
             if (!source) {
               break;
             }
@@ -7639,9 +7669,9 @@ var init_magic_string_es = __esm({
       trimEnd(charType) {
         const rx = new RegExp((charType || "\\s") + "+$");
         let source;
-        let i = this.sources.length - 1;
+        let i2 = this.sources.length - 1;
         do {
-          source = this.sources[i--];
+          source = this.sources[i2--];
           if (!source) {
             this.intro = this.intro.replace(rx, "");
             break;
@@ -7662,16 +7692,16 @@ var require_camelcase = __commonJS({
       let isLastCharLower = false;
       let isLastCharUpper = false;
       let isLastLastCharUpper = false;
-      for (let i = 0; i < string3.length; i++) {
-        const character = string3[i];
+      for (let i2 = 0; i2 < string3.length; i2++) {
+        const character = string3[i2];
         if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
-          string3 = string3.slice(0, i) + "-" + string3.slice(i);
+          string3 = string3.slice(0, i2) + "-" + string3.slice(i2);
           isLastCharLower = false;
           isLastLastCharUpper = isLastCharUpper;
           isLastCharUpper = true;
-          i++;
+          i2++;
         } else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLowerCase() === character) {
-          string3 = string3.slice(0, i - 1) + "-" + string3.slice(i - 1);
+          string3 = string3.slice(0, i2 - 1) + "-" + string3.slice(i2 - 1);
           isLastLastCharUpper = isLastCharUpper;
           isLastCharUpper = false;
           isLastCharLower = true;
@@ -7706,7 +7736,7 @@ var require_camelcase = __commonJS({
       if (hasUpperCase) {
         input = preserveCamelCase(input);
       }
-      input = input.replace(/^[_.\- ]+/, "").toLowerCase().replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase()).replace(/\d+(\w|$)/g, (m2) => m2.toUpperCase());
+      input = input.replace(/^[_.\- ]+/, "").toLowerCase().replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase()).replace(/\d+(\w|$)/g, (m) => m.toUpperCase());
       return postProcess(input);
     };
     module.exports = camelCase;
@@ -7804,34 +7834,34 @@ function deepClone(val, options = defaultCloneOptions) {
   return clone(val, seen, options);
 }
 function clone(val, seen, options = defaultCloneOptions) {
-  let k, out;
+  let k2, out;
   if (seen.has(val))
     return seen.get(val);
   if (Array.isArray(val)) {
-    out = Array(k = val.length);
+    out = Array(k2 = val.length);
     seen.set(val, out);
-    while (k--)
-      out[k] = clone(val[k], seen, options);
+    while (k2--)
+      out[k2] = clone(val[k2], seen, options);
     return out;
   }
   if (Object.prototype.toString.call(val) === "[object Object]") {
     out = Object.create(Object.getPrototypeOf(val));
     seen.set(val, out);
     const props = getOwnProperties(val);
-    for (const k2 of props) {
-      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
+    for (const k22 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k22);
       if (!descriptor)
         continue;
-      const cloned = clone(val[k2], seen, options);
+      const cloned = clone(val[k22], seen, options);
       if ("get" in descriptor) {
-        Object.defineProperty(out, k2, {
+        Object.defineProperty(out, k22, {
           ...descriptor,
           get() {
             return cloned;
           }
         });
       } else {
-        Object.defineProperty(out, k2, {
+        Object.defineProperty(out, k22, {
           ...descriptor,
           writable: options.forceWritable ? true : descriptor.writable,
           value: cloned
@@ -7847,8 +7877,8 @@ function noop() {
 function objectAttr(source, path3, defaultValue = void 0) {
   const paths = path3.replace(/\[(\d+)\]/g, ".$1").split(".");
   let result = source;
-  for (const p2 of paths) {
-    result = Object(result)[p2];
+  for (const p of paths) {
+    result = Object(result)[p];
     if (result === void 0)
       return defaultValue;
   }
@@ -7857,13 +7887,13 @@ function objectAttr(source, path3, defaultValue = void 0) {
 function createDefer() {
   let resolve3 = null;
   let reject = null;
-  const p2 = new Promise((_resolve, _reject) => {
+  const p = new Promise((_resolve, _reject) => {
     resolve3 = _resolve;
     reject = _reject;
   });
-  p2.resolve = resolve3;
-  p2.reject = reject;
-  return p2;
+  p.resolve = resolve3;
+  p.reject = reject;
+  return p;
 }
 
 // ../../node_modules/@vitest/utils/dist/chunk-display.js
@@ -7913,21 +7943,21 @@ var formatRegExp = /%[sdjifoOcj%]/g;
 function format(...args) {
   if (typeof args[0] !== "string") {
     const objects = [];
-    for (let i2 = 0; i2 < args.length; i2++)
-      objects.push(inspect2(args[i2], { depth: 0, colors: false, compact: 3 }));
+    for (let i22 = 0; i22 < args.length; i22++)
+      objects.push(inspect2(args[i22], { depth: 0, colors: false, compact: 3 }));
     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`;
         if (typeof value === "number" && value === 0 && 1 / value < 0)
@@ -7937,35 +7967,35 @@ function format(...args) {
         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 inspect2(args[i++], { showHidden: true, showProxy: true });
+        return inspect2(args[i2++], { showHidden: true, showProxy: true });
       case "%O":
-        return inspect2(args[i++]);
+        return inspect2(args[i2++]);
       case "%c": {
-        i++;
+        i2++;
         return "";
       }
       case "%j":
         try {
-          return JSON.stringify(args[i++]);
+          return JSON.stringify(args[i2++]);
         } catch (err) {
-          const m2 = err.message;
+          const m = err.message;
           if (
             // chromium
-            m2.includes("circular structure") || m2.includes("cyclic structures") || m2.includes("cyclic object")
+            m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")
           )
             return "[Circular]";
           throw err;
@@ -7974,7 +8004,7 @@ function format(...args) {
         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
@@ -8300,33 +8330,33 @@ 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;
-    if (iStart !== i) {
+  let i2 = 0;
+  while (i2 !== iLength) {
+    const iStart = i2;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_EQUAL)
+      i2 += 1;
+    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 n2 = i - iStart;
+      } else if (i2 === iLength) {
+        const n2 = i2 - iStart;
         if (n2 > nContextLines) {
           jLength -= n2 - nContextLines;
           hasExcessAtStartOrEnd = true;
         }
       } else {
-        const n2 = i - iStart;
+        const n2 = i2 - iStart;
         if (n2 > nContextLines2) {
           jLength -= n2 - 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;
   if (nExcessesBetweenChanges !== 0)
@@ -8358,28 +8388,28 @@ 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;
-    if (iStart !== i) {
+  i2 = 0;
+  while (i2 !== iLength) {
+    let iStart = i2;
+    while (i2 !== iLength && diffs[i2][0] === DIFF_EQUAL)
+      i2 += 1;
+    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)
@@ -8398,21 +8428,21 @@ 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)
@@ -8420,9 +8450,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);
@@ -8436,17 +8466,17 @@ function joinAlignedDiffsExpand(diffs, options) {
 var noColor = (string3) => string3;
 var DIFF_CONTEXT_DEFAULT = 5;
 function getDefaultOptions() {
-  const c = getColors();
+  const c2 = getColors();
   return {
     aAnnotation: "Expected",
-    aColor: c.green,
+    aColor: c2.green,
     aIndicator: "-",
     bAnnotation: "Received",
-    bColor: c.red,
+    bColor: c2.red,
     bIndicator: "+",
-    changeColor: c.inverse,
+    changeColor: c2.inverse,
     changeLineTrailingSpaceColor: noColor,
-    commonColor: c.dim,
+    commonColor: c2.dim,
     commonIndicator: " ",
     commonLineTrailingSpaceColor: noColor,
     compareKeys: void 0,
@@ -8455,7 +8485,7 @@ function getDefaultOptions() {
     expand: true,
     includeChangeCounts: false,
     omitAnnotationLines: false,
-    patchColor: c.yellow
+    patchColor: c2.yellow
   };
 }
 function getCompareKeys(compareKeys) {
@@ -8731,8 +8761,8 @@ var import_diff_sequences = __toESM(require_build2(), 1);
 init_loupe();
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
-function isImmutable(v2) {
-  return v2 && (v2[IS_COLLECTION_SYMBOL] || v2[IS_RECORD_SYMBOL]);
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
 }
 var OBJECT_PROTO = Object.getPrototypeOf({});
 function getUnserializableMessage(err) {
@@ -8764,11 +8794,11 @@ function serializeError(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] = serializeError(e, seen);
+        clone2[i2] = serializeError(e, seen);
       } catch (err) {
-        clone2[i] = getUnserializableMessage(err);
+        clone2[i2] = getUnserializableMessage(err);
       }
     });
     return clone2;
@@ -8833,7 +8863,7 @@ function isAsymmetricMatcher(data) {
 function isReplaceable(obj1, obj2) {
   const obj1Type = getType(obj1);
   const obj2Type = getType(obj2);
-  return obj1Type === obj2Type && obj1Type === "Object";
+  return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
 }
 function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
   if (!isReplaceable(actual, expected))
@@ -8868,7 +8898,7 @@ function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE_
   };
 }
 
-// ../../node_modules/@vitest/runner/dist/utils.js
+// ../../node_modules/@vitest/runner/dist/chunk-tasks.js
 init_esm_shims();
 function createChainable(keys2, fn2) {
   function create(context) {
@@ -9005,8 +9035,8 @@ function normalizeString(path3, allowAboveRoot) {
   }
   return res;
 }
-var isAbsolute = function(p2) {
-  return _IS_ABSOLUTE_RE.test(p2);
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
 };
 
 // ../../node_modules/@vitest/runner/dist/index.js
@@ -9080,6 +9110,10 @@ function createTestContext(test3, runner2) {
     test3.onFailed || (test3.onFailed = []);
     test3.onFailed.push(fn2);
   };
+  context.onTestFinished = (fn2) => {
+    test3.onFinished || (test3.onFinished = []);
+    test3.onFinished.push(fn2);
+  };
   return ((_a2 = runner2.extendTaskContext) == null ? void 0 : _a2.call(runner2, context)) || context;
 }
 function makeTimeoutMsg(isHook, timeout) {
@@ -9087,14 +9121,16 @@ function makeTimeoutMsg(isHook, timeout) {
 If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
 }
 function mergeContextFixtures(fixtures, context = {}) {
-  const fixtureArray = Object.entries(fixtures).map(([prop, value], index) => {
-    const isFn = typeof value === "function";
-    return {
-      prop,
-      value,
-      index,
-      isFn
-    };
+  const fixtureOptionKeys = ["auto"];
+  const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
+    const fixtureItem = { value };
+    if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+      Object.assign(fixtureItem, value[1]);
+      fixtureItem.value = value[0];
+    }
+    fixtureItem.prop = prop;
+    fixtureItem.isFn = typeof fixtureItem.value === "function";
+    return fixtureItem;
   });
   if (Array.isArray(context.fixtures))
     context.fixtures = context.fixtures.concat(fixtureArray);
@@ -9120,7 +9156,8 @@ function withFixtures(fn2, testContext) {
     if (!(fixtures == null ? void 0 : fixtures.length))
       return fn2(context);
     const usedProps = getUsedProps(fn2);
-    if (!usedProps.length)
+    const hasAutoFixture = fixtures.some(({ auto }) => auto);
+    if (!usedProps.length && !hasAutoFixture)
       return fn2(context);
     if (!fixtureValueMaps.get(context))
       fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
@@ -9128,7 +9165,7 @@ function withFixtures(fn2, testContext) {
     if (!cleanupFnArrayMap.has(context))
       cleanupFnArrayMap.set(context, []);
     const cleanupFnArray = cleanupFnArrayMap.get(context);
-    const usedFixtures = fixtures.filter(({ prop }) => usedProps.includes(prop));
+    const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
     const pendingFixtures = resolveDeps(usedFixtures);
     if (!pendingFixtures.length)
       return fn2(context);
@@ -9177,7 +9214,7 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
       return;
     }
     if (depSet.has(fixture))
-      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d2) => d2.prop).join(" <- ")}`);
+      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
     depSet.add(fixture);
     resolveDeps(fixture.deps, depSet, pendingFixtures);
     pendingFixtures.push(fixture);
@@ -9208,16 +9245,16 @@ 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[stack.length - 1]) {
+  for (let i2 = 0; i2 < s.length; i2++) {
+    if (s[i2] === "{" || s[i2] === "[") {
+      stack.push(s[i2] === "{" ? "}" : "]");
+    } else if (s[i2] === stack[stack.length - 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();
@@ -9231,10 +9268,10 @@ function getCurrentTest() {
 }
 var suite = createSuite();
 var test = createTest(
-  function(name, fn2, options) {
+  function(name, optionsOrFn, optionsOrTest) {
     if (getCurrentTest())
       throw new Error('Calling the test function inside another test function is not allowed. Please put it inside "describe" or "suite" so it can be properly collected.');
-    getCurrentSuite().test.fn.call(this, formatName(name), fn2, options);
+    getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
   }
 );
 var describe = suite;
@@ -9255,8 +9292,33 @@ function createSuiteHooks() {
     afterEach: []
   };
 }
+function parseArguments(optionsOrFn, optionsOrTest) {
+  let options = {};
+  let fn2 = () => {
+  };
+  if (typeof optionsOrTest === "object") {
+    if (typeof optionsOrFn === "object")
+      throw new TypeError("Cannot use two objects as arguments. Please provide options and a function callback in that order.");
+    options = optionsOrTest;
+  } else if (typeof optionsOrTest === "number") {
+    options = { timeout: optionsOrTest };
+  } else if (typeof optionsOrFn === "object") {
+    options = optionsOrFn;
+  }
+  if (typeof optionsOrFn === "function") {
+    if (typeof optionsOrTest === "function")
+      throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+    fn2 = optionsOrFn;
+  } else if (typeof optionsOrTest === "function") {
+    fn2 = optionsOrTest;
+  }
+  return {
+    options,
+    handler: fn2
+  };
+}
 function createSuiteCollector(name, factory = () => {
-}, mode, concurrent, sequential, shuffle2, each, suiteOptions) {
+}, mode, shuffle2, each, suiteOptions) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
@@ -9295,16 +9357,18 @@ function createSuiteCollector(name, factory = () => {
     tasks.push(task2);
     return task2;
   };
-  const test22 = createTest(function(name2, fn2 = noop, options = {}) {
-    if (typeof options === "number")
-      options = { timeout: options };
+  const test22 = createTest(function(name2, optionsOrFn, optionsOrTest) {
+    let { options, handler } = parseArguments(
+      optionsOrFn,
+      optionsOrTest
+    );
     if (typeof suiteOptions === "object")
       options = Object.assign({}, suiteOptions, options);
     options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
     options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
     const test3 = task(
       formatName(name2),
-      { ...this, ...options, handler: fn2 }
+      { ...this, ...options, handler }
     );
     test3.type = "test";
   });
@@ -9349,8 +9413,8 @@ function createSuiteCollector(name, factory = () => {
     if (factory)
       await runWithSuite(collector, () => factory(test22));
     const allChildren = [];
-    for (const i of [...factoryQueue, ...tasks])
-      allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    for (const i2 of [...factoryQueue, ...tasks])
+      allChildren.push(i2.type === "collector" ? await i2.collect(file) : i2);
     suite2.file = file;
     suite2.tasks = allChildren;
     allChildren.forEach((task2) => {
@@ -9364,28 +9428,34 @@ function createSuiteCollector(name, factory = () => {
   return collector;
 }
 function createSuite() {
-  function suiteFn(name, factory, options = {}) {
+  function suiteFn(name, factoryOrOptions, optionsOrFactory = {}) {
     const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
     const currentSuite = getCurrentSuite();
-    if (typeof options === "number")
-      options = { timeout: options };
+    let { options, handler: factory } = parseArguments(
+      factoryOrOptions,
+      optionsOrFactory
+    );
     if (currentSuite == null ? void 0 : currentSuite.options)
       options = { ...currentSuite.options, ...options };
     options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
     options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
-    return createSuiteCollector(formatName(name), factory, mode, this.concurrent, this.sequential, this.shuffle, this.each, options);
+    return createSuiteCollector(formatName(name), factory, mode, this.shuffle, this.each, options);
   }
   suiteFn.each = function(cases, ...args) {
     const suite2 = this.withContext();
     this.setContext("each", true);
     if (Array.isArray(cases) && args.length)
       cases = formatTemplateString(cases, args);
-    return (name, fn2, options) => {
+    return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      cases.forEach((i, idx) => {
-        const items = Array.isArray(i) ? i : [i];
-        arrayOnlyCases ? suite2(formatTitle(_name, items, idx), () => fn2(...items), options) : suite2(formatTitle(_name, items, idx), () => fn2(i), options);
+      const { options, handler } = parseArguments(
+        optionsOrFn,
+        fnOrOptions
+      );
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
+        arrayOnlyCases ? suite2(formatTitle(_name, items, idx), options, () => handler(...items)) : suite2(formatTitle(_name, items, idx), options, () => handler(i2));
       });
       this.setContext("each", void 0);
     };
@@ -9404,12 +9474,16 @@ function createTaskCollector(fn2, context) {
     this.setContext("each", true);
     if (Array.isArray(cases) && args.length)
       cases = formatTemplateString(cases, args);
-    return (name, fn22, options) => {
+    return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      cases.forEach((i, idx) => {
-        const items = Array.isArray(i) ? i : [i];
-        arrayOnlyCases ? test22(formatTitle(_name, items, idx), () => fn22(...items), options) : test22(formatTitle(_name, items, idx), () => fn22(i), options);
+      const { options, handler } = parseArguments(
+        optionsOrFn,
+        fnOrOptions
+      );
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
+        arrayOnlyCases ? test22(formatTitle(_name, items, idx), options, () => handler(...items)) : test22(formatTitle(_name, items, idx), options, () => handler(i2));
       });
       this.setContext("each", void 0);
     };
@@ -9422,8 +9496,8 @@ function createTaskCollector(fn2, context) {
   };
   taskFn.extend = function(fixtures) {
     const _context = mergeContextFixtures(fixtures, context);
-    return createTest(function fn22(name, fn22, options) {
-      getCurrentSuite().test.fn.call(this, formatName(name), fn22, options);
+    return createTest(function fn22(name, optionsOrFn, optionsOrTest) {
+      getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
     }, _context);
   };
   const _test2 = createChainable(
@@ -9459,12 +9533,12 @@ function formatTitle(template, items, idx) {
   return formatted;
 }
 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);
   }
   return res;
@@ -9490,19 +9564,26 @@ var onTestFailed = createTestHook("onTestFailed", (test3, handler) => {
   test3.onFailed || (test3.onFailed = []);
   test3.onFailed.push(handler);
 });
+var onTestFinished = createTestHook("onTestFinished", (test3, handler) => {
+  test3.onFinished || (test3.onFinished = []);
+  test3.onFinished.push(handler);
+});
 function createTestHook(name, handler) {
   return (fn2) => {
     const current = getCurrentTest();
     if (!current)
       throw new Error(`Hook ${name}() can only be called inside a test`);
-    handler(current, fn2);
+    return handler(current, fn2);
   };
 }
 
-// ../../node_modules/vitest/dist/vendor/benchmark.IlKmJkUU.js
+// ../../node_modules/vitest/dist/vendor/benchmark.eeqk2rd8.js
 init_esm_shims();
 
-// ../../node_modules/vitest/dist/vendor/index.rJjbcrrp.js
+// ../../node_modules/@vitest/runner/dist/utils.js
+init_esm_shims();
+
+// ../../node_modules/vitest/dist/vendor/index.ir9i0ywP.js
 init_esm_shims();
 
 // ../../node_modules/vitest/dist/vendor/global.CkGT_TMy.js
@@ -9520,7 +9601,7 @@ function getCurrentEnvironment() {
   return state == null ? void 0 : state.environment.name;
 }
 
-// ../../node_modules/vitest/dist/vendor/index.rJjbcrrp.js
+// ../../node_modules/vitest/dist/vendor/index.ir9i0ywP.js
 var _a;
 var isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
 var isWindows = isNode && process.platform === "win32";
@@ -9531,7 +9612,7 @@ function isRunningInBenchmark() {
   return getRunMode() === "benchmark";
 }
 
-// ../../node_modules/vitest/dist/vendor/benchmark.IlKmJkUU.js
+// ../../node_modules/vitest/dist/vendor/benchmark.eeqk2rd8.js
 var benchFns = /* @__PURE__ */ new WeakMap();
 var benchOptsMap = /* @__PURE__ */ new WeakMap();
 var bench = createBenchmark(
@@ -9584,7 +9665,7 @@ function isFirstRun() {
   return firstRun;
 }
 
-// ../../node_modules/vitest/dist/vendor/vi.Bw2UL9c9.js
+// ../../node_modules/vitest/dist/vendor/vi.C5mroSoP.js
 init_esm_shims();
 
 // ../../node_modules/chai/index.mjs
@@ -9631,67 +9712,70 @@ init_esm_shims();
 
 // ../../node_modules/tinyspy/dist/index.js
 init_esm_shims();
-function m(e, t) {
+function R(e, t) {
   if (!e)
     throw new Error(t);
 }
-function y(e, t) {
+function u(e, t) {
   return typeof t === e;
 }
 function b(e) {
   return e instanceof Promise;
 }
-function d(e, t, n2) {
+function f(e, t, n2) {
   Object.defineProperty(e, t, n2);
 }
-function p(e, t, n2) {
+function i(e, t, n2) {
   Object.defineProperty(e, t, { value: n2 });
 }
-var u = Symbol.for("tinyspy:spy");
-var I = /* @__PURE__ */ new Set();
-var M = (e) => {
+var c = Symbol.for("tinyspy:spy");
+var g = /* @__PURE__ */ new Set();
+var C = (e) => {
   e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.next = [];
 };
-var C = (e) => (d(e, u, { value: { reset: () => M(e[u]) } }), e[u]);
-var v = (e) => e[u] || C(e);
-function T(e) {
-  m(y("function", e) || y("undefined", e), "cannot spy on a non-function value");
-  let t = function(...a) {
-    let r = v(t);
-    r.called = true, r.callCount++, r.calls.push(a);
-    let i = r.next.shift();
-    if (i) {
-      r.results.push(i);
-      let [s, l] = i;
-      if (s === "ok")
-        return l;
-      throw l;
-    }
-    let o, c = "ok";
+var M = (e) => (f(e, c, { value: { reset: () => C(e[c]) } }), e[c]);
+var A = (e) => e[c] || M(e);
+function I(e) {
+  R(u("function", e) || u("undefined", e), "cannot spy on a non-function value");
+  let t = function(...s) {
+    let r = A(t);
+    r.called = true, r.callCount++, r.calls.push(s);
+    let m = r.next.shift();
+    if (m) {
+      r.results.push(m);
+      let [l, o] = m;
+      if (l === "ok")
+        return o;
+      throw o;
+    }
+    let p, d = "ok";
     if (r.impl)
       try {
-        new.target ? o = Reflect.construct(r.impl, a, new.target) : o = r.impl.apply(this, a), c = "ok";
-      } catch (s) {
-        throw o = s, c = "error", r.results.push([c, s]), s;
-      }
-    let x = [c, o];
-    if (b(o)) {
-      let s = o.then((l) => x[1] = l).catch((l) => {
-        throw x[0] = "error", x[1] = l, l;
+        new.target ? p = Reflect.construct(r.impl, s, new.target) : p = r.impl.apply(this, s), d = "ok";
+      } catch (l) {
+        throw p = l, d = "error", r.results.push([d, l]), l;
+      }
+    let a = [d, p];
+    if (b(p)) {
+      let l = p.then((o) => a[1] = o).catch((o) => {
+        throw a[0] = "error", a[1] = o, o;
       });
-      Object.assign(s, o), o = s;
+      Object.assign(l, p), p = l;
     }
-    return r.results.push(x), o;
+    return r.results.push(a), p;
   };
-  p(t, "_isMockFunction", true), p(t, "length", e ? e.length : 0), p(t, "name", e && e.name || "spy");
-  let n2 = v(t);
+  i(t, "_isMockFunction", true), i(t, "length", e ? e.length : 0), i(t, "name", e && e.name || "spy");
+  let n2 = A(t);
   return n2.reset(), n2.impl = e, t;
 }
-var P = (e, t) => Object.getOwnPropertyDescriptor(e, t);
+var k = (e, t) => Object.getOwnPropertyDescriptor(e, t);
+var P = (e, t) => {
+  t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
+};
 function E(e, t, n2) {
-  m(!y("undefined", e), "spyOn could not find an object to spy upon"), m(y("object", e) || y("function", e), "cannot spyOn on a primitive value");
-  let a = () => {
-    if (!y("object", t))
+  R(!u("undefined", e), "spyOn could not find an object to spy upon"), R(u("object", e) || u("function", e), "cannot spyOn on a primitive value");
+  let [s, r] = (() => {
+    if (!u("object", t))
       return [t, "value"];
     if ("getter" in t && "setter" in t)
       throw new Error("cannot spy on both getter and setter");
@@ -9700,20 +9784,22 @@ function E(e, t, n2) {
     if ("setter" in t)
       return [t.setter, "set"];
     throw new Error("specify getter or setter to spy on");
-  }, [r, i] = a(), o = P(e, r), c = Object.getPrototypeOf(e), x = c && P(c, r), s = o || x;
-  m(s || r in e, `${String(r)} does not exist`);
+  })(), m = k(e, s), p = Object.getPrototypeOf(e), d = p && k(p, s), a = m || d;
+  R(a || s in e, `${String(s)} does not exist`);
   let l = false;
-  i === "value" && s && !s.value && s.get && (i = "get", l = true, n2 = s.get());
-  let f;
-  s ? f = s[i] : i !== "value" ? f = () => e[r] : f = e[r], n2 || (n2 = f);
-  let S = T(n2), O = (w) => {
-    let { value: G, ...k } = s || {
+  r === "value" && a && !a.value && a.get && (r = "get", l = true, n2 = a.get());
+  let o;
+  a ? o = a[r] : r !== "value" ? o = () => e[s] : o = e[s], n2 || (n2 = o);
+  let y = I(n2);
+  r === "value" && P(y, o);
+  let O = (h) => {
+    let { value: G, ...w } = a || {
       configurable: true,
       writable: true
     };
-    i !== "value" && delete k.writable, k[i] = w, d(e, r, k);
-  }, K = () => s ? d(e, r, s) : O(f), A = S[u];
-  return p(A, "restore", K), p(A, "getOriginal", () => l ? f() : f), p(A, "willCall", (w) => (A.impl = w, S)), O(l ? () => S : S), I.add(S), S;
+    r !== "value" && delete w.writable, w[r] = h, f(e, s, w);
+  }, K = () => a ? f(e, s, a) : O(o), T = y[c];
+  return i(T, "restore", K), i(T, "getOriginal", () => l ? o() : o), i(T, "willCall", (h) => (T.impl = h, y)), O(l ? () => (P(y, n2), y) : y), g.add(y), y;
 }
 
 // ../../node_modules/@vitest/spy/dist/index.js
@@ -9736,7 +9822,7 @@ function enhanceSpy(spy) {
   let implementation;
   let instances = [];
   let invocations = [];
-  const state = v(spy);
+  const state = A(spy);
   const mockContext = {
     get calls() {
       return state.calls;
@@ -9879,12 +9965,12 @@ function setState(state, expect2) {
   map2.set(expect2, current);
 }
 function getMatcherUtils() {
-  const c = () => getColors();
-  const EXPECTED_COLOR = c().green;
-  const RECEIVED_COLOR = c().red;
-  const INVERTED_COLOR = c().inverse;
-  const BOLD_WEIGHT = c().bold;
-  const DIM_COLOR = c().dim;
+  const c2 = () => getColors();
+  const EXPECTED_COLOR = c2().green;
+  const RECEIVED_COLOR = c2().red;
+  const INVERTED_COLOR = c2().inverse;
+  const BOLD_WEIGHT = c2().bold;
+  const DIM_COLOR = c2().dim;
   function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
     const {
       comment = "",
@@ -9985,8 +10071,8 @@ function eq(a, b2, aStack, bStack, customTesters, hasKey2) {
   if (asymmetricResult !== void 0)
     return asymmetricResult;
   const testerContext = { equals };
-  for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i].call(testerContext, a, b2, customTesters);
+  for (let i2 = 0; i2 < customTesters.length; i2++) {
+    const customTesterResult = customTesters[i2].call(testerContext, a, b2, customTesters);
     if (customTesterResult !== void 0)
       return customTesterResult;
   }
@@ -10220,8 +10306,8 @@ function arrayBufferEquality(a, b2) {
   }
   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;
@@ -10558,7 +10644,7 @@ function wrapSoft(utils, fn2) {
 }
 var JestChaiExpect = (chai3, utils) => {
   const { AssertionError: AssertionError2 } = chai3;
-  const c = () => getColors();
+  const c2 = () => getColors();
   const customTesters = getCustomEqualityTesters();
   function def(name, fn2) {
     const addMethod = (n2) => {
@@ -10571,8 +10657,8 @@ var JestChaiExpect = (chai3, utils) => {
     else
       addMethod(name);
   }
-  ["throw", "throws", "Throw"].forEach((m2) => {
-    utils.overwriteMethod(chai3.Assertion.prototype, m2, (_super) => {
+  ["throw", "throws", "Throw"].forEach((m) => {
+    utils.overwriteMethod(chai3.Assertion.prototype, m, (_super) => {
       return function(...args) {
         const promise = utils.flag(this, "promise");
         const object2 = utils.flag(this, "object");
@@ -10889,25 +10975,25 @@ var JestChaiExpect = (chai3, utils) => {
     assertIsMock(assertion);
     return assertion._obj;
   };
-  const ordinalOf = (i) => {
-    const j = i % 10;
-    const k = i % 100;
-    if (j === 1 && k !== 11)
-      return `${i}st`;
-    if (j === 2 && k !== 12)
-      return `${i}nd`;
-    if (j === 3 && k !== 13)
-      return `${i}rd`;
-    return `${i}th`;
+  const ordinalOf = (i2) => {
+    const j = i2 % 10;
+    const k2 = i2 % 100;
+    if (j === 1 && k2 !== 11)
+      return `${i2}st`;
+    if (j === 2 && k2 !== 12)
+      return `${i2}nd`;
+    if (j === 3 && k2 !== 13)
+      return `${i2}rd`;
+    return `${i2}th`;
   };
   const formatCalls = (spy, msg, actualCall) => {
     if (spy.mock.calls) {
-      msg += c().gray(`
+      msg += c2().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 = c2().bold(`  ${ordinalOf(i2 + 1)} ${spy.getMockName()} call:
 
 `);
         if (actualCall)
@@ -10918,19 +11004,19 @@ ${spy.mock.calls.map((callArg, i) => {
         return methodCall;
       }).join("\n")}`);
     }
-    msg += c().gray(`
+    msg += c2().gray(`
 
-Number of calls: ${c().bold(spy.mock.calls.length)}
+Number of calls: ${c2().bold(spy.mock.calls.length)}
 `);
     return msg;
   };
   const formatReturns = (spy, msg, actualReturn) => {
-    msg += c().gray(`
+    msg += c2().gray(`
 
 Received: 
 
-${spy.mock.results.map((callReturn, i) => {
-      let methodCall = c().bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
+${spy.mock.results.map((callReturn, i2) => {
+      let methodCall = c2().bold(`  ${ordinalOf(i2 + 1)} ${spy.getMockName()} call return:
 
 `);
       if (actualReturn)
@@ -10940,9 +11026,9 @@ ${spy.mock.results.map((callReturn, i) => {
       methodCall += "\n";
       return methodCall;
     }).join("\n")}`);
-    msg += c().gray(`
+    msg += c2().gray(`
 
-Number of calls: ${c().bold(spy.mock.calls.length)}
+Number of calls: ${c2().bold(spy.mock.calls.length)}
 `);
     return msg;
   };
@@ -11076,8 +11162,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
         `expected error to be instance of ${name}`,
         `expected error not to be instance of ${name}`,
         expected,
-        thrown,
-        false
+        thrown
       );
     }
     if (expected instanceof Error) {
@@ -11095,9 +11180,8 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
         thrown && matcher.asymmetricMatch(thrown),
         "expected error to match asymmetric matcher",
         "expected error not to match asymmetric matcher",
-        matcher.toString(),
-        thrown,
-        false
+        matcher,
+        thrown
       );
     }
     throw new Error(`"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`);
@@ -11284,7 +11368,7 @@ var JestExtendError = class extends Error {
   }
 };
 function JestExtendPlugin(expect2, matchers) {
-  return (c, utils) => {
+  return (c2, utils) => {
     Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
       function expectWrapper(...args) {
         const { state, isNot, obj } = getMatcherState(this, expect2);
@@ -11301,7 +11385,7 @@ function JestExtendPlugin(expect2, matchers) {
       }
       const softWrapper = wrapSoft(utils, expectWrapper);
       utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, softWrapper);
-      utils.addMethod(c.Assertion.prototype, expectAssertionName, softWrapper);
+      utils.addMethod(c2.Assertion.prototype, expectAssertionName, softWrapper);
       class CustomMatcher extends AsymmetricMatcher3 {
         constructor(inverse = false, ...sample) {
           super(sample, inverse);
@@ -11360,12 +11444,12 @@ function getDefaultExportFromCjs2(x) {
 }
 var naturalCompare$2 = { exports: {} };
 var naturalCompare = function(a, b2) {
-  var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+  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;
@@ -11376,8 +11460,8 @@ var naturalCompare = function(a, b2) {
       codeB = getCode(b2, posB++);
       if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
         codeA = getCode(a, posA, posA);
-        codeB = getCode(b2, posB, posA = i);
-        posB = i;
+        codeB = getCode(b2, posB, posA = i2);
+        posB = i2;
       }
       if (codeA != codeB)
         return codeA < codeB ? -1 : 1;
@@ -11391,8 +11475,8 @@ try {
 }
 var naturalCompareExports = naturalCompare$2.exports;
 var naturalCompare$1 = /* @__PURE__ */ getDefaultExportFromCjs2(naturalCompareExports);
-function notNullish2(v2) {
-  return v2 != null;
+function notNullish2(v) {
+  return v != null;
 }
 function isPrimitive2(value) {
   return value === null || typeof value !== "function" && typeof value !== "object";
@@ -11456,8 +11540,8 @@ function positionToOffset(source, lineNumber, columnNumber) {
   let start = 0;
   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;
 }
 function offsetToLineNumber(source, offset) {
@@ -11697,10 +11781,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 c2 = chars2.charCodeAt(i2);
+  intToChar2[i2] = c2;
+  charToInt2[c2] = i2;
 }
 function decode(mappings) {
   const state = new Int32Array(5);
@@ -11712,19 +11796,19 @@ function decode(mappings) {
     let sorted = true;
     let lastCol = 0;
     state[0] = 0;
-    for (let i = index; i < semi; i++) {
+    for (let i2 = index; i2 < semi; i2++) {
       let seg;
-      i = decodeInteger(mappings, i, state, 0);
+      i2 = decodeInteger(mappings, i2, state, 0);
       const col = state[0];
       if (col < lastCol)
         sorted = false;
       lastCol = col;
-      if (hasMoreVlq(mappings, i, semi)) {
-        i = decodeInteger(mappings, i, state, 1);
-        i = decodeInteger(mappings, i, state, 2);
-        i = decodeInteger(mappings, i, state, 3);
-        if (hasMoreVlq(mappings, i, semi)) {
-          i = decodeInteger(mappings, i, state, 4);
+      if (hasMoreVlq(mappings, i2, semi)) {
+        i2 = decodeInteger(mappings, i2, state, 1);
+        i2 = decodeInteger(mappings, i2, state, 2);
+        i2 = decodeInteger(mappings, i2, state, 3);
+        if (hasMoreVlq(mappings, i2, semi)) {
+          i2 = decodeInteger(mappings, i2, state, 4);
           seg = [col, state[1], state[2], state[3], state[4]];
         } else {
           seg = [col, state[1], state[2], state[3]];
@@ -11750,8 +11834,8 @@ function decodeInteger(mappings, pos, state, j) {
   let shift = 0;
   let integer = 0;
   do {
-    const c = mappings.charCodeAt(pos++);
-    integer = charToInt2[c];
+    const c2 = mappings.charCodeAt(pos++);
+    integer = charToInt2[c2];
     value |= (integer & 31) << shift;
     shift += 5;
   } while (integer & 32);
@@ -11763,10 +11847,10 @@ function decodeInteger(mappings, pos, state, j) {
   state[j] += value;
   return pos;
 }
-function hasMoreVlq(mappings, i, length) {
-  if (i >= length)
+function hasMoreVlq(mappings, i2, length) {
+  if (i2 >= length)
     return false;
-  return mappings.charCodeAt(i) !== comma2;
+  return mappings.charCodeAt(i2) !== comma2;
 }
 function sort(line) {
   line.sort(sortComparator$1);
@@ -11867,8 +11951,8 @@ function normalizePath(url, type2) {
   let pointer = 1;
   let positive = 0;
   let addTrailingSlash = false;
-  for (let i = 1; i < pieces.length; i++) {
-    const piece = pieces[i];
+  for (let i2 = 1; i2 < pieces.length; i2++) {
+    const piece = pieces[i2];
     if (!piece) {
       addTrailingSlash = true;
       continue;
@@ -11890,8 +11974,8 @@ function normalizePath(url, type2) {
     positive++;
   }
   let path3 = "";
-  for (let i = 1; i < pointer; i++) {
-    path3 += "/" + pieces[i];
+  for (let i2 = 1; i2 < pointer; i2++) {
+    path3 += "/" + pieces[i2];
   }
   if (!path3 || addTrailingSlash && !path3.endsWith("/..")) {
     path3 += "/";
@@ -11967,15 +12051,15 @@ function maybeSort(mappings, owned) {
     return mappings;
   if (!owned)
     mappings = mappings.slice();
-  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-    mappings[i] = sortSegments(mappings[i], owned);
+  for (let i2 = unsortedIndex; i2 < mappings.length; i2 = nextUnsortedSegmentLine(mappings, i2 + 1)) {
+    mappings[i2] = sortSegments(mappings[i2], owned);
   }
   return mappings;
 }
 function nextUnsortedSegmentLine(mappings, start) {
-  for (let i = start; i < mappings.length; i++) {
-    if (!isSorted(mappings[i]))
-      return i;
+  for (let i2 = start; i2 < mappings.length; i2++) {
+    if (!isSorted(mappings[i2]))
+      return i2;
   }
   return mappings.length;
 }
@@ -12014,15 +12098,15 @@ function binarySearch(haystack, needle, low, high) {
   return low - 1;
 }
 function upperBound(haystack, needle, index) {
-  for (let i = index + 1; i < haystack.length; index = i++) {
-    if (haystack[i][COLUMN] !== needle)
+  for (let i2 = index + 1; i2 < haystack.length; index = i2++) {
+    if (haystack[i2][COLUMN] !== needle)
       break;
   }
   return index;
 }
 function lowerBound(haystack, needle, index) {
-  for (let i = index - 1; i >= 0; index = i--) {
-    if (haystack[i][COLUMN] !== needle)
+  for (let i2 = index - 1; i2 >= 0; index = i2--) {
+    if (haystack[i2][COLUMN] !== needle)
       break;
   }
   return index;
@@ -12210,7 +12294,7 @@ function parseStacktrace(stack, options = {}) {
   const { ignoreStackEntries = stackIgnorePatterns } = options;
   let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
   if (ignoreStackEntries.length)
-    stacks = stacks.filter((stack2) => !ignoreStackEntries.some((p2) => stack2.file.match(p2)));
+    stacks = stacks.filter((stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p)));
   return stacks.map((stack2) => {
     var _a2;
     const map2 = (_a2 = options.getSourceMap) == null ? void 0 : _a2.call(options, stack2.file);
@@ -12237,15 +12321,15 @@ function parseErrorStacktrace(e, options = {}) {
   const stackStr = e.stack || e.stackStr || "";
   let stackFrames = parseStacktrace(stackStr, options);
   if (options.frameFilter)
-    stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+    stackFrames = stackFrames.filter((f2) => options.frameFilter(e, f2) !== false);
   e.stacks = stackFrames;
   return stackFrames;
 }
 async function saveInlineSnapshots(environment, snapshots) {
   const MagicString2 = (await Promise.resolve().then(() => (init_magic_string_es(), magic_string_es_exports))).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 MagicString2(code);
     for (const snap of snaps) {
@@ -12301,7 +12385,7 @@ function prepareSnapString(snap, source, index) {
   if (isOneline)
     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 startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\S\s]*\*\/\s*|\/\/.*\s+)*\s*[\w_$]*(['"`\)])/m;
@@ -12340,12 +12424,12 @@ function stripSnapshotIndentation(inlineSnapshot) {
   if (lines[0].trim() !== "" || lines[lines.length - 1].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] = "";
@@ -12418,10 +12502,10 @@ var SnapshotState = class _SnapshotState {
     });
   }
   _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) {
@@ -12828,17 +12912,17 @@ function normalizeString2(path3, allowAboveRoot) {
   }
   return res;
 }
-var isAbsolute2 = function(p2) {
-  return _IS_ABSOLUTE_RE2.test(p2);
+var isAbsolute2 = function(p) {
+  return _IS_ABSOLUTE_RE2.test(p);
 };
 var comma3 = ",".charCodeAt(0);
 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++) {
+  const c2 = chars3.charCodeAt(i2);
+  intToChar3[i2] = c2;
+  charToInt3[c2] = i2;
 }
 function decode2(mappings) {
   const state = new Int32Array(5);
@@ -12850,19 +12934,19 @@ function decode2(mappings) {
     let sorted = true;
     let lastCol = 0;
     state[0] = 0;
-    for (let i = index; i < semi; i++) {
+    for (let i2 = index; i2 < semi; i2++) {
       let seg;
-      i = decodeInteger2(mappings, i, state, 0);
+      i2 = decodeInteger2(mappings, i2, state, 0);
       const col = state[0];
       if (col < lastCol)
         sorted = false;
       lastCol = col;
-      if (hasMoreVlq2(mappings, i, semi)) {
-        i = decodeInteger2(mappings, i, state, 1);
-        i = decodeInteger2(mappings, i, state, 2);
-        i = decodeInteger2(mappings, i, state, 3);
-        if (hasMoreVlq2(mappings, i, semi)) {
-          i = decodeInteger2(mappings, i, state, 4);
+      if (hasMoreVlq2(mappings, i2, semi)) {
+        i2 = decodeInteger2(mappings, i2, state, 1);
+        i2 = decodeInteger2(mappings, i2, state, 2);
+        i2 = decodeInteger2(mappings, i2, state, 3);
+        if (hasMoreVlq2(mappings, i2, semi)) {
+          i2 = decodeInteger2(mappings, i2, state, 4);
           seg = [col, state[1], state[2], state[3], state[4]];
         } else {
           seg = [col, state[1], state[2], state[3]];
@@ -12888,8 +12972,8 @@ function decodeInteger2(mappings, pos, state, j) {
   let shift = 0;
   let integer = 0;
   do {
-    const c = mappings.charCodeAt(pos++);
-    integer = charToInt3[c];
+    const c2 = mappings.charCodeAt(pos++);
+    integer = charToInt3[c2];
     value |= (integer & 31) << shift;
     shift += 5;
   } while (integer & 32);
@@ -12901,10 +12985,10 @@ function decodeInteger2(mappings, pos, state, j) {
   state[j] += value;
   return pos;
 }
-function hasMoreVlq2(mappings, i, length) {
-  if (i >= length)
+function hasMoreVlq2(mappings, i2, length) {
+  if (i2 >= length)
     return false;
-  return mappings.charCodeAt(i) !== comma3;
+  return mappings.charCodeAt(i2) !== comma3;
 }
 function sort2(line) {
   line.sort(sortComparator$12);
@@ -12948,15 +13032,15 @@ function binarySearch2(haystack, needle, low, high) {
   return low - 1;
 }
 function upperBound2(haystack, needle, index) {
-  for (let i = index + 1; i < haystack.length; index = i++) {
-    if (haystack[i][COLUMN2] !== needle)
+  for (let i2 = index + 1; i2 < haystack.length; index = i2++) {
+    if (haystack[i2][COLUMN2] !== needle)
       break;
   }
   return index;
 }
 function lowerBound2(haystack, needle, index) {
-  for (let i = index - 1; i >= 0; index = i--) {
-    if (haystack[i][COLUMN2] !== needle)
+  for (let i2 = index - 1; i2 >= 0; index = i2--) {
+    if (haystack[i2][COLUMN2] !== needle)
       break;
   }
   return index;
@@ -12989,8 +13073,8 @@ function memoizedBinarySearch2(haystack, needle, state, key) {
 }
 function buildBySources(decoded, memos) {
   const sources = memos.map(buildNullArray);
-  for (let i = 0; i < decoded.length; i++) {
-    const line = decoded[i];
+  for (let i2 = 0; i2 < decoded.length; i2++) {
+    const line = decoded[i2];
     for (let j = 0; j < line.length; j++) {
       const seg = line[j];
       if (seg.length === 1)
@@ -13002,14 +13086,14 @@ function buildBySources(decoded, memos) {
       const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
       const memo = memos[sourceIndex];
       const index = upperBound2(originalLine, sourceColumn, memoizedBinarySearch2(originalLine, sourceColumn, memo, sourceLine));
-      insert(originalLine, memo.lastIndex = index + 1, [sourceColumn, i, seg[COLUMN2]]);
+      insert(originalLine, memo.lastIndex = index + 1, [sourceColumn, i2, seg[COLUMN2]]);
     }
   }
   return sources;
 }
 function insert(array2, index, value) {
-  for (let i = array2.length; i > index; i--) {
-    array2[i] = array2[i - 1];
+  for (let i2 = array2.length; i2 > index; i2--) {
+    array2[i2] = array2[i2 - 1];
   }
   array2[index] = value;
 }
@@ -13183,7 +13267,7 @@ function parseSingleV8Stack2(raw) {
   };
 }
 
-// ../../node_modules/vitest/dist/vendor/base.QYERqzkH.js
+// ../../node_modules/vitest/dist/vendor/base.N3JkKp7j.js
 init_esm_shims();
 function isChildProcess() {
   return typeof process !== "undefined" && !!process.send;
@@ -13194,7 +13278,7 @@ init_esm_shims();
 var RealDate = Date;
 var now2 = null;
 var MockDate = class _MockDate extends RealDate {
-  constructor(y2, m2, d2, h, M2, s, ms) {
+  constructor(y, m, d, h, M2, s, ms) {
     super();
     let date;
     switch (arguments.length) {
@@ -13205,15 +13289,15 @@ var MockDate = class _MockDate extends RealDate {
           date = new RealDate();
         break;
       case 1:
-        date = new RealDate(y2);
+        date = new RealDate(y);
         break;
       default:
-        d2 = typeof d2 === "undefined" ? 1 : d2;
+        d = typeof d === "undefined" ? 1 : d;
         h = h || 0;
         M2 = M2 || 0;
         s = s || 0;
         ms = ms || 0;
-        date = new RealDate(y2, m2, d2, h, M2, s, ms);
+        date = new RealDate(y, m, d, h, M2, s, ms);
         break;
     }
     Object.setPrototypeOf(date, _MockDate.prototype);
@@ -13241,7 +13325,7 @@ function resetDate() {
   globalThis.Date = RealDate;
 }
 
-// ../../node_modules/vitest/dist/vendor/vi.Bw2UL9c9.js
+// ../../node_modules/vitest/dist/vendor/vi.C5mroSoP.js
 function resetModules(modules, resetMocks = false) {
   const skipPaths = [
     // Vitest
@@ -13975,8 +14059,8 @@ function withGlobal(_global) {
     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;
     }
   }
@@ -13989,7 +14073,7 @@ function withGlobal(_global) {
     }
     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)) {
@@ -13997,12 +14081,12 @@ function withGlobal(_global) {
         "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;
   }
@@ -14044,15 +14128,15 @@ function withGlobal(_global) {
       );
     }
     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;
@@ -14173,11 +14257,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);
       }
     }
@@ -14388,11 +14472,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) {
@@ -14841,9 +14925,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;
@@ -14854,7 +14938,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);
@@ -14865,12 +14949,12 @@ 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 {
                 let numTimers;
-                if (i < clock.loopLimit) {
+                if (i2 < clock.loopLimit) {
                   if (!clock.timers) {
                     resetIsNearInfiniteLimit();
                     resolve3(clock.now);
@@ -14885,9 +14969,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);
@@ -14989,7 +15073,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         "config.target is no longer supported. Use `withGlobal(target)` instead."
       );
     }
-    let i, l;
+    let i2, l;
     const clock = createClock(config2.now, config2.loopLimit);
     clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
     clock.uninstall = function() {
@@ -15037,8 +15121,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
     if (_global === globalObject && timersModule) {
       clock.timersModuleMethods = [];
     }
-    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 (nameOfMethodToReplace === "hrtime") {
         if (_global.process && typeof _global.process.hrtime === "function") {
           hijackMethod(_global.process, nameOfMethodToReplace, clock);
@@ -15074,6 +15158,7 @@ defaultImplementation.createClock;
 defaultImplementation.install;
 var withGlobal_1 = withGlobal;
 var FakeTimers = class {
+  _global;
   _clock;
   _fakingTime;
   _fakingDate;
@@ -15088,6 +15173,7 @@ var FakeTimers = class {
     this._fakingDate = false;
     this._fakingTime = false;
     this._fakeTimers = withGlobal_1(global3);
+    this._global = global3;
   }
   clearAllTimers() {
     if (this._fakingTime)
@@ -15114,7 +15200,7 @@ var FakeTimers = class {
   }
   advanceTimersToNextTimer(steps = 1) {
     if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
+      for (let i2 = steps; i2 > 0; i2--) {
         this._clock.next();
         this._clock.tick(0);
         if (this._clock.countTimers() === 0)
@@ -15124,7 +15210,7 @@ var FakeTimers = class {
   }
   async advanceTimersToNextTimerAsync(steps = 1) {
     if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
+      for (let i2 = steps; i2 > 0; i2--) {
         await this._clock.nextAsync();
         this._clock.tick(0);
         if (this._clock.countTimers() === 0)
@@ -15168,11 +15254,11 @@ var FakeTimers = class {
         throw new Error("process.nextTick cannot be mocked inside child_process");
       const existingFakedMethods = (((_c = this._userConfig) == null ? void 0 : _c.toFake) || toFake).filter((method) => {
         switch (method) {
-          case "hrtime":
-          case "nextTick":
-            return typeof process !== "undefined" && method in process && process[method];
+          case "setImmediate":
+          case "clearImmediate":
+            return method in this._global && this._global[method];
           default:
-            return method in globalThis && globalThis[method];
+            return true;
         }
       });
       this._clock = this._fakeTimers.install({
@@ -15484,6 +15570,7 @@ function createVitest() {
     async importMock(path3) {
       return _mocker.importMock(path3, getImporter());
     },
+    // this is typed in the interface so it's not necessary to type it here
     mocked(item, _options = {}) {
       return item;
     },
@@ -15561,7 +15648,7 @@ function createVitest() {
 var vitest = createVitest();
 var vi = vitest;
 
-// ../../node_modules/vitest/dist/vendor/index.vs_-lzuF.js
+// ../../node_modules/vitest/dist/vendor/index.JZMafwT-.js
 init_esm_shims();
 function getRunningMode() {
   return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
@@ -15647,6 +15734,7 @@ var VitestIndex = /* @__PURE__ */ Object.freeze({
   isWatchMode,
   it,
   onTestFailed,
+  onTestFinished,
   runOnce,
   should,
   suite,