@lokascript/framework 7.0.0 → 7.1.0

package/dist/testing/index.js

@@ -4,9 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn2, res) => function __init() {
   return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
@@ -35,10 +32,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
 // ../../node_modules/expect-type/dist/branding.js
 var require_branding = __commonJS({
@@ -109,7 +102,7 @@ var require_dist = __commonJS({
       o2[k2] = m2[k];
     }));
     var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
-      for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
+      for (var p2 in m2) if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p2)) __createBinding(exports2, m2, p2);
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.expectTypeOf = void 0;
@@ -197,11 +190,11 @@ function encodeRangeMappings(decoded) {
   for (let i3 = 0; i3 < decoded.length; i3++) {
     const indices = decoded[i3];
     if (i3 > 0) writer.write(semicolon);
-    let index = 0;
+    let index2 = 0;
     for (let j = 0; j < indices.length; j++) {
       const offset = indices[j];
-      encodeInteger(writer, offset - index);
-      index = offset;
+      encodeInteger(writer, offset - index2);
+      index2 = offset;
     }
   }
   return writer.flush();
@@ -246,9 +239,9 @@ var init_sourcemap_codec = __esm({
     intToChar3 = new Uint8Array(64);
     charToInt3 = new Uint8Array(128);
     for (let i3 = 0; i3 < chars3.length; i3++) {
-      const c = chars3.charCodeAt(i3);
-      intToChar3[i3] = c;
-      charToInt3[c] = i3;
+      const c2 = chars3.charCodeAt(i3);
+      intToChar3[i3] = c2;
+      charToInt3[c2] = i3;
     }
     bufLength = 1024 * 16;
     td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
@@ -287,7 +280,7 @@ var init_sourcemap_codec = __esm({
   }
 });
 
-// node_modules/magic-string/dist/index.mjs
+// ../../node_modules/vitest/node_modules/magic-string/dist/index.mjs
 var dist_exports = {};
 __export(dist_exports, {
   Bundle: () => Bundle,
@@ -307,18 +300,18 @@ function getBtoa() {
 function getLocator(source) {
   const lineOffsets = [0];
   for (let i3 = source.indexOf("\n"); i3 !== -1; i3 = source.indexOf("\n", i3 + 1)) lineOffsets.push(i3 + 1);
-  return function locate(index) {
+  return function locate(index2) {
     let i3 = 0;
     let j = lineOffsets.length;
     while (i3 < j) {
       const m2 = i3 + j >> 1;
-      if (index < lineOffsets[m2]) j = m2;
+      if (index2 < lineOffsets[m2]) j = m2;
       else i3 = m2 + 1;
     }
     const line = i3 - 1;
     return {
       line,
-      column: index - lineOffsets[line]
+      column: index2 - lineOffsets[line]
     };
   };
 }
@@ -367,14 +360,14 @@ function isWordCode(code) {
 function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
   if (!replacement.includes("$")) return replacement;
   let result = "";
-  let index = 0;
-  while (index < replacement.length) {
-    const dollar = replacement.indexOf("$", index);
+  let index2 = 0;
+  while (index2 < replacement.length) {
+    const dollar = replacement.indexOf("$", index2);
     if (dollar === -1) {
-      result += replacement.slice(index);
+      result += replacement.slice(index2);
       break;
     }
-    result += replacement.slice(index, dollar);
+    result += replacement.slice(index2, dollar);
     const char = replacement[dollar + 1];
     let expansion = "$";
     let consumed = 1;
@@ -407,24 +400,24 @@ function expandReplacement(replacement, matched, position, str, captures, namedC
       }
     }
     result += expansion;
-    index = dollar + consumed;
+    index2 = dollar + consumed;
   }
   return result;
 }
-var BitSet, Chunk, MagicStringError, btoa, SourceMap, toString3, BASE64_CHARS, intToChar4, COMMA, SEMICOLON, BUFFER_SIZE, FLUSH_THRESHOLD, scratch, decoder, MappingsEncoder, NEWLINE_CHAR$1, Mappings, n2, NEWLINE_CHAR, CR_CHAR, warned, MagicString, hasOwnProp, Bundle;
+var BitSet, Chunk, MagicStringError, btoa, SourceMap, toString3, BASE64_CHARS, intToChar4, COMMA, SEMICOLON, BUFFER_SIZE, FLUSH_THRESHOLD, scratch, decoder, MappingsEncoder, NEWLINE_CHAR$1, Mappings, n, NEWLINE_CHAR, CR_CHAR, warned, MagicString, hasOwnProp, Bundle;
 var init_dist = __esm({
-  "node_modules/magic-string/dist/index.mjs"() {
+  "../../node_modules/vitest/node_modules/magic-string/dist/index.mjs"() {
     "use strict";
     init_sourcemap_codec();
     BitSet = class BitSet2 {
       constructor(arg) {
         this.bits = arg instanceof BitSet2 ? arg.bits.slice() : [];
       }
-      add(n3) {
-        this.bits[n3 >> 5] |= 1 << (n3 & 31);
+      add(n2) {
+        this.bits[n2 >> 5] |= 1 << (n2 & 31);
       }
-      has(n3) {
-        return !!(this.bits[n3 >> 5] & 1 << (n3 & 31));
+      has(n2) {
+        return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
       }
     };
     Chunk = class Chunk2 {
@@ -455,8 +448,8 @@ var init_dist = __esm({
         chunk.edited = this.edited;
         return chunk;
       }
-      contains(index) {
-        return this.start < index && index < this.end;
+      contains(index2) {
+        return this.start < index2 && index2 < this.end;
       }
       eachNext(fn2) {
         fn2(this);
@@ -499,15 +492,15 @@ var init_dist = __esm({
           this.edited = false;
         }
       }
-      split(index) {
-        const sliceIndex = index - this.start;
+      split(index2) {
+        const sliceIndex = index2 - this.start;
         const originalBefore = this.original.slice(0, sliceIndex);
         const originalAfter = this.original.slice(sliceIndex);
         this.original = originalBefore;
-        const newChunk = new Chunk2(index, this.end, originalAfter);
+        const newChunk = new Chunk2(index2, this.end, originalAfter);
         newChunk.outro = this.outro;
         this.outro = "";
-        this.end = index;
+        this.end = index2;
         if (this.edited) {
           newChunk.edit("", false, true);
           this.content = "";
@@ -814,9 +807,9 @@ var init_dist = __esm({
                 const base = w << 5;
                 while (word) {
                   const lowest = word & -word;
-                  const index = base + 31 - Math.clz32(lowest);
-                  if (index > i3 && index < newline) {
-                    const offset = index - i3;
+                  const index2 = base + 31 - Math.clz32(lowest);
+                  if (index2 > i3 && index2 < newline) {
+                    const offset = index2 - i3;
                     this.rawSegments.push([
                       this.generatedCodeColumn + offset,
                       sourceIndex,
@@ -845,7 +838,7 @@ var init_dist = __esm({
         this.generatedCodeColumn += str.length - lastNewline - 1;
       }
     };
-    n2 = "\n";
+    n = "\n";
     NEWLINE_CHAR = "\n".charCodeAt(0);
     CR_CHAR = "\r".charCodeAt(0);
     warned = {
@@ -942,11 +935,11 @@ var init_dist = __esm({
       * If a range *ending* with index is subsequently moved, the insert will be moved with it.
       * See also `s.prependLeft(...)`.
       */
-      appendLeft(index, content) {
-        index = index + this.offset;
+      appendLeft(index2, content) {
+        index2 = index2 + this.offset;
         if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
-        this._split(index);
-        const chunk = this.byEnd.get(index);
+        this._split(index2);
+        const chunk = this.byEnd.get(index2);
         if (chunk) chunk.appendLeft(content);
         else this.intro += content;
         return this;
@@ -956,11 +949,11 @@ var init_dist = __esm({
       * If a range *starting* with index is subsequently moved, the insert will be moved with it.
       * See also `s.prependRight(...)`.
       */
-      appendRight(index, content) {
-        index = index + this.offset;
+      appendRight(index2, content) {
+        index2 = index2 + this.offset;
         if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
-        this._split(index);
-        const chunk = this.byStart.get(index);
+        this._split(index2);
+        const chunk = this.byStart.get(index2);
         if (chunk) chunk.appendRight(content);
         else this.outro += content;
         return this;
@@ -1091,11 +1084,11 @@ var init_dist = __esm({
         this.intro = indentPiece(this.intro);
         let charIndex = 0;
         let chunk = this.firstChunk;
-        const indentAt = (index) => {
+        const indentAt = (index2) => {
           shouldIndentNextCharacter = false;
-          if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
+          if (index2 === chunk.start) chunk.appendRight(resolvedIndentStr);
           else {
-            this._splitChunk(chunk, index);
+            this._splitChunk(chunk, index2);
             chunk = chunk.next;
             chunk.prependRight(resolvedIndentStr);
           }
@@ -1119,7 +1112,7 @@ var init_dist = __esm({
             charIndex = chunk.start;
             while (charIndex < end) {
               if (!shouldIndentNextCharacter) {
-                const nextLine = this.original.indexOf(n2, charIndex);
+                const nextLine = this.original.indexOf(n, charIndex);
                 if (nextLine === -1 || nextLine >= end) break;
                 shouldIndentNextCharacter = true;
                 charIndex = nextLine + 1;
@@ -1146,20 +1139,20 @@ var init_dist = __esm({
         throw new MagicStringError("insert() is deprecated, use appendLeft() or prependRight()");
       }
       /** @internal */
-      insertLeft(index, content) {
+      insertLeft(index2, content) {
         if (!warned.insertLeft) {
           console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
           warned.insertLeft = true;
         }
-        return this.appendLeft(index, content);
+        return this.appendLeft(index2, content);
       }
       /** @internal */
-      insertRight(index, content) {
+      insertRight(index2, content) {
         if (!warned.insertRight) {
           console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
           warned.insertRight = true;
         }
-        return this.prependRight(index, content);
+        return this.prependRight(index2, content);
       }
       /**
       * Moves the characters from `start` and `end` to `index`.
@@ -1170,15 +1163,15 @@ var init_dist = __esm({
       * two differ only when other content has already been moved to that boundary,
       * mirroring the `appendLeft`/`appendRight` distinction.
       */
-      move(start, end, index, affinity = "right") {
+      move(start, end, index2, affinity = "right") {
         start = start + this.offset;
         end = end + this.offset;
-        index = index + this.offset;
+        index2 = index2 + this.offset;
         if (start === end) return this;
-        if (index >= start && index <= end) throw new MagicStringError("cannot move a selection inside itself");
+        if (index2 >= start && index2 <= end) throw new MagicStringError("cannot move a selection inside itself");
         this._split(start);
         this._split(end);
-        this._split(index);
+        this._split(index2);
         const first = this.byStart.get(start);
         const last = this.byEnd.get(end);
         if (this.hasMovedChunks) {
@@ -1193,7 +1186,7 @@ var init_dist = __esm({
         let newLeft;
         let newRight;
         if (affinity === "left") {
-          newLeft = this.byEnd.get(index) ?? null;
+          newLeft = this.byEnd.get(index2) ?? null;
           if (!newLeft) {
             if (first === this.firstChunk) return this;
             newRight = this.firstChunk;
@@ -1202,7 +1195,7 @@ var init_dist = __esm({
             newRight = newLeft.next;
           }
         } else {
-          newRight = this.byStart.get(index) ?? null;
+          newRight = this.byStart.get(index2) ?? null;
           if (!newRight) {
             if (last === this.lastChunk) return this;
             newLeft = this.lastChunk;
@@ -1290,7 +1283,7 @@ var init_dist = __esm({
           while (chunk !== last) {
             if (chunk.next !== this.byStart.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
             chunk = chunk.next;
-            chunk.edit("", false);
+            chunk.edit("", false, !overwrite);
           }
           first.edit(content, storeName, !overwrite);
         } else {
@@ -1311,11 +1304,11 @@ var init_dist = __esm({
       /**
       * Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
       */
-      prependLeft(index, content) {
-        index = index + this.offset;
+      prependLeft(index2, content) {
+        index2 = index2 + this.offset;
         if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
-        this._split(index);
-        const chunk = this.byEnd.get(index);
+        this._split(index2);
+        const chunk = this.byEnd.get(index2);
         if (chunk) chunk.prependLeft(content);
         else this.intro = content + this.intro;
         return this;
@@ -1323,11 +1316,11 @@ var init_dist = __esm({
       /**
       * Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
       */
-      prependRight(index, content) {
-        index = index + this.offset;
+      prependRight(index2, content) {
+        index2 = index2 + this.offset;
         if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
-        this._split(index);
-        const chunk = this.byStart.get(index);
+        this._split(index2);
+        const chunk = this.byStart.get(index2);
         if (chunk) chunk.prependRight(content);
         else this.outro = content + this.outro;
         return this;
@@ -1395,29 +1388,29 @@ var init_dist = __esm({
         return "";
       }
       lastLine() {
-        let lineIndex = this.outro.lastIndexOf(n2);
+        let lineIndex = this.outro.lastIndexOf(n);
         if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
         let lineStr = this.outro;
         let chunk = this.lastChunk;
         while (chunk) {
           if (chunk.outro.length > 0) {
-            lineIndex = chunk.outro.lastIndexOf(n2);
+            lineIndex = chunk.outro.lastIndexOf(n);
             if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
             lineStr = chunk.outro + lineStr;
           }
           if (chunk.content.length > 0) {
-            lineIndex = chunk.content.lastIndexOf(n2);
+            lineIndex = chunk.content.lastIndexOf(n);
             if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
             lineStr = chunk.content + lineStr;
           }
           if (chunk.intro.length > 0) {
-            lineIndex = chunk.intro.lastIndexOf(n2);
+            lineIndex = chunk.intro.lastIndexOf(n);
             if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
             lineStr = chunk.intro + lineStr;
           }
           chunk = chunk.previous;
         }
-        lineIndex = this.intro.lastIndexOf(n2);
+        lineIndex = this.intro.lastIndexOf(n);
         if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
         return this.intro + lineStr;
       }
@@ -1464,27 +1457,27 @@ var init_dist = __esm({
         return clone2;
       }
       /** @internal */
-      _split(index) {
-        if (this.byStart.get(index) || this.byEnd.get(index)) return;
+      _split(index2) {
+        if (this.byStart.get(index2) || this.byEnd.get(index2)) return;
         let chunk = this.lastSearchedChunk;
         let previousChunk = chunk;
-        const searchForward = index > chunk.end;
+        const searchForward = index2 > chunk.end;
         while (chunk) {
-          if (chunk.contains(index)) return this._splitChunk(chunk, index);
+          if (chunk.contains(index2)) return this._splitChunk(chunk, index2);
           chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
           if (chunk === previousChunk) return;
           previousChunk = chunk;
         }
       }
       /** @internal */
-      _splitChunk(chunk, index) {
+      _splitChunk(chunk, index2) {
         if (chunk.edited && chunk.content.length) {
-          const loc = getLocator(this.original)(index);
+          const loc = getLocator(this.original)(index2);
           throw new MagicStringError(`cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`);
         }
-        const newChunk = chunk.split(index);
-        this.byEnd.set(index, chunk);
-        this.byStart.set(index, newChunk);
+        const newChunk = chunk.split(index2);
+        this.byEnd.set(index2, chunk);
+        this.byStart.set(index2, newChunk);
         this.byEnd.set(newChunk.end, newChunk);
         if (chunk === this.lastChunk) this.lastChunk = newChunk;
         this.lastSearchedChunk = chunk;
@@ -1643,8 +1636,8 @@ var init_dist = __esm({
           if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
           const replacement2 = getReplacement(match, this.original);
           if (replacement2 === match[0]) return true;
-          if (match[0].length === 0) this.appendRight(match.index, replacement2);
-          else this.overwrite(match.index, match.index + match[0].length, replacement2);
+          if (match[0].length === 0) this.appendRight(match.index - this.offset, replacement2);
+          else this.overwrite(match.index - this.offset, match.index + match[0].length - this.offset, replacement2);
           return true;
         };
         if (searchValue.global) {
@@ -1662,17 +1655,17 @@ var init_dist = __esm({
       /** @internal */
       _replaceString(string2, replacement) {
         const { original } = this;
-        let index = original.indexOf(string2);
-        while (index !== -1) {
-          if (this._hasRemovedContent(index, index + string2.length)) {
-            index = original.indexOf(string2, index + string2.length);
+        let index2 = original.indexOf(string2);
+        while (index2 !== -1) {
+          if (this._hasRemovedContent(index2, index2 + string2.length)) {
+            index2 = original.indexOf(string2, index2 + string2.length);
             continue;
           }
-          if (typeof replacement === "function") replacement = replacement(string2, index, original);
-          else replacement = expandReplacement(replacement, string2, index, original, [], void 0);
+          if (typeof replacement === "function") replacement = replacement(string2, index2, original);
+          else replacement = expandReplacement(replacement, string2, index2, original, [], void 0);
           if (string2 !== replacement) {
-            if (string2.length === 0) this.appendRight(index, replacement);
-            else this.overwrite(index, index + string2.length, replacement);
+            if (string2.length === 0) this.appendRight(index2 - this.offset, replacement);
+            else this.overwrite(index2 - this.offset, index2 + string2.length - this.offset, replacement);
           }
           break;
         }
@@ -1690,18 +1683,18 @@ var init_dist = __esm({
         const { original } = this;
         const stringLength = string2.length;
         if (stringLength === 0) {
-          for (let index = 0; index <= original.length; index += 1) {
-            if (this._hasRemovedContent(index, index)) continue;
-            const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
-            if (_replacement !== "") this.appendRight(index, _replacement);
+          for (let index2 = 0; index2 <= original.length; index2 += 1) {
+            if (this._hasRemovedContent(index2, index2)) continue;
+            const _replacement = typeof replacement === "function" ? replacement("", index2, original) : expandReplacement(replacement, "", index2, original, [], void 0);
+            if (_replacement !== "") this.appendRight(index2 - this.offset, _replacement);
           }
           return this;
         }
-        for (let index = original.indexOf(string2); index !== -1; index = original.indexOf(string2, index + stringLength)) {
-          if (this._hasRemovedContent(index, index + stringLength)) continue;
-          const previous = original.slice(index, index + stringLength);
-          const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
-          if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
+        for (let index2 = original.indexOf(string2); index2 !== -1; index2 = original.indexOf(string2, index2 + stringLength)) {
+          if (this._hasRemovedContent(index2, index2 + stringLength)) continue;
+          const previous = original.slice(index2, index2 + stringLength);
+          const _replacement = typeof replacement === "function" ? replacement(previous, index2, original) : expandReplacement(replacement, previous, index2, original, [], void 0);
+          if (previous !== _replacement) this.overwrite(index2 - this.offset, index2 + stringLength - this.offset, _replacement);
         }
         return this;
       }
@@ -1839,7 +1832,7 @@ var init_dist = __esm({
             sourceFirst.previous = last;
           } else first = sourceFirst;
           last = sourceLast;
-          for (let index = 0; index < magicString.original.length; index += 1) if (magicString.sourcemapLocations.has(index)) combined.sourcemapLocations.add(index + offset);
+          for (let index2 = 0; index2 < magicString.original.length; index2 += 1) if (magicString.sourcemapLocations.has(index2)) combined.sourcemapLocations.add(index2 + offset);
           Object.keys(magicString.storedNames).forEach((name) => {
             Object.defineProperty(combined.storedNames, name, {
               writable: true,
@@ -1941,8 +1934,8 @@ var init_dist = __esm({
           if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
           indentStringCounts[indentStr] += 1;
         });
-        return Object.keys(indentStringCounts).sort((a2, b2) => {
-          return indentStringCounts[b2] - indentStringCounts[a2];
+        return Object.keys(indentStringCounts).sort((a, b2) => {
+          return indentStringCounts[b2] - indentStringCounts[a];
         })[0] || "	";
       }
       indent(indentStr) {
@@ -1958,8 +1951,8 @@ var init_dist = __esm({
           });
           trailingNewline = source.content.lastChar() === "\n";
         });
-        if (this.intro) this.intro = indentStr + this.intro.replace(/^[^\n]/gm, (match, index) => {
-          return index > 0 ? indentStr + match : match;
+        if (this.intro) this.intro = indentStr + this.intro.replace(/^[^\n]/gm, (match, index2) => {
+          return index2 > 0 ? indentStr + match : match;
         });
         return this;
       }
@@ -2024,104 +2017,109 @@ var init_dist = __esm({
   }
 });
 
-// node_modules/vitest/dist/chunks/tinyrainbow.Ht9iggcq.js
-var b = {
-  reset: [0, 0],
-  bold: [1, 22, "\x1B[22m\x1B[1m"],
-  dim: [2, 22, "\x1B[22m\x1B[2m"],
-  italic: [3, 23],
-  underline: [4, 24],
-  inverse: [7, 27],
-  hidden: [8, 28],
-  strikethrough: [9, 29],
-  black: [30, 39],
-  red: [31, 39],
-  green: [32, 39],
-  yellow: [33, 39],
-  blue: [34, 39],
-  magenta: [35, 39],
-  cyan: [36, 39],
-  white: [37, 39],
-  gray: [90, 39],
-  bgBlack: [40, 49],
-  bgRed: [41, 49],
-  bgGreen: [42, 49],
-  bgYellow: [43, 49],
-  bgBlue: [44, 49],
-  bgMagenta: [45, 49],
-  bgCyan: [46, 49],
-  bgWhite: [47, 49],
-  blackBright: [90, 39],
-  redBright: [91, 39],
-  greenBright: [92, 39],
-  yellowBright: [93, 39],
-  blueBright: [94, 39],
-  magentaBright: [95, 39],
-  cyanBright: [96, 39],
-  whiteBright: [97, 39],
-  bgBlackBright: [100, 49],
-  bgRedBright: [101, 49],
-  bgGreenBright: [102, 49],
-  bgYellowBright: [103, 49],
-  bgBlueBright: [104, 49],
-  bgMagentaBright: [105, 49],
-  bgCyanBright: [106, 49],
-  bgWhiteBright: [107, 49]
+// ../../node_modules/vitest/dist/chunks/tinyrainbow.Do8I1XRG.js
+var d = (e2) => String(e2);
+d.open = d.close = "";
+var i = () => d;
+var t = "\x1B[39m";
+var o = "\x1B[49m";
+var F = (e2, r, a, n2, l) => {
+  let m2 = "", g2 = 0;
+  do
+    m2 += e2.substring(g2, n2) + a, g2 = n2 + l, n2 = e2.indexOf(r, g2);
+  while (~n2);
+  return m2 + e2.substring(g2);
 };
-function i(e) {
-  return String(e);
-}
-i.open = "";
-i.close = "";
-function B() {
-  let e = typeof process != "undefined" ? process : void 0, r2 = (e == null ? void 0 : e.env) || {}, a2 = r2.FORCE_TTY !== "false", l = (e == null ? void 0 : e.argv) || [];
-  return !("NO_COLOR" in r2 || l.includes("--no-color")) && ("FORCE_COLOR" in r2 || l.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a2 && r2.TERM !== "dumb" || "CI" in r2) || typeof window != "undefined" && !!window.chrome;
-}
-function C({ force: e } = {}) {
-  let r2 = e || B(), a2 = (t2, o2, u, n3) => {
-    let g = "", s = 0;
-    do
-      g += t2.substring(s, n3) + u, s = n3 + o2.length, n3 = t2.indexOf(o2, s);
-    while (~n3);
-    return g + t2.substring(s);
-  }, l = (t2, o2, u = t2) => {
-    let n3 = (g) => {
-      let s = String(g), h = s.indexOf(o2, t2.length);
-      return ~h ? t2 + a2(s, o2, u, h) + o2 : t2 + s + o2;
-    };
-    return n3.open = t2, n3.close = o2, n3;
-  }, c = {
-    isColorSupported: r2
-  }, f = (t2) => `\x1B[${t2}m`;
-  for (let t2 in b) {
-    let o2 = b[t2];
-    c[t2] = r2 ? l(
-      f(o2[0]),
-      f(o2[1]),
-      o2[2]
-    ) : i;
-  }
-  return c;
-}
-var d = C();
-var y = d;
+var u = (e2, r, a = e2, n2 = e2.length) => {
+  let l = r.length, m2 = (g2) => {
+    let s = g2 + "", x = s.indexOf(r, n2);
+    return ~x ? e2 + F(s, r, a, x, l) + r : e2 + s + r;
+  };
+  return m2.open = e2, m2.close = r, m2;
+};
+var B = (e2, r) => u(e2, r, e2, 5);
+var c = (e2) => {
+  let r = e2.charCodeAt(0) === 35 ? e2.slice(1) : e2, a = parseInt(r, 16) || 0;
+  return r.length < 6 ? `${(a >> 8 & 15) * 17};${(a >> 4 & 15) * 17};${(a & 15) * 17}` : `${a >> 16 & 255};${a >> 8 & 255};${a & 255}`;
+};
+function y(e2) {
+  let r = e2 ? u : i;
+  return {
+    isColorSupported: e2,
+    reset: r("\x1B[0m", "\x1B[0m"),
+    bold: r("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+    dim: r("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+    italic: r("\x1B[3m", "\x1B[23m"),
+    underline: r("\x1B[4m", "\x1B[24m"),
+    inverse: r("\x1B[7m", "\x1B[27m"),
+    hidden: r("\x1B[8m", "\x1B[28m"),
+    strikethrough: r("\x1B[9m", "\x1B[29m"),
+    black: r("\x1B[30m", t),
+    red: r("\x1B[31m", t),
+    green: r("\x1B[32m", t),
+    yellow: r("\x1B[33m", t),
+    blue: r("\x1B[34m", t),
+    magenta: r("\x1B[35m", t),
+    cyan: r("\x1B[36m", t),
+    white: r("\x1B[37m", t),
+    gray: r("\x1B[90m", t),
+    bgBlack: r("\x1B[40m", o),
+    bgRed: r("\x1B[41m", o),
+    bgGreen: r("\x1B[42m", o),
+    bgYellow: r("\x1B[43m", o),
+    bgBlue: r("\x1B[44m", o),
+    bgMagenta: r("\x1B[45m", o),
+    bgCyan: r("\x1B[46m", o),
+    bgWhite: r("\x1B[47m", o),
+    blackBright: r("\x1B[90m", t),
+    redBright: r("\x1B[91m", t),
+    greenBright: r("\x1B[92m", t),
+    yellowBright: r("\x1B[93m", t),
+    blueBright: r("\x1B[94m", t),
+    magentaBright: r("\x1B[95m", t),
+    cyanBright: r("\x1B[96m", t),
+    whiteBright: r("\x1B[97m", t),
+    bgBlackBright: r("\x1B[100m", o),
+    bgRedBright: r("\x1B[101m", o),
+    bgGreenBright: r("\x1B[102m", o),
+    bgYellowBright: r("\x1B[103m", o),
+    bgBlueBright: r("\x1B[104m", o),
+    bgMagentaBright: r("\x1B[105m", o),
+    bgCyanBright: r("\x1B[106m", o),
+    bgWhiteBright: r("\x1B[107m", o),
+    rgb: e2 ? (n2, l, m2) => B(`\x1B[38;2;${n2};${l};${m2}m`, t) : i,
+    bgRgb: e2 ? (n2, l, m2) => B(`\x1B[48;2;${n2};${l};${m2}m`, o) : i,
+    hex: e2 ? (n2) => B(`\x1B[38;2;${c(n2)}m`, t) : i,
+    bgHex: e2 ? (n2) => B(`\x1B[48;2;${c(n2)}m`, o) : i
+  };
+}
+function C() {
+  let e2 = typeof process != "undefined" ? process : void 0, r = (e2 == null ? void 0 : e2.env) || {}, a = r.FORCE_TTY !== "false", n2 = (e2 == null ? void 0 : e2.argv) || [];
+  return !("NO_COLOR" in r || n2.includes("--no-color")) && ("FORCE_COLOR" in r || n2.includes("--color") || (e2 == null ? void 0 : e2.platform) === "win32" || a && r.TERM !== "dumb" || "CI" in r) || typeof window != "undefined" && !!window.chrome;
+}
+function h({ force: e2 } = {}) {
+  let r = e2 || C();
+  return y(r);
+}
+var b = h();
+var $ = b;
 
-// node_modules/vitest/dist/chunks/index.M2dsQ_UQ.js
-function _mergeNamespaces$1(n3, m2) {
-  m2.forEach(function(e) {
-    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
-      if (k !== "default" && !(k in n3)) {
-        var d2 = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n3, k, d2.get ? d2 : {
+// ../../node_modules/vitest/dist/chunks/index.D0heQG4v.js
+function _mergeNamespaces(n2, m2) {
+  m2.forEach(function(e2) {
+    e2 && typeof e2 !== "string" && !Array.isArray(e2) && Object.keys(e2).forEach(function(k) {
+      if (k !== "default" && !(k in n2)) {
+        var d2 = Object.getOwnPropertyDescriptor(e2, k);
+        Object.defineProperty(n2, k, d2.get ? d2 : {
           enumerable: true,
           get: function() {
-            return e[k];
+            return e2[k];
           }
         });
       }
     });
   });
-  return Object.freeze(n3);
+  return Object.freeze(n2);
 }
 function getKeysOfEnumerableProperties(object2, compareKeys) {
   const rawKeys = Object.keys(object2);
@@ -2431,6 +2429,7 @@ var plugin$2 = {
   serialize: serialize$2,
   test: test$2
 };
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -2521,22 +2520,120 @@ function requireReactIs_production() {
     return typeOf2(object2) === REACT_SUSPENSE_LIST_TYPE;
   };
   reactIs_production.isValidElementType = function(type3) {
-    return "string" === typeof type3 || "function" === typeof type3 || type3 === REACT_FRAGMENT_TYPE || type3 === REACT_PROFILER_TYPE || type3 === REACT_STRICT_MODE_TYPE || type3 === REACT_SUSPENSE_TYPE || type3 === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type3 && null !== type3 && (type3.$$typeof === REACT_LAZY_TYPE || type3.$$typeof === REACT_MEMO_TYPE || type3.$$typeof === REACT_CONTEXT_TYPE || type3.$$typeof === REACT_CONSUMER_TYPE || type3.$$typeof === REACT_FORWARD_REF_TYPE || type3.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type3.getModuleId) ? true : false;
+    return "string" === typeof type3 || "function" === typeof type3 || type3 === REACT_FRAGMENT_TYPE || type3 === REACT_PROFILER_TYPE || type3 === REACT_STRICT_MODE_TYPE || type3 === REACT_SUSPENSE_TYPE || type3 === REACT_SUSPENSE_LIST_TYPE || type3 === REACT_VIEW_TRANSITION_TYPE || "object" === typeof type3 && null !== type3 && (type3.$$typeof === REACT_LAZY_TYPE || type3.$$typeof === REACT_MEMO_TYPE || type3.$$typeof === REACT_CONTEXT_TYPE || type3.$$typeof === REACT_CONSUMER_TYPE || type3.$$typeof === REACT_FORWARD_REF_TYPE || type3.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type3.getModuleId) ? true : false;
   };
   reactIs_production.typeOf = typeOf2;
   return reactIs_production;
 }
+var reactIs_development$1 = {};
+var hasRequiredReactIs_development$1;
+function requireReactIs_development$1() {
+  if (hasRequiredReactIs_development$1) return reactIs_development$1;
+  hasRequiredReactIs_development$1 = 1;
+  "production" !== process.env.NODE_ENV && (function() {
+    function typeOf2(object2) {
+      if ("object" === typeof object2 && null !== object2) {
+        var $$typeof = object2.$$typeof;
+        switch ($$typeof) {
+          case REACT_ELEMENT_TYPE:
+            switch (object2 = object2.type, object2) {
+              case REACT_FRAGMENT_TYPE:
+              case REACT_PROFILER_TYPE:
+              case REACT_STRICT_MODE_TYPE:
+              case REACT_SUSPENSE_TYPE:
+              case REACT_SUSPENSE_LIST_TYPE:
+              case REACT_VIEW_TRANSITION_TYPE:
+                return object2;
+              default:
+                switch (object2 = object2 && object2.$$typeof, object2) {
+                  case REACT_CONTEXT_TYPE:
+                  case REACT_FORWARD_REF_TYPE:
+                  case REACT_LAZY_TYPE:
+                  case REACT_MEMO_TYPE:
+                    return object2;
+                  case REACT_CONSUMER_TYPE:
+                    return object2;
+                  default:
+                    return $$typeof;
+                }
+            }
+          case REACT_PORTAL_TYPE:
+            return $$typeof;
+        }
+      }
+    }
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+    reactIs_development$1.ContextConsumer = REACT_CONSUMER_TYPE;
+    reactIs_development$1.ContextProvider = REACT_CONTEXT_TYPE;
+    reactIs_development$1.Element = REACT_ELEMENT_TYPE;
+    reactIs_development$1.ForwardRef = REACT_FORWARD_REF_TYPE;
+    reactIs_development$1.Fragment = REACT_FRAGMENT_TYPE;
+    reactIs_development$1.Lazy = REACT_LAZY_TYPE;
+    reactIs_development$1.Memo = REACT_MEMO_TYPE;
+    reactIs_development$1.Portal = REACT_PORTAL_TYPE;
+    reactIs_development$1.Profiler = REACT_PROFILER_TYPE;
+    reactIs_development$1.StrictMode = REACT_STRICT_MODE_TYPE;
+    reactIs_development$1.Suspense = REACT_SUSPENSE_TYPE;
+    reactIs_development$1.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+    reactIs_development$1.isContextConsumer = function(object2) {
+      return typeOf2(object2) === REACT_CONSUMER_TYPE;
+    };
+    reactIs_development$1.isContextProvider = function(object2) {
+      return typeOf2(object2) === REACT_CONTEXT_TYPE;
+    };
+    reactIs_development$1.isElement = function(object2) {
+      return "object" === typeof object2 && null !== object2 && object2.$$typeof === REACT_ELEMENT_TYPE;
+    };
+    reactIs_development$1.isForwardRef = function(object2) {
+      return typeOf2(object2) === REACT_FORWARD_REF_TYPE;
+    };
+    reactIs_development$1.isFragment = function(object2) {
+      return typeOf2(object2) === REACT_FRAGMENT_TYPE;
+    };
+    reactIs_development$1.isLazy = function(object2) {
+      return typeOf2(object2) === REACT_LAZY_TYPE;
+    };
+    reactIs_development$1.isMemo = function(object2) {
+      return typeOf2(object2) === REACT_MEMO_TYPE;
+    };
+    reactIs_development$1.isPortal = function(object2) {
+      return typeOf2(object2) === REACT_PORTAL_TYPE;
+    };
+    reactIs_development$1.isProfiler = function(object2) {
+      return typeOf2(object2) === REACT_PROFILER_TYPE;
+    };
+    reactIs_development$1.isStrictMode = function(object2) {
+      return typeOf2(object2) === REACT_STRICT_MODE_TYPE;
+    };
+    reactIs_development$1.isSuspense = function(object2) {
+      return typeOf2(object2) === REACT_SUSPENSE_TYPE;
+    };
+    reactIs_development$1.isSuspenseList = function(object2) {
+      return typeOf2(object2) === REACT_SUSPENSE_LIST_TYPE;
+    };
+    reactIs_development$1.isValidElementType = function(type3) {
+      return "string" === typeof type3 || "function" === typeof type3 || type3 === REACT_FRAGMENT_TYPE || type3 === REACT_PROFILER_TYPE || type3 === REACT_STRICT_MODE_TYPE || type3 === REACT_SUSPENSE_TYPE || type3 === REACT_SUSPENSE_LIST_TYPE || type3 === REACT_VIEW_TRANSITION_TYPE || "object" === typeof type3 && null !== type3 && (type3.$$typeof === REACT_LAZY_TYPE || type3.$$typeof === REACT_MEMO_TYPE || type3.$$typeof === REACT_CONTEXT_TYPE || type3.$$typeof === REACT_CONSUMER_TYPE || type3.$$typeof === REACT_FORWARD_REF_TYPE || type3.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type3.getModuleId) ? true : false;
+    };
+    reactIs_development$1.typeOf = typeOf2;
+  })();
+  return reactIs_development$1;
+}
 var hasRequiredReactIs$1;
 function requireReactIs$1() {
   if (hasRequiredReactIs$1) return reactIs$1.exports;
   hasRequiredReactIs$1 = 1;
-  reactIs$1.exports = requireReactIs_production();
+  if (process.env.NODE_ENV === "production") {
+    reactIs$1.exports = requireReactIs_production();
+  } else {
+    reactIs$1.exports = requireReactIs_development$1();
+  }
   return reactIs$1.exports;
 }
 var reactIsExports$1 = requireReactIs$1();
-var ReactIs19 = /* @__PURE__ */ _mergeNamespaces$1({
+var index$1 = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports$1);
+var ReactIs19 = /* @__PURE__ */ _mergeNamespaces({
   __proto__: null,
-  default: /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports$1)
+  default: index$1
 }, [reactIsExports$1]);
 var reactIs = { exports: {} };
 var reactIs_production_min = {};
@@ -2544,108 +2641,295 @@ var hasRequiredReactIs_production_min;
 function requireReactIs_production_min() {
   if (hasRequiredReactIs_production_min) return reactIs_production_min;
   hasRequiredReactIs_production_min = 1;
-  var b2 = Symbol.for("react.element"), c = Symbol.for("react.portal"), d2 = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n3 = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t2 = Symbol.for("react.offscreen"), u = Symbol.for("react.module.reference");
-  function v(a2) {
-    if ("object" === typeof a2 && null !== a2) {
-      var r2 = a2.$$typeof;
-      switch (r2) {
+  var b2 = Symbol.for("react.element"), c2 = Symbol.for("react.portal"), d2 = Symbol.for("react.fragment"), e2 = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g2 = Symbol.for("react.provider"), h3 = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n2 = Symbol.for("react.suspense_list"), p2 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t3 = Symbol.for("react.offscreen"), u2;
+  u2 = Symbol.for("react.module.reference");
+  function v(a) {
+    if ("object" === typeof a && null !== a) {
+      var r = a.$$typeof;
+      switch (r) {
         case b2:
-          switch (a2 = a2.type, a2) {
+          switch (a = a.type, a) {
             case d2:
             case f:
-            case e:
+            case e2:
             case m2:
-            case n3:
-              return a2;
+            case n2:
+              return a;
             default:
-              switch (a2 = a2 && a2.$$typeof, a2) {
+              switch (a = a && a.$$typeof, a) {
                 case k:
-                case h:
+                case h3:
                 case l:
                 case q:
-                case p:
-                case g:
-                  return a2;
+                case p2:
+                case g2:
+                  return a;
                 default:
-                  return r2;
+                  return r;
               }
           }
-        case c:
-          return r2;
+        case c2:
+          return r;
       }
     }
   }
-  reactIs_production_min.ContextConsumer = h;
-  reactIs_production_min.ContextProvider = g;
+  reactIs_production_min.ContextConsumer = h3;
+  reactIs_production_min.ContextProvider = g2;
   reactIs_production_min.Element = b2;
   reactIs_production_min.ForwardRef = l;
   reactIs_production_min.Fragment = d2;
   reactIs_production_min.Lazy = q;
-  reactIs_production_min.Memo = p;
-  reactIs_production_min.Portal = c;
+  reactIs_production_min.Memo = p2;
+  reactIs_production_min.Portal = c2;
   reactIs_production_min.Profiler = f;
-  reactIs_production_min.StrictMode = e;
+  reactIs_production_min.StrictMode = e2;
   reactIs_production_min.Suspense = m2;
-  reactIs_production_min.SuspenseList = n3;
+  reactIs_production_min.SuspenseList = n2;
   reactIs_production_min.isAsyncMode = function() {
     return false;
   };
   reactIs_production_min.isConcurrentMode = function() {
     return false;
   };
-  reactIs_production_min.isContextConsumer = function(a2) {
-    return v(a2) === h;
+  reactIs_production_min.isContextConsumer = function(a) {
+    return v(a) === h3;
   };
-  reactIs_production_min.isContextProvider = function(a2) {
-    return v(a2) === g;
+  reactIs_production_min.isContextProvider = function(a) {
+    return v(a) === g2;
   };
-  reactIs_production_min.isElement = function(a2) {
-    return "object" === typeof a2 && null !== a2 && a2.$$typeof === b2;
+  reactIs_production_min.isElement = function(a) {
+    return "object" === typeof a && null !== a && a.$$typeof === b2;
   };
-  reactIs_production_min.isForwardRef = function(a2) {
-    return v(a2) === l;
+  reactIs_production_min.isForwardRef = function(a) {
+    return v(a) === l;
   };
-  reactIs_production_min.isFragment = function(a2) {
-    return v(a2) === d2;
+  reactIs_production_min.isFragment = function(a) {
+    return v(a) === d2;
   };
-  reactIs_production_min.isLazy = function(a2) {
-    return v(a2) === q;
+  reactIs_production_min.isLazy = function(a) {
+    return v(a) === q;
   };
-  reactIs_production_min.isMemo = function(a2) {
-    return v(a2) === p;
+  reactIs_production_min.isMemo = function(a) {
+    return v(a) === p2;
   };
-  reactIs_production_min.isPortal = function(a2) {
-    return v(a2) === c;
+  reactIs_production_min.isPortal = function(a) {
+    return v(a) === c2;
   };
-  reactIs_production_min.isProfiler = function(a2) {
-    return v(a2) === f;
+  reactIs_production_min.isProfiler = function(a) {
+    return v(a) === f;
   };
-  reactIs_production_min.isStrictMode = function(a2) {
-    return v(a2) === e;
+  reactIs_production_min.isStrictMode = function(a) {
+    return v(a) === e2;
   };
-  reactIs_production_min.isSuspense = function(a2) {
-    return v(a2) === m2;
+  reactIs_production_min.isSuspense = function(a) {
+    return v(a) === m2;
   };
-  reactIs_production_min.isSuspenseList = function(a2) {
-    return v(a2) === n3;
+  reactIs_production_min.isSuspenseList = function(a) {
+    return v(a) === n2;
   };
-  reactIs_production_min.isValidElementType = function(a2) {
-    return "string" === typeof a2 || "function" === typeof a2 || a2 === d2 || a2 === f || a2 === e || a2 === m2 || a2 === n3 || a2 === t2 || "object" === typeof a2 && null !== a2 && (a2.$$typeof === q || a2.$$typeof === p || a2.$$typeof === g || a2.$$typeof === h || a2.$$typeof === l || a2.$$typeof === u || void 0 !== a2.getModuleId) ? true : false;
+  reactIs_production_min.isValidElementType = function(a) {
+    return "string" === typeof a || "function" === typeof a || a === d2 || a === f || a === e2 || a === m2 || a === n2 || a === t3 || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p2 || a.$$typeof === g2 || a.$$typeof === h3 || a.$$typeof === l || a.$$typeof === u2 || void 0 !== a.getModuleId) ? true : false;
   };
   reactIs_production_min.typeOf = v;
   return reactIs_production_min;
 }
+var reactIs_development = {};
+var hasRequiredReactIs_development;
+function requireReactIs_development() {
+  if (hasRequiredReactIs_development) return reactIs_development;
+  hasRequiredReactIs_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      var REACT_ELEMENT_TYPE = Symbol.for("react.element");
+      var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+      var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+      var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
+      var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+      var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
+      var REACT_CONTEXT_TYPE = Symbol.for("react.context");
+      var REACT_SERVER_CONTEXT_TYPE = Symbol.for("react.server_context");
+      var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+      var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
+      var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
+      var REACT_MEMO_TYPE = Symbol.for("react.memo");
+      var REACT_LAZY_TYPE = Symbol.for("react.lazy");
+      var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
+      var enableScopeAPI = false;
+      var enableCacheElement = false;
+      var enableTransitionTracing = false;
+      var enableLegacyHidden = false;
+      var enableDebugTracing = false;
+      var REACT_MODULE_REFERENCE;
+      {
+        REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
+      }
+      function isValidElementType(type3) {
+        if (typeof type3 === "string" || typeof type3 === "function") {
+          return true;
+        }
+        if (type3 === REACT_FRAGMENT_TYPE || type3 === REACT_PROFILER_TYPE || enableDebugTracing || type3 === REACT_STRICT_MODE_TYPE || type3 === REACT_SUSPENSE_TYPE || type3 === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type3 === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+          return true;
+        }
+        if (typeof type3 === "object" && type3 !== null) {
+          if (type3.$$typeof === REACT_LAZY_TYPE || type3.$$typeof === REACT_MEMO_TYPE || type3.$$typeof === REACT_PROVIDER_TYPE || type3.$$typeof === REACT_CONTEXT_TYPE || type3.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+          // types supported by any Flight configuration anywhere since
+          // we don't know which Flight build this will end up being used
+          // with.
+          type3.$$typeof === REACT_MODULE_REFERENCE || type3.getModuleId !== void 0) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function typeOf2(object2) {
+        if (typeof object2 === "object" && object2 !== null) {
+          var $$typeof = object2.$$typeof;
+          switch ($$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var type3 = object2.type;
+              switch (type3) {
+                case REACT_FRAGMENT_TYPE:
+                case REACT_PROFILER_TYPE:
+                case REACT_STRICT_MODE_TYPE:
+                case REACT_SUSPENSE_TYPE:
+                case REACT_SUSPENSE_LIST_TYPE:
+                  return type3;
+                default:
+                  var $$typeofType = type3 && type3.$$typeof;
+                  switch ($$typeofType) {
+                    case REACT_SERVER_CONTEXT_TYPE:
+                    case REACT_CONTEXT_TYPE:
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_LAZY_TYPE:
+                    case REACT_MEMO_TYPE:
+                    case REACT_PROVIDER_TYPE:
+                      return $$typeofType;
+                    default:
+                      return $$typeof;
+                  }
+              }
+            case REACT_PORTAL_TYPE:
+              return $$typeof;
+          }
+        }
+        return void 0;
+      }
+      var ContextConsumer = REACT_CONTEXT_TYPE;
+      var ContextProvider = REACT_PROVIDER_TYPE;
+      var Element2 = REACT_ELEMENT_TYPE;
+      var ForwardRef = REACT_FORWARD_REF_TYPE;
+      var Fragment = REACT_FRAGMENT_TYPE;
+      var Lazy = REACT_LAZY_TYPE;
+      var Memo = REACT_MEMO_TYPE;
+      var Portal = REACT_PORTAL_TYPE;
+      var Profiler = REACT_PROFILER_TYPE;
+      var StrictMode = REACT_STRICT_MODE_TYPE;
+      var Suspense = REACT_SUSPENSE_TYPE;
+      var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+      var hasWarnedAboutDeprecatedIsAsyncMode = false;
+      var hasWarnedAboutDeprecatedIsConcurrentMode = false;
+      function isAsyncMode(object2) {
+        {
+          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+            hasWarnedAboutDeprecatedIsAsyncMode = true;
+            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
+          }
+        }
+        return false;
+      }
+      function isConcurrentMode(object2) {
+        {
+          if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+            hasWarnedAboutDeprecatedIsConcurrentMode = true;
+            console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
+          }
+        }
+        return false;
+      }
+      function isContextConsumer(object2) {
+        return typeOf2(object2) === REACT_CONTEXT_TYPE;
+      }
+      function isContextProvider(object2) {
+        return typeOf2(object2) === REACT_PROVIDER_TYPE;
+      }
+      function isElement(object2) {
+        return typeof object2 === "object" && object2 !== null && object2.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function isForwardRef(object2) {
+        return typeOf2(object2) === REACT_FORWARD_REF_TYPE;
+      }
+      function isFragment(object2) {
+        return typeOf2(object2) === REACT_FRAGMENT_TYPE;
+      }
+      function isLazy(object2) {
+        return typeOf2(object2) === REACT_LAZY_TYPE;
+      }
+      function isMemo(object2) {
+        return typeOf2(object2) === REACT_MEMO_TYPE;
+      }
+      function isPortal(object2) {
+        return typeOf2(object2) === REACT_PORTAL_TYPE;
+      }
+      function isProfiler(object2) {
+        return typeOf2(object2) === REACT_PROFILER_TYPE;
+      }
+      function isStrictMode(object2) {
+        return typeOf2(object2) === REACT_STRICT_MODE_TYPE;
+      }
+      function isSuspense(object2) {
+        return typeOf2(object2) === REACT_SUSPENSE_TYPE;
+      }
+      function isSuspenseList(object2) {
+        return typeOf2(object2) === REACT_SUSPENSE_LIST_TYPE;
+      }
+      reactIs_development.ContextConsumer = ContextConsumer;
+      reactIs_development.ContextProvider = ContextProvider;
+      reactIs_development.Element = Element2;
+      reactIs_development.ForwardRef = ForwardRef;
+      reactIs_development.Fragment = Fragment;
+      reactIs_development.Lazy = Lazy;
+      reactIs_development.Memo = Memo;
+      reactIs_development.Portal = Portal;
+      reactIs_development.Profiler = Profiler;
+      reactIs_development.StrictMode = StrictMode;
+      reactIs_development.Suspense = Suspense;
+      reactIs_development.SuspenseList = SuspenseList;
+      reactIs_development.isAsyncMode = isAsyncMode;
+      reactIs_development.isConcurrentMode = isConcurrentMode;
+      reactIs_development.isContextConsumer = isContextConsumer;
+      reactIs_development.isContextProvider = isContextProvider;
+      reactIs_development.isElement = isElement;
+      reactIs_development.isForwardRef = isForwardRef;
+      reactIs_development.isFragment = isFragment;
+      reactIs_development.isLazy = isLazy;
+      reactIs_development.isMemo = isMemo;
+      reactIs_development.isPortal = isPortal;
+      reactIs_development.isProfiler = isProfiler;
+      reactIs_development.isStrictMode = isStrictMode;
+      reactIs_development.isSuspense = isSuspense;
+      reactIs_development.isSuspenseList = isSuspenseList;
+      reactIs_development.isValidElementType = isValidElementType;
+      reactIs_development.typeOf = typeOf2;
+    })();
+  }
+  return reactIs_development;
+}
 var hasRequiredReactIs;
 function requireReactIs() {
   if (hasRequiredReactIs) return reactIs.exports;
   hasRequiredReactIs = 1;
-  reactIs.exports = requireReactIs_production_min();
+  if (process.env.NODE_ENV === "production") {
+    reactIs.exports = requireReactIs_production_min();
+  } else {
+    reactIs.exports = requireReactIs_development();
+  }
   return reactIs.exports;
 }
 var reactIsExports = requireReactIs();
-var ReactIs18 = /* @__PURE__ */ _mergeNamespaces$1({
+var index = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports);
+var ReactIs18 = /* @__PURE__ */ _mergeNamespaces({
   __proto__: null,
-  default: /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports)
+  default: index
 }, [reactIsExports]);
 var ReactIs = Object.fromEntries([
   "isAsyncMode",
@@ -2744,7 +3028,7 @@ function printFunction(val, printFunctionName2) {
   return `[Function ${val.name || "anonymous"}]`;
 }
 function printSymbol(val) {
-  return String(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+  return Symbol.prototype.toString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
 }
 function printError(val) {
   return `[${errorToString.call(val)}]`;
@@ -2842,7 +3126,7 @@ function findPlugin(plugins2, val) {
   return null;
 }
 function printer(val, config2, indentation, depth, refs, hasCalledToJSON) {
-  var _a2;
+  var _a;
   let result;
   const plugin3 = findPlugin(config2.plugins, val);
   if (plugin3 !== null) result = printPlugin(plugin3, val, config2, indentation, depth, refs);
@@ -2851,7 +3135,7 @@ function printer(val, config2, indentation, depth, refs, hasCalledToJSON) {
     if (basicResult !== null) result = basicResult;
     else result = printComplexValue(val, config2, indentation, depth, refs, hasCalledToJSON);
   }
-  (_a2 = config2._outputLengthPerDepth)[depth] ?? (_a2[depth] = 0);
+  (_a = config2._outputLengthPerDepth)[depth] ?? (_a[depth] = 0);
   config2._outputLengthPerDepth[depth] += result.length;
   if (config2._outputLengthPerDepth[depth] > config2.maxOutputLength) config2.maxDepth = 0;
   return result;
@@ -2894,7 +3178,7 @@ function validateOptions(options) {
 function getColorsHighlight() {
   return DEFAULT_THEME_KEYS.reduce((colors, key) => {
     const value = DEFAULT_THEME[key];
-    const color = value && y[value];
+    const color = value && $[value];
     if (color && typeof color.close === "string" && typeof color.open === "string") colors[key] = color;
     else throw new Error(`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`);
     return colors;
@@ -2963,7 +3247,7 @@ var plugins = {
   Error: ErrorPlugin
 };
 
-// node_modules/vitest/dist/chunks/display.pkpxlVcY.js
+// ../../node_modules/vitest/dist/chunks/display.BlTmubjj.js
 var { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
 var PLUGINS = [
   ReactTestComponent,
@@ -3149,7 +3433,7 @@ function isHighSurrogate(char) {
   return char >= "\uD800" && char <= "\uDBFF";
 }
 
-// node_modules/vitest/dist/chunks/pathe.M-eThtNZ.DwEga6ro.js
+// ../../node_modules/vitest/dist/chunks/pathe.M-eThtNZ.Ba-7h1rE.js
 var KNOWN_ASSET_TYPES = [
   "apng",
   "bmp",
@@ -3184,7 +3468,7 @@ function createSimpleStackTrace(options) {
   const limit = Error.stackTraceLimit;
   const prepareStackTrace = Error.prepareStackTrace;
   Error.stackTraceLimit = stackTraceLimit;
-  Error.prepareStackTrace = (e) => e.stack;
+  Error.prepareStackTrace = (e2) => e2.stack;
   const stackTrace = new Error(message).stack || "";
   Error.prepareStackTrace = prepareStackTrace;
   Error.stackTraceLimit = limit;
@@ -3207,11 +3491,13 @@ function filterOutComments(s) {
     if (s[i3] === "\n") commentState = "none";
   } else if (commentState === "multiline") {
     if (s[i3 - 1] === "*" && s[i3] === "/") commentState = "none";
-  } else if (commentState === "none") if (s[i3] === "/" && s[i3 + 1] === "/") commentState = "singleline";
-  else if (s[i3] === "/" && s[i3 + 1] === "*") {
-    commentState = "multiline";
-    i3 += 2;
-  } else result.push(s[i3]);
+  } else if (commentState === "none") {
+    if (s[i3] === "/" && s[i3 + 1] === "/") commentState = "singleline";
+    else if (s[i3] === "/" && s[i3 + 1] === "*") {
+      commentState = "multiline";
+      i3 += 2;
+    } else result.push(s[i3]);
+  }
   return result.join("");
 }
 function toArray(array2) {
@@ -3286,8 +3572,8 @@ function noop() {
 function objectAttr(source, path, defaultValue = void 0) {
   const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
   let result = source;
-  for (const p of paths) {
-    result = new Object(result)[p];
+  for (const p2 of paths) {
+    result = new Object(result)[p2];
     if (result === void 0) return defaultValue;
   }
   return result;
@@ -3295,13 +3581,13 @@ function objectAttr(source, path, defaultValue = void 0) {
 function createDefer() {
   let resolve2 = null;
   let reject = null;
-  const p = new Promise((_resolve, _reject) => {
+  const p2 = new Promise((_resolve, _reject) => {
     resolve2 = _resolve;
     reject = _reject;
   });
-  p.resolve = resolve2;
-  p.reject = reject;
-  return p;
+  p2.resolve = resolve2;
+  p2.reject = reject;
+  return p2;
 }
 function getCallLastIndex(code) {
   let charIndex = -1;
@@ -3347,7 +3633,7 @@ function normalizeWindowsPath(input = "") {
   if (!input) {
     return input;
   }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r2) => r2.toUpperCase());
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
 var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 function cwd() {
@@ -3360,8 +3646,8 @@ var resolve = function(...arguments_) {
   arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
   let resolvedPath = "";
   let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
+  for (let index2 = arguments_.length - 1; index2 >= -1 && !resolvedAbsolute; index2--) {
+    const path = index2 >= 0 ? arguments_[index2] : cwd();
     if (!path || path.length === 0) {
       continue;
     }
@@ -3380,16 +3666,16 @@ function normalizeString(path, allowAboveRoot) {
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
+  for (let index2 = 0; index2 <= path.length; ++index2) {
+    if (index2 < path.length) {
+      char = path[index2];
     } else if (char === "/") {
       break;
     } else {
       char = "/";
     }
     if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ;
+      if (lastSlash === index2 - 1 || dots === 1) ;
       else if (dots === 2) {
         if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
           if (res.length > 2) {
@@ -3401,13 +3687,13 @@ function normalizeString(path, allowAboveRoot) {
               res = res.slice(0, lastSlashIndex);
               lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
             }
-            lastSlash = index;
+            lastSlash = index2;
             dots = 0;
             continue;
           } else if (res.length > 0) {
             res = "";
             lastSegmentLength = 0;
-            lastSlash = index;
+            lastSlash = index2;
             dots = 0;
             continue;
           }
@@ -3418,13 +3704,13 @@ function normalizeString(path, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
+          res += `/${path.slice(lastSlash + 1, index2)}`;
         } else {
-          res = path.slice(lastSlash + 1, index);
+          res = path.slice(lastSlash + 1, index2);
         }
-        lastSegmentLength = index - lastSlash - 1;
+        lastSegmentLength = index2 - lastSlash - 1;
       }
-      lastSlash = index;
+      lastSlash = index2;
       dots = 0;
     } else if (char === "." && dots !== -1) {
       ++dots;
@@ -3434,15 +3720,11 @@ function normalizeString(path, allowAboveRoot) {
   }
   return res;
 }
-var isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
+var isAbsolute = function(p2) {
+  return _IS_ABSOLUTE_RE.test(p2);
 };
 
-// node_modules/vitest/dist/chunks/source-map.BH0bbrs9.js
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs2(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
+// ../../node_modules/vitest/dist/chunks/source-map.DdKI5IHB.js
 var build = {};
 var hasRequiredBuild;
 function requireBuild() {
@@ -3925,7 +4207,7 @@ function requireBuild() {
   return build;
 }
 var buildExports = requireBuild();
-var diffSequences = /* @__PURE__ */ getDefaultExportFromCjs2(buildExports);
+var diffSequences = /* @__PURE__ */ getDefaultExportFromCjs(buildExports);
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
 function isImmutable(v) {
@@ -3962,9 +4244,9 @@ function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
   if (Array.isArray(val)) {
     const clone2 = new Array(val.length);
     seen.set(val, clone2);
-    val.forEach((e, i3) => {
+    val.forEach((e2, i3) => {
       try {
-        clone2[i3] = serializeValue(e, seen);
+        clone2[i3] = serializeValue(e2, seen);
       } catch (err) {
         clone2[i3] = getUnserializableMessage(err);
       }
@@ -4022,17 +4304,17 @@ var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar = new Uint8Array(64);
 var charToInt = new Uint8Array(128);
 for (let i3 = 0; i3 < chars.length; i3++) {
-  const c = chars.charCodeAt(i3);
-  intToChar[i3] = c;
-  charToInt[c] = i3;
+  const c2 = chars.charCodeAt(i3);
+  intToChar[i3] = c2;
+  charToInt[c2] = i3;
 }
 function decodeInteger(reader, relative2) {
   let value = 0;
   let shift = 0;
   let integer = 0;
   do {
-    const c = reader.next();
-    integer = charToInt[c];
+    const c2 = reader.next();
+    integer = charToInt[c2];
     value |= (integer & 31) << shift;
     shift += 5;
   } while (integer & 32);
@@ -4109,8 +4391,8 @@ function decode(mappings) {
 function sort(line) {
   line.sort(sortComparator$1);
 }
-function sortComparator$1(a2, b2) {
-  return a2[0] - b2[0];
+function sortComparator$1(a, b2) {
+  return a[0] - b2[0];
 }
 var COLUMN = 0;
 var SOURCES_INDEX = 1;
@@ -4135,17 +4417,17 @@ function binarySearch2(haystack, needle, low, high) {
   found = false;
   return low - 1;
 }
-function upperBound(haystack, needle, index) {
-  for (let i3 = index + 1; i3 < haystack.length; index = i3++) {
+function upperBound(haystack, needle, index2) {
+  for (let i3 = index2 + 1; i3 < haystack.length; index2 = i3++) {
     if (haystack[i3][COLUMN] !== needle) break;
   }
-  return index;
+  return index2;
 }
-function lowerBound(haystack, needle, index) {
-  for (let i3 = index - 1; i3 >= 0; index = i3--) {
+function lowerBound(haystack, needle, index2) {
+  for (let i3 = index2 - 1; i3 >= 0; index2 = i3--) {
     if (haystack[i3][COLUMN] !== needle) break;
   }
-  return index;
+  return index2;
 }
 function memoizedBinarySearch(haystack, needle, state, key) {
   const { lastKey, lastNeedle, lastIndex } = state;
@@ -4174,8 +4456,8 @@ function cast(map2) {
   return map2;
 }
 function decodedMappings(map2) {
-  var _a2;
-  return (_a2 = cast(map2))._decoded || (_a2._decoded = decode(cast(map2)._encoded));
+  var _a;
+  return (_a = cast(map2))._decoded || (_a._decoded = decode(cast(map2)._encoded));
 }
 function originalPositionFor(map2, needle) {
   let { line, column, bias } = needle;
@@ -4185,15 +4467,15 @@ function originalPositionFor(map2, needle) {
   const decoded = decodedMappings(map2);
   if (line >= decoded.length) return OMapping(null, null, null, null);
   const segments = decoded[line];
-  const index = traceSegmentInternal(
+  const index2 = traceSegmentInternal(
     segments,
     cast(map2)._decodedMemo,
     line,
     column,
     bias || GREATEST_LOWER_BOUND
   );
-  if (index === -1) return OMapping(null, null, null, null);
-  const segment = segments[index];
+  if (index2 === -1) return OMapping(null, null, null, null);
+  const segment = segments[index2];
   if (segment.length === 1) return OMapping(null, null, null, null);
   const { names, resolvedSources } = map2;
   return OMapping(
@@ -4207,12 +4489,12 @@ function OMapping(source, line, column, name) {
   return { source, line, column, name };
 }
 function traceSegmentInternal(segments, memo2, line, column, bias) {
-  let index = memoizedBinarySearch(segments, column, memo2, line);
+  let index2 = memoizedBinarySearch(segments, column, memo2, line);
   if (found) {
-    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
-  } else if (bias === LEAST_UPPER_BOUND) index++;
-  if (index === -1 || index === segments.length) return -1;
-  return index;
+    index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
+  } else if (bias === LEAST_UPPER_BOUND) index2++;
+  if (index2 === -1 || index2 === segments.length) return -1;
+  return index2;
 }
 var CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
 var SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
@@ -4254,7 +4536,7 @@ function extractLocation(urlLike) {
     const urlObj = new URL(url);
     urlObj.searchParams.delete("import");
     urlObj.searchParams.delete("browserv");
-    url = urlObj.pathname + urlObj.hash + urlObj.search;
+    url = tryDecode(urlObj.pathname, decodeURI) + urlObj.hash + urlObj.search;
   }
   if (url.startsWith("/@fs/")) {
     const isWindows2 = /^\/@fs\/[a-zA-Z]:\//.test(url);
@@ -4267,6 +4549,13 @@ function extractLocation(urlLike) {
     parts[3] || void 0
   ];
 }
+function tryDecode(value, decode2) {
+  try {
+    return decode2(value);
+  } catch {
+    return value;
+  }
+}
 function parseSingleFFOrSafariStack(raw) {
   let line = raw.trim();
   if (SAFARI_NATIVE_CODE_REGEXP.test(line)) return null;
@@ -4311,7 +4600,8 @@ function parseSingleV8Stack(raw) {
   let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
   if (!file || !lineNumber || !columnNumber) return null;
   if (method.startsWith("async ")) method = method.slice(6);
-  if (file.startsWith("file://")) file = file.slice(7);
+  if (file.startsWith("file://"))
+    file = tryDecode(file.slice(7), decodeURIComponent);
   file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
   if (method) method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
   return {
@@ -4352,7 +4642,7 @@ function parseStacktrace(stack, options = {}) {
   }).filter((s) => s != null);
 }
 function shouldFilter(ignoreStackEntries, file) {
-  return ignoreStackEntries.some((p) => file.match(p));
+  return ignoreStackEntries.some((p2) => file.match(p2));
 }
 function parseFFOrSafariStackTrace(stack) {
   return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
@@ -4360,18 +4650,18 @@ function parseFFOrSafariStackTrace(stack) {
 function parseV8Stacktrace(stack) {
   return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
 }
-function parseErrorStacktrace(e, options = {}) {
-  if (!e || isPrimitive(e)) return [];
-  if ("stacks" in e && e.stacks) return e.stacks;
-  const stackStr = e.stack || "";
+function parseErrorStacktrace(e2, options = {}) {
+  if (!e2 || isPrimitive(e2)) return [];
+  if ("stacks" in e2 && e2.stacks) return e2.stacks;
+  const stackStr = e2.stack || "";
   let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
   if (!stackFrames.length) {
-    const e_ = e;
+    const e_ = e2;
     if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
     if (e_.sourceURL != null && e_.line != null && e_._column != null) stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
   }
-  if (options.frameFilter) stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
-  e.stacks = stackFrames;
+  if (options.frameFilter) stackFrames = stackFrames.filter((f) => options.frameFilter(e2, f) !== false);
+  e2.stacks = stackFrames;
   return stackFrames;
 }
 var DecodedMap = class {
@@ -4407,7 +4697,7 @@ function getOriginalPosition(map2, needle) {
   return result;
 }
 
-// node_modules/vitest/dist/task-utils.js
+// ../../node_modules/vitest/dist/task-utils.js
 // @__NO_SIDE_EFFECTS__
 function getNames(task) {
   const names = [task.name];
@@ -4424,7 +4714,7 @@ function createTaskName(names, separator = " > ") {
   return names.filter((name) => name !== void 0).join(separator);
 }
 
-// node_modules/vitest/dist/chunks/run.C5UmxDPh.js
+// ../../node_modules/vitest/dist/chunks/run.BPv-BBRv.js
 var DIFF_DELETE = -1;
 var DIFF_INSERT = 1;
 var DIFF_EQUAL = 0;
@@ -4741,22 +5031,24 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   while (i3 !== iLength) {
     const iStart = i3;
     while (i3 !== iLength && diffs[i3][0] === DIFF_EQUAL) i3 += 1;
-    if (iStart !== i3) if (iStart === 0) {
-      if (i3 > nContextLines) {
-        jLength -= i3 - nContextLines;
-        hasExcessAtStartOrEnd = true;
-      }
-    } else if (i3 === iLength) {
-      const n3 = i3 - iStart;
-      if (n3 > nContextLines) {
-        jLength -= n3 - nContextLines;
-        hasExcessAtStartOrEnd = true;
-      }
-    } else {
-      const n3 = i3 - iStart;
-      if (n3 > nContextLines2) {
-        jLength -= n3 - nContextLines2;
-        nExcessesBetweenChanges += 1;
+    if (iStart !== i3) {
+      if (iStart === 0) {
+        if (i3 > nContextLines) {
+          jLength -= i3 - nContextLines;
+          hasExcessAtStartOrEnd = true;
+        }
+      } else if (i3 === iLength) {
+        const n2 = i3 - iStart;
+        if (n2 > nContextLines) {
+          jLength -= n2 - nContextLines;
+          hasExcessAtStartOrEnd = true;
+        }
+      } else {
+        const n2 = i3 - iStart;
+        if (n2 > nContextLines2) {
+          jLength -= n2 - nContextLines2;
+          nExcessesBetweenChanges += 1;
+        }
       }
     }
     while (i3 !== iLength && diffs[i3][0] !== DIFF_EQUAL) i3 += 1;
@@ -4792,33 +5084,35 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   while (i3 !== iLength) {
     let iStart = i3;
     while (i3 !== iLength && diffs[i3][0] === DIFF_EQUAL) i3 += 1;
-    if (iStart !== i3) if (iStart === 0) {
-      if (i3 > nContextLines) {
-        iStart = i3 - nContextLines;
-        aStart = iStart;
-        bStart = iStart;
-        aEnd = aStart;
-        bEnd = bStart;
-      }
-      for (let iCommon = iStart; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
-    } else if (i3 === iLength) {
-      const iEnd = i3 - iStart > nContextLines ? iStart + nContextLines : i3;
-      for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
-    } else {
-      const nCommon = i3 - iStart;
-      if (nCommon > nContextLines2) {
-        const iEnd = iStart + nContextLines;
+    if (iStart !== i3) {
+      if (iStart === 0) {
+        if (i3 > nContextLines) {
+          iStart = i3 - nContextLines;
+          aStart = iStart;
+          bStart = iStart;
+          aEnd = aStart;
+          bEnd = bStart;
+        }
+        for (let iCommon = iStart; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+      } else if (i3 === iLength) {
+        const iEnd = i3 - iStart > nContextLines ? iStart + nContextLines : i3;
         for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
-        lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
-        jPatchMark = lines.length;
-        lines.push("");
-        const nOmit = nCommon - nContextLines2;
-        aStart = aEnd + nOmit;
-        bStart = bEnd + nOmit;
-        aEnd = aStart;
-        bEnd = bStart;
-        for (let iCommon = i3 - nContextLines; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
-      } else for (let iCommon = iStart; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+      } else {
+        const nCommon = i3 - iStart;
+        if (nCommon > nContextLines2) {
+          const iEnd = iStart + nContextLines;
+          for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+          lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
+          jPatchMark = lines.length;
+          lines.push("");
+          const nOmit = nCommon - nContextLines2;
+          aStart = aEnd + nOmit;
+          bStart = bEnd + nOmit;
+          aEnd = aStart;
+          bEnd = bStart;
+          for (let iCommon = i3 - nContextLines; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+        } else for (let iCommon = iStart; iCommon !== i3; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+      }
     }
     while (i3 !== iLength && diffs[i3][0] === DIFF_DELETE) {
       pushDeleteLine(diffs[i3][1]);
@@ -4852,14 +5146,14 @@ var DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;
 function getDefaultOptions() {
   return {
     aAnnotation: "Expected",
-    aColor: y.green,
+    aColor: $.green,
     aIndicator: "-",
     bAnnotation: "Received",
-    bColor: y.red,
+    bColor: $.red,
     bIndicator: "+",
-    changeColor: y.inverse,
+    changeColor: $.inverse,
     changeLineTrailingSpaceColor: noColor,
-    commonColor: y.dim,
+    commonColor: $.dim,
     commonIndicator: " ",
     commonLineTrailingSpaceColor: noColor,
     compareKeys: void 0,
@@ -4868,7 +5162,7 @@ function getDefaultOptions() {
     expand: false,
     includeChangeCounts: false,
     omitAnnotationLines: false,
-    patchColor: y.yellow,
+    patchColor: $.yellow,
     printBasicPrototype: false,
     truncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,
     truncateAnnotation: "... Diff result is truncated",
@@ -4893,19 +5187,19 @@ function isEmptyString(lines) {
   return lines.length === 1 && lines[0].length === 0;
 }
 function countChanges(diffs) {
-  let a2 = 0;
+  let a = 0;
   let b2 = 0;
   diffs.forEach((diff2) => {
     switch (diff2[0]) {
       case DIFF_DELETE:
-        a2 += 1;
+        a += 1;
         break;
       case DIFF_INSERT:
         b2 += 1;
     }
   });
   return {
-    a: a2,
+    a,
     b: b2
   };
 }
@@ -4925,9 +5219,9 @@ function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor,
     aRest = `${aAnnotationPadding}  ${aIndicator} ${aCountPadding}${aCount}`;
     bRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;
   }
-  const a2 = `${aIndicator} ${aAnnotation}${aRest}`;
+  const a = `${aIndicator} ${aAnnotation}${aRest}`;
   const b2 = `${bIndicator} ${bAnnotation}${bRest}`;
-  return `${aColor(a2)}
+  return `${aColor(a)}
 ${bColor(b2)}
 
 `;
@@ -5016,37 +5310,37 @@ function getType3(value) {
 function getNewLineSymbol(string2) {
   return string2.includes("\r\n") ? "\r\n" : "\n";
 }
-function diffStrings(a2, b2, options) {
+function diffStrings(a, b2, options) {
   const truncate2 = options?.truncateThreshold ?? false;
   const truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);
-  let aLength = a2.length;
+  let aLength = a.length;
   let bLength = b2.length;
   if (truncate2) {
-    const aMultipleLines = a2.includes("\n");
+    const aMultipleLines = a.includes("\n");
     const bMultipleLines = b2.includes("\n");
-    const aNewLineSymbol = getNewLineSymbol(a2);
+    const aNewLineSymbol = getNewLineSymbol(a);
     const bNewLineSymbol = getNewLineSymbol(b2);
-    const _a2 = aMultipleLines ? `${a2.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
-` : a2;
+    const _a = aMultipleLines ? `${a.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
+` : a;
     const _b = bMultipleLines ? `${b2.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
 ` : b2;
-    aLength = _a2.length;
+    aLength = _a.length;
     bLength = _b.length;
   }
-  const truncated = aLength !== a2.length || bLength !== b2.length;
-  const isCommon = (aIndex2, bIndex2) => a2[aIndex2] === b2[bIndex2];
+  const truncated = aLength !== a.length || bLength !== b2.length;
+  const isCommon = (aIndex2, bIndex2) => a[aIndex2] === b2[bIndex2];
   let aIndex = 0;
   let bIndex = 0;
   const diffs = [];
   const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    if (aIndex !== aCommon) diffs.push(new Diff(DIFF_DELETE, a2.slice(aIndex, aCommon)));
+    if (aIndex !== aCommon) diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex, aCommon)));
     if (bIndex !== bCommon) diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex, bCommon)));
     aIndex = aCommon + nCommon;
     bIndex = bCommon + nCommon;
     diffs.push(new Diff(DIFF_EQUAL, b2.slice(bCommon, bIndex)));
   };
   diffSequences(aLength, bLength, isCommon, foundSubsequence);
-  if (aIndex !== aLength) diffs.push(new Diff(DIFF_DELETE, a2.slice(aIndex)));
+  if (aIndex !== aLength) diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
   if (bIndex !== bLength) diffs.push(new Diff(DIFF_INSERT, b2.slice(bIndex)));
   return [diffs, truncated];
 }
@@ -5178,11 +5472,11 @@ function hasCommonDiff(diffs, isMultiline) {
   }
   return diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
 }
-function diffStringsUnified(a2, b2, options) {
-  if (a2 !== b2 && a2.length !== 0 && b2.length !== 0) {
-    const isMultiline = a2.includes("\n") || b2.includes("\n");
-    const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a2}
-` : a2, isMultiline ? `${b2}
+function diffStringsUnified(a, b2, options) {
+  if (a !== b2 && a.length !== 0 && b2.length !== 0) {
+    const isMultiline = a.includes("\n") || b2.includes("\n");
+    const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a}
+` : a, isMultiline ? `${b2}
 ` : b2, true, options);
     if (hasCommonDiff(diffs, isMultiline)) {
       const optionsNormalized = normalizeDiffOptions(options);
@@ -5190,10 +5484,10 @@ function diffStringsUnified(a2, b2, options) {
       return printDiffLines(lines, truncated, optionsNormalized);
     }
   }
-  return diffLinesUnified(a2.split("\n"), b2.split("\n"), options);
+  return diffLinesUnified(a.split("\n"), b2.split("\n"), options);
 }
-function diffStringsRaw(a2, b2, cleanup, options) {
-  const [diffs, truncated] = diffStrings(a2, b2, options);
+function diffStringsRaw(a, b2, cleanup, options) {
+  const [diffs, truncated] = diffStrings(a, b2, options);
   diff_cleanupSemantic(diffs);
   return [diffs, truncated];
 }
@@ -5220,18 +5514,18 @@ var FALLBACK_FORMAT_OPTIONS = {
   maxDepth: 8,
   plugins: PLUGINS2
 };
-var DEFAULT_MEMORIZE = (_, v) => v;
-function diff(a2, b2, options, memorize = DEFAULT_MEMORIZE) {
-  if (Object.is(a2, b2)) return "";
-  const aType = getType3(a2);
+var DEFAULT_MEMORIZE = (_2, v) => v;
+function diff(a, b2, options, memorize = DEFAULT_MEMORIZE) {
+  if (Object.is(a, b2)) return "";
+  const aType = getType3(a);
   let expectedType = aType;
   let omitDifference = false;
-  if (aType === "object" && typeof a2.asymmetricMatch === "function") {
-    if (a2.$$typeof !== Symbol.for("jest.asymmetricMatcher"))
+  if (aType === "object" && typeof a.asymmetricMatch === "function") {
+    if (a.$$typeof !== Symbol.for("jest.asymmetricMatcher"))
       return;
-    if (typeof a2.getExpectedType !== "function")
+    if (typeof a.getExpectedType !== "function")
       return;
-    expectedType = a2.getExpectedType();
+    expectedType = a.getExpectedType();
     omitDifference = expectedType === "string";
   }
   if (expectedType !== getType3(b2)) {
@@ -5241,7 +5535,7 @@ function diff(a2, b2, options, memorize = DEFAULT_MEMORIZE) {
     var truncate2 = truncate3;
     const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    let aDisplay = format(a2, formatOptions);
+    let aDisplay = format(a, formatOptions);
     let bDisplay = format(b2, formatOptions);
     const MAX_LENGTH = 1e5;
     aDisplay = memorize("expected", truncate3(aDisplay));
@@ -5255,16 +5549,16 @@ ${bDisplay}`}`;
   if (omitDifference) return;
   switch (aType) {
     case "string":
-      return diffLinesUnified(a2.split("\n"), b2.split("\n"), options);
+      return diffLinesUnified(a.split("\n"), b2.split("\n"), options);
     case "boolean":
     case "number":
-      return comparePrimitive(a2, b2, options, memorize);
+      return comparePrimitive(a, b2, options, memorize);
     case "map":
-      return compareObjects(sortMap(a2), sortMap(b2), options, memorize);
+      return compareObjects(sortMap(a), sortMap(b2), options, memorize);
     case "set":
-      return compareObjects(sortSet(a2), sortSet(b2), options, memorize);
+      return compareObjects(sortSet(a), sortSet(b2), options, memorize);
     default:
-      return compareObjects(a2, b2, options, memorize);
+      return compareObjects(a, b2, options, memorize);
   }
 }
 function createMemorize(memory) {
@@ -5273,8 +5567,8 @@ function createMemorize(memory) {
     return stringifiedValue;
   };
 }
-function comparePrimitive(a2, b2, options, memorize = DEFAULT_MEMORIZE) {
-  const aFormat = memorize("expected", format(a2, FORMAT_OPTIONS));
+function comparePrimitive(a, b2, options, memorize = DEFAULT_MEMORIZE) {
+  const aFormat = memorize("expected", format(a, FORMAT_OPTIONS));
   const bFormat = memorize("actual", format(b2, FORMAT_OPTIONS));
   return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
 }
@@ -5284,17 +5578,17 @@ function sortMap(map2) {
 function sortSet(set3) {
   return new Set(Array.from(set3.values()).sort());
 }
-function compareObjects(a2, b2, options, memorize = DEFAULT_MEMORIZE) {
+function compareObjects(a, b2, options, memorize = DEFAULT_MEMORIZE) {
   let difference;
   let hasThrown = false;
   try {
-    difference = getObjectsDifference(a2, b2, getFormatOptions(FORMAT_OPTIONS, options), options, memorize);
+    difference = getObjectsDifference(a, b2, getFormatOptions(FORMAT_OPTIONS, options), options, memorize);
   } catch {
     hasThrown = true;
   }
   const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
   if (difference === void 0 || difference === noDiffMessage) {
-    difference = getObjectsDifference(a2, b2, getFormatOptions(FALLBACK_FORMAT_OPTIONS, options), options, memorize);
+    difference = getObjectsDifference(a, b2, getFormatOptions(FALLBACK_FORMAT_OPTIONS, options), options, memorize);
     if (difference !== noDiffMessage && !hasThrown) difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
 
 ${difference}`;
@@ -5313,16 +5607,16 @@ function getFormatOptions(formatOptions, options) {
     maxDepth: maxDepth ?? formatOptions.maxDepth
   };
 }
-function getObjectsDifference(a2, b2, formatOptions, options, memorize = DEFAULT_MEMORIZE) {
+function getObjectsDifference(a, b2, formatOptions, options, memorize = DEFAULT_MEMORIZE) {
   const formatOptionsZeroIndent = {
     ...formatOptions,
     indent: 0
   };
-  const aCompare = format(a2, formatOptionsZeroIndent);
+  const aCompare = format(a, formatOptionsZeroIndent);
   const bCompare = format(b2, formatOptionsZeroIndent);
   if (aCompare === bCompare) return getCommonMessage(NO_DIFF_MESSAGE, options);
   else {
-    const aDisplay = memorize("expected", format(a2, formatOptions));
+    const aDisplay = memorize("expected", format(a, formatOptions));
     const bDisplay = memorize("actual", format(b2, formatOptions));
     return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
   }
@@ -5405,13 +5699,13 @@ function replaceTrailingSpaces(text) {
   return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
 }
 function printReceived(object2) {
-  return y.red(replaceTrailingSpaces(stringify(object2)));
+  return $.red(replaceTrailingSpaces(stringify(object2)));
 }
 function printExpected(value) {
-  return y.green(replaceTrailingSpaces(stringify(value)));
+  return $.green(replaceTrailingSpaces(stringify(value)));
 }
 function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
-  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? y.inverse(diff2[1]) : diff2[1] : ""), "");
+  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? $.inverse(diff2[1]) : diff2[1] : ""), "");
 }
 function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
   if (!_err || typeof _err !== "object") return { message: String(_err) };
@@ -5434,8 +5728,8 @@ function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
   }
   try {
     return serializeValue(err);
-  } catch (e) {
-    return serializeValue(/* @__PURE__ */ new Error(`Failed to fully serialize error: ${e?.message}
+  } catch (e2) {
+    return serializeValue(/* @__PURE__ */ new Error(`Failed to fully serialize error: ${e2?.message}
 Inner error message: ${err?.message}`));
   }
 }
@@ -5685,8 +5979,12 @@ function withFixtures(fn2, options) {
     for (const fixture of pendingFixtures) if (fixture.scope === "test") {
       if (cachedFixtures.has(fixture)) continue;
       cachedFixtures.add(fixture);
-      const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
-      context[fixture.name] = resolvedValue;
+      try {
+        context[fixture.name] = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+      } catch (error) {
+        cachedFixtures.delete(fixture);
+        throw error;
+      }
       cleanupFnArray.push(() => {
         cachedFixtures.delete(fixture);
       });
@@ -5727,8 +6025,9 @@ async function resolveScopeFixtureValue(fixtures, suite2, fixture) {
     ...fileContext
   } : fixtureContext, cleanupFnFileArray).then((value) => {
     fixtureContext[fixture.name] = value;
-    scopedFixturePromiseCache.delete(fixture);
     return value;
+  }).finally(() => {
+    scopedFixturePromiseCache.delete(fixture);
   });
   scopedFixturePromiseCache.set(fixture, promise);
   return promise;
@@ -5752,12 +6051,12 @@ async function resolveFixtureFunction(fixtureFn, fixtureName, context, cleanupFn
       if (stackTraceError?.stack) error.stack = error.message + stackTraceError.stack.replace(stackTraceError.message, "");
       useFnArgPromise.reject(error);
     }
-  }).catch((e) => {
+  }).catch((e2) => {
     if (!isUseFnArgResolved) {
-      useFnArgPromise.reject(e);
+      useFnArgPromise.reject(e2);
       return;
     }
-    throw e;
+    throw e2;
   });
   return useFnArgPromise;
 }
@@ -5768,10 +6067,12 @@ function resolveDeps(usedFixtures, registrations, depSet = /* @__PURE__ */ new S
       pendingFixtures.push(fixture);
       return;
     }
-    if (depSet.has(fixture)) if (fixture.parent) fixture = fixture.parent;
-    else throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d2) => d2.name).join(" <- ")}`);
+    if (depSet.has(fixture)) {
+      if (fixture.parent) fixture = fixture.parent;
+      else throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d2) => d2.name).join(" <- ")}`);
+    }
     depSet.add(fixture);
-    resolveDeps(Array.from(fixture.deps, (n3) => n3 === fixture.name ? fixture.parent : registrations.get(n3)).filter((n3) => !!n3), registrations, depSet, pendingFixtures);
+    resolveDeps(Array.from(fixture.deps, (n2) => n2 === fixture.name ? fixture.parent : registrations.get(n2)).filter((n2) => !!n2), registrations, depSet, pendingFixtures);
     pendingFixtures.push(fixture);
     depSet.clear();
   });
@@ -5861,6 +6162,10 @@ function createChainable(keys2, fn2, context) {
     Object.defineProperty(chain2, kChainableContext, {
       value: {
         withContext: () => chain2.bind(context2),
+        extendContext: (ctx) => create({
+          ...context2,
+          ...ctx
+        }),
         getFixtures: () => context2.fixtures,
         setContext: (key, value) => {
           context2[key] = value;
@@ -6006,7 +6311,7 @@ function validateTags(config2, tags) {
 function createNoTagsError(availableTags, tag, prefix = "tag") {
   if (!availableTags.length) throw new Error(`The Vitest config doesn't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
   throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:
-${availableTags.map((t2) => `- ${t2.name}${t2.description ? `: ${t2.description}` : ""}`).join("\n")}`);
+${availableTags.map((t3) => `- ${t3.name}${t3.description ? `: ${t3.description}` : ""}`).join("\n")}`);
 }
 var suite = createSuite();
 var test2 = createTest(function(name, optionsOrFn, optionsOrTest) {
@@ -6044,6 +6349,10 @@ function createSuiteHooks() {
   };
 }
 var POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
+function assignDefined(target, source) {
+  for (const key in source) if (source[key] !== void 0) target[key] = source[key];
+  return target;
+}
 function parseArguments(optionsOrFn, timeoutOrTest) {
   if (timeoutOrTest != null && typeof timeoutOrTest === "object") throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
   let options = {};
@@ -6069,21 +6378,21 @@ function createSuiteCollector(name, factory = () => {
     const parentTags = (currentSuite ?? collectorContext.currentSuite?.file)?.tags || [];
     const testTags = unique([...parentTags, ...toArray(options.tags)]);
     const tagsOptions = testTags.map((tag) => {
-      const tagDefinition = runner.config.tags?.find((t2) => t2.name === tag);
+      const tagDefinition = runner.config.tags?.find((t3) => t3.name === tag);
       if (!tagDefinition && runner.config.strictTags) throw createNoTagsError(runner.config.tags, tag);
       return tagDefinition;
-    }).filter((r2) => r2 != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
+    }).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
       const { name: name3, description, priority, meta, ...options2 } = tag;
-      Object.assign(acc, options2);
+      assignDefined(acc, options2);
       if (meta) acc.meta = Object.assign(acc.meta ?? /* @__PURE__ */ Object.create(null), meta);
       return acc;
     }, {});
     const testOwnMeta = options.meta;
-    options = {
-      ...collectorContext.currentSuite?.options,
-      ...tagsOptions,
-      ...options
-    };
+    const parentOptions = collectorContext.currentSuite?.options;
+    options = assignDefined({
+      ...parentOptions,
+      ...tagsOptions
+    }, options);
     const timeout = options.timeout ?? runner.config.testTimeout;
     const parentMeta = currentSuite?.meta;
     const tagMeta = tagsOptions.meta;
@@ -6126,7 +6435,7 @@ function createSuiteCollector(name, factory = () => {
     Error.stackTraceLimit = 10;
     const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
     Error.stackTraceLimit = limit;
-    if (handler) setFn(task2, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task2), task2.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+    if (handler) setFn(task2, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task2), task2.context.signal), timeout, false, stackTraceError, (_2, error) => abortIfTimeout([context], error)));
     if (runner.config.includeTaskLocation) {
       const stack = findTestFileStackTrace(currentTestFilepath, stackTraceError);
       if (stack) task2.location = {
@@ -6142,8 +6451,7 @@ function createSuiteCollector(name, factory = () => {
     const concurrent = this.concurrent ?? options?.concurrent;
     if (concurrent != null) options.concurrent = concurrent;
     const test6 = task(formatName(name2), {
-      ...this,
-      ...options,
+      ...assignDefined({ ...this }, options),
       handler
     });
     test6.type = "test";
@@ -6228,7 +6536,7 @@ function withAwaitAsyncAssertions(fn2, task) {
   return (async (...args) => {
     const fnResult = await fn2(...args);
     if (task.promises) {
-      const errors = (await Promise.allSettled(task.promises)).map((r2) => r2.status === "rejected" ? r2.reason : void 0).filter(Boolean);
+      const errors = (await Promise.allSettled(task.promises)).map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
       if (errors.length) throw errors;
     }
     return fnResult;
@@ -6240,10 +6548,7 @@ function createSuite() {
     const currentSuite = collectorContext.currentSuite || defaultSuite;
     let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
     const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
-    options = {
-      ...parentOptions,
-      ...options
-    };
+    options = assignDefined({ ...parentOptions }, options);
     const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
     if (shuffle != null) options.shuffle = shuffle;
     let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
@@ -6265,9 +6570,10 @@ function createSuite() {
       const fnFirst = typeof optionsOrFn === "function";
       cases.forEach((i3, idx) => {
         const items = Array.isArray(i3) ? i3 : [i3];
-        if (fnFirst) if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
-        else suite2(formatTitle(_name, items, idx), handler ? () => handler(i3) : void 0, options.timeout);
-        else if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+        if (fnFirst) {
+          if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+          else suite2(formatTitle(_name, items, idx), handler ? () => handler(i3) : void 0, options.timeout);
+        } else if (arrayOnlyCases) suite2(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
         else suite2(formatTitle(_name, items, idx), options, handler ? () => handler(i3) : void 0);
       });
       context.setContext("each", void 0);
@@ -6308,9 +6614,10 @@ function createTaskCollector(fn2) {
       const fnFirst = typeof optionsOrFn === "function";
       cases.forEach((i3, idx) => {
         const items = Array.isArray(i3) ? i3 : [i3];
-        if (fnFirst) if (arrayOnlyCases) test5(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
-        else test5(formatTitle(_name, items, idx), handler ? () => handler(i3) : void 0, options.timeout);
-        else if (arrayOnlyCases) test5(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+        if (fnFirst) {
+          if (arrayOnlyCases) test5(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+          else test5(formatTitle(_name, items, idx), handler ? () => handler(i3) : void 0, options.timeout);
+        } else if (arrayOnlyCases) test5(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
         else test5(formatTitle(_name, items, idx), options, handler ? () => handler(i3) : void 0);
       });
       context.setContext("each", void 0);
@@ -6333,10 +6640,10 @@ function createTaskCollector(fn2) {
     };
   };
   taskFn.skipIf = function(condition) {
-    return condition ? this.skip : this;
+    return getChainableContext(this).extendContext({ skip: !!condition });
   };
   taskFn.runIf = function(condition) {
-    return condition ? this : this.skip;
+    return getChainableContext(this).extendContext({ skip: !condition });
   };
   function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
     if (typeof fixturesOrName !== "string") return fixturesOrName;
@@ -6415,7 +6722,7 @@ function formatTitle(template, items, idx) {
   if (template.includes("%#") || template.includes("%$"))
     template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/%\$/g, `${idx + 1}`).replace(/__vitest_escaped_%__/g, "%%");
   const count = template.split("%").length - 1;
-  if (template.includes("%f")) (template.match(/%f/g) || []).forEach((_, i4) => {
+  if (template.includes("%f")) (template.match(/%f/g) || []).forEach((_2, i4) => {
     if (isNegativeNaN(items[i4]) || Object.is(items[i4], -0)) {
       let occurrence = 0;
       template = template.replace(/%f/g, (match) => {
@@ -6427,12 +6734,12 @@ function formatTitle(template, items, idx) {
   const inspectOptions = { truncate: runner.config.taskTitleValueFormatTruncate };
   const isObjectItem = isObject(items[0]);
   function formatAttribute(s) {
-    return s.replace(/\$([$\p{ID_Continue}.]+)/gu, (_, key) => {
+    return s.replace(/\$([$\p{ID_Continue}.]+)/gu, (_2, key) => {
       const isArrayKey = /^\d+$/.test(key);
       if (!isObjectItem && !isArrayKey) return `$${key}`;
       const arrayElement = isArrayKey ? objectAttr(items, key) : void 0;
       const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
-      if (typeof value === "string") return truncateString(value, inspectOptions.truncate);
+      if (typeof value === "string") return inspectOptions.truncate ? truncateString(value, inspectOptions.truncate) : value;
       return inspect(value, inspectOptions);
     });
   }
@@ -6500,27 +6807,27 @@ function encodeUint8Array(bytes) {
   let base64 = "";
   const len = bytes.byteLength;
   for (let i3 = 0; i3 < len; i3 += 3) if (len === i3 + 1) {
-    const a2 = (bytes[i3] & 252) >> 2;
+    const a = (bytes[i3] & 252) >> 2;
     const b2 = (bytes[i3] & 3) << 4;
-    base64 += table[a2];
+    base64 += table[a];
     base64 += table[b2];
     base64 += "==";
   } else if (len === i3 + 2) {
-    const a2 = (bytes[i3] & 252) >> 2;
+    const a = (bytes[i3] & 252) >> 2;
     const b2 = (bytes[i3] & 3) << 4 | (bytes[i3 + 1] & 240) >> 4;
-    const c = (bytes[i3 + 1] & 15) << 2;
-    base64 += table[a2];
+    const c2 = (bytes[i3 + 1] & 15) << 2;
+    base64 += table[a];
     base64 += table[b2];
-    base64 += table[c];
+    base64 += table[c2];
     base64 += "=";
   } else {
-    const a2 = (bytes[i3] & 252) >> 2;
+    const a = (bytes[i3] & 252) >> 2;
     const b2 = (bytes[i3] & 3) << 4 | (bytes[i3 + 1] & 240) >> 4;
-    const c = (bytes[i3 + 1] & 15) << 2 | (bytes[i3 + 2] & 192) >> 6;
+    const c2 = (bytes[i3 + 1] & 15) << 2 | (bytes[i3 + 2] & 192) >> 6;
     const d2 = bytes[i3 + 2] & 63;
-    base64 += table[a2];
+    base64 += table[a];
     base64 += table[b2];
-    base64 += table[c];
+    base64 += table[c2];
     base64 += table[d2];
   }
   return base64;
@@ -6528,8 +6835,8 @@ function encodeUint8Array(bytes) {
 function recordAsyncOperation(test5, promise) {
   promise = promise.finally(() => {
     if (!test5.promises) return;
-    const index = test5.promises.indexOf(promise);
-    if (index !== -1) test5.promises.splice(index, 1);
+    const index2 = test5.promises.indexOf(promise);
+    if (index2 !== -1) test5.promises.splice(index2, 1);
   });
   if (!test5.promises) test5.promises = [];
   test5.promises.push(promise);
@@ -6615,7 +6922,7 @@ async function runWithSuite(suite2, fn2) {
 }
 function withTimeout(fn2, timeout, isHook = false, stackTraceError, onTimeout) {
   if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) return fn2;
-  return (function runWithTimeout(...args) {
+  return function runWithTimeout(...args) {
     const runner2 = getRunner();
     const previousDeadline = runner2._deadline;
     return new Promise((resolve_, reject_) => {
@@ -6661,10 +6968,10 @@ function withTimeout(fn2, timeout, isHook = false, stackTraceError, onTimeout) {
         reject(error);
       }
     });
-  });
+  };
 }
 function withCancel(fn2, signal) {
-  return (function runWithCancel(...args) {
+  return function runWithCancel(...args) {
     return new Promise((resolve2, reject) => {
       const onAbort = () => reject(signal.reason);
       signal.addEventListener("abort", onAbort, { once: true });
@@ -6687,7 +6994,7 @@ function withCancel(fn2, signal) {
         reject(error);
       }
     });
-  });
+  };
 }
 var abortControllers = /* @__PURE__ */ new WeakMap();
 function abortIfTimeout([context], error) {
@@ -6738,11 +7045,11 @@ function createTestContext(test5, runner2) {
   });
   context.onTestFailed = (handler, timeout) => {
     test5.onFailed || (test5.onFailed = []);
-    test5.onFailed.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+    test5.onFailed.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_2, error) => abortController.abort(error)));
   };
   context.onTestFinished = (handler, timeout) => {
     test5.onFinished || (test5.onFinished = []);
-    test5.onFinished.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+    test5.onFinished.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_2, error) => abortController.abort(error)));
   };
   return runner2.extendTaskContext?.(context) || context;
 }
@@ -6772,10 +7079,10 @@ function sendTasksUpdate(runner2) {
         task[1]
       ];
     });
-    const p = runner2.onTaskUpdate?.(taskPacks, eventsPacks);
-    if (p) {
-      pendingTasksUpdates.push(p);
-      p.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p), 1), () => {
+    const p2 = runner2.onTaskUpdate?.(taskPacks, eventsPacks);
+    if (p2) {
+      pendingTasksUpdates.push(p2);
+      p2.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p2), 1), () => {
       });
     }
     eventsPacks.length = 0;
@@ -6802,7 +7109,7 @@ function throttle(fn2, ms) {
 }
 var sendTasksUpdateThrottled = throttle(sendTasksUpdate, 100);
 
-// node_modules/vitest/dist/chunks/utils.DYj33du9.js
+// ../../node_modules/vitest/dist/chunks/utils.DYj33du9.js
 var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
   const workerState = globalThis[NAME_WORKER_STATE];
@@ -6828,19 +7135,41 @@ function resetModules(modules, resetMocks = false) {
   });
 }
 
-// node_modules/vitest/dist/chunks/spy.KLHgXex_.js
+// ../../node_modules/vitest/dist/chunks/spy.DDMXghXv.js
 function isMockFunction(fn2) {
   return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction === true;
 }
 var MOCK_RESTORE = /* @__PURE__ */ new Set();
 var DIRTY_MOCK_STATES = /* @__PURE__ */ new Set();
-var addDirtyMock = DIRTY_MOCK_STATES.add.bind(DIRTY_MOCK_STATES);
-var REGISTERED_MOCKS = /* @__PURE__ */ new Set();
+var DIRTY_MOCK_CONFIGS = /* @__PURE__ */ new Set();
+var addToSet = Set.prototype.add;
+var MOCK_REFS = /* @__PURE__ */ new WeakMap();
 var MOCK_FINALIZER = new FinalizationRegistry((ref) => {
-  REGISTERED_MOCKS.delete(ref);
+  DIRTY_MOCK_STATES.delete(ref);
+  DIRTY_MOCK_CONFIGS.delete(ref);
 });
 var MOCK_CONFIGS = /* @__PURE__ */ new WeakMap();
 var MOCKS_BY_STATE = /* @__PURE__ */ new WeakMap();
+function markDirty(set3, mock) {
+  let ref = MOCK_REFS.get(mock);
+  if (!ref) {
+    ref = new WeakRef(mock);
+    MOCK_REFS.set(mock, ref);
+    MOCK_FINALIZER.register(mock, ref);
+  }
+  addToSet.call(set3, ref);
+}
+function unmarkDirty(set3, mock) {
+  const ref = MOCK_REFS.get(mock);
+  if (ref) set3.delete(ref);
+}
+function forEachDirty(set3, fn2) {
+  for (const ref of set3) {
+    const mock = ref.deref();
+    if (mock) fn2(mock);
+    else set3.delete(ref);
+  }
+}
 function createMockInstance(options = {}) {
   const { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options;
   if (restore) MOCK_RESTORE.add(restore);
@@ -6861,9 +7190,6 @@ function createMockInstance(options = {}) {
   if (resetToMockName) config2.mockName = mock.name || "vi.fn()";
   MOCK_CONFIGS.set(mock, config2);
   MOCKS_BY_STATE.set(state, mock);
-  const ref = new WeakRef(mock);
-  REGISTERED_MOCKS.add(ref);
-  MOCK_FINALIZER.register(mock, ref);
   mock._isMockFunction = true;
   mock.getMockImplementation = () => {
     return config2.onceMockImplementations[0] || config2.mockImplementation;
@@ -6878,21 +7204,25 @@ function createMockInstance(options = {}) {
     value: state
   });
   mock.mockImplementation = function mockImplementation2(implementation) {
+    markDirty(DIRTY_MOCK_CONFIGS, mock);
     config2.mockImplementation = implementation;
     updateMockPrototype();
     return mock;
   };
   mock.mockImplementationOnce = function mockImplementationOnce(implementation) {
+    markDirty(DIRTY_MOCK_CONFIGS, mock);
     config2.onceMockImplementations.push(implementation);
     updateMockPrototype();
     return mock;
   };
   mock.withImplementation = function withImplementation(implementation, callback) {
+    markDirty(DIRTY_MOCK_CONFIGS, mock);
     const previousImplementation = config2.mockImplementation;
     const previousOnceImplementations = config2.onceMockImplementations;
     const reset = () => {
       config2.mockImplementation = previousImplementation;
       config2.onceMockImplementations = previousOnceImplementations;
+      markDirty(DIRTY_MOCK_CONFIGS, mock);
       updateMockPrototype();
     };
     config2.mockImplementation = implementation;
@@ -6964,7 +7294,7 @@ function createMockInstance(options = {}) {
     state.invocationCallOrder = [];
     state.results = [];
     state.settledResults = [];
-    DIRTY_MOCK_STATES.delete(mock);
+    unmarkDirty(DIRTY_MOCK_STATES, mock);
     return mock;
   };
   mock.mockReset = function mockReset() {
@@ -6972,6 +7302,7 @@ function createMockInstance(options = {}) {
     config2.mockImplementation = resetToMockImplementation ? mockImplementation : void 0;
     config2.mockName = resetToMockName ? mock.name || "vi.fn()" : "vi.fn()";
     config2.onceMockImplementations = [];
+    unmarkDirty(DIRTY_MOCK_CONFIGS, mock);
     updateMockPrototype();
     return mock;
   };
@@ -6980,7 +7311,10 @@ function createMockInstance(options = {}) {
     return restore?.();
   };
   mock.mockName = function mockName(name) {
-    if (typeof name === "string") config2.mockName = name;
+    if (typeof name === "string") {
+      markDirty(DIRTY_MOCK_CONFIGS, mock);
+      config2.mockName = name;
+    }
     return mock;
   };
   mock.getMockName = function getMockName() {
@@ -7077,9 +7411,9 @@ function createMock({ state, config: config2, name: mockName, prototypeState, pr
   const prototypeMock = prototypeState && MOCKS_BY_STATE.get(prototypeState);
   const namedObject = {
     // to keep the name of the function intact
-    [name]: (function(...args) {
-      addDirtyMock(namedObject[name]);
-      if (prototypeMock) addDirtyMock(prototypeMock);
+    [name]: function(...args) {
+      markDirty(DIRTY_MOCK_STATES, namedObject[name]);
+      if (prototypeMock) markDirty(DIRTY_MOCK_STATES, prototypeMock);
       registerCalls(args, state, prototypeState);
       registerInvocationOrder(invocationCallCounter++, state, prototypeState);
       const result = {
@@ -7101,8 +7435,11 @@ function createMock({ state, config: config2, name: mockName, prototypeState, pr
       let didThrow = false;
       try {
         if (new.target) {
-          if (prototypeMembers.length === 0)
-            reparentMockPrototype(mock, implementation === noopImplementation ? void 0 : implementation);
+          if (prototypeMembers.length === 0) reparentMockPrototype(
+            // oxlint-disable-next-line typescript/no-use-before-define
+            mock,
+            implementation === noopImplementation ? void 0 : implementation
+          );
           returnValue = Reflect.construct(implementation, args, new.target);
           for (const prop of prototypeMembers) {
             const prototypeMock2 = returnValue[prop];
@@ -7152,7 +7489,7 @@ function createMock({ state, config: config2, name: mockName, prototypeState, pr
         }
       }
       return returnValue;
-    })
+    }
   };
   const mock = namedObject[name];
   const copyPropertiesFrom = original || pseudoOriginal;
@@ -7245,14 +7582,11 @@ function restoreAllMocks() {
   MOCK_RESTORE.clear();
 }
 function clearAllMocks() {
-  for (const mock of DIRTY_MOCK_STATES) mock.mockClear();
+  forEachDirty(DIRTY_MOCK_STATES, (mock) => mock.mockClear());
 }
 function resetAllMocks() {
-  for (const ref of REGISTERED_MOCKS) {
-    const mock = ref.deref();
-    if (mock) mock.mockReset();
-    else REGISTERED_MOCKS.delete(ref);
-  }
+  forEachDirty(DIRTY_MOCK_STATES, (mock) => mock.mockReset());
+  forEachDirty(DIRTY_MOCK_CONFIGS, (mock) => mock.mockReset());
 }
 function throwConstructorError(shorthand) {
   throw new TypeError(`Cannot use \`${shorthand}\` when called with \`new\`. Use \`mockImplementation\` with a \`class\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`);
@@ -7332,6 +7666,9 @@ function compatibleConstructor(thrown, errorLike) {
 __name(compatibleConstructor, "compatibleConstructor");
 function compatibleMessage(thrown, errMatcher) {
   const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
+  if (comparisonString === void 0) {
+    return false;
+  }
   if (isRegExp(errMatcher)) {
     return errMatcher.test(comparisonString);
   } else if (typeof errMatcher === "string") {
@@ -7385,7 +7722,10 @@ function type(obj) {
   if (obj === null) {
     return "null";
   }
-  const stringTag = obj[Symbol.toStringTag];
+  const stringTag = (
+    /** @type {Record<PropertyKey, unknown>} */
+    obj[Symbol.toStringTag]
+  );
   if (typeof stringTag === "string") {
     return stringTag;
   }
@@ -7428,17 +7768,21 @@ __name(_AssertionError, "AssertionError");
 var AssertionError = _AssertionError;
 function expectTypes(obj, types) {
   let flagMsg = flag(obj, "message");
-  let ssfi = flag(obj, "ssfi");
+  let ssfi = (
+    /** @type {Function} */
+    flag(obj, "ssfi")
+  );
   flagMsg = flagMsg ? flagMsg + ": " : "";
-  obj = flag(obj, "object");
-  types = types.map(function(t2) {
-    return t2.toLowerCase();
+  obj = /** @type {object} */
+  flag(obj, "object");
+  types = types.map(function(t3) {
+    return t3.toLowerCase();
   });
   types.sort();
-  let str = types.map(function(t2, index) {
-    let art = ~["a", "e", "i", "o", "u"].indexOf(t2.charAt(0)) ? "an" : "a";
-    let or = types.length > 1 && index === types.length - 1 ? "or " : "";
-    return or + art + " " + t2;
+  let str = types.map(function(t3, index2) {
+    let art = ~["a", "e", "i", "o", "u"].indexOf(t3.charAt(0)) ? "an" : "a";
+    let or = types.length > 1 && index2 === types.length - 1 ? "or " : "";
+    return or + art + " " + t3;
   }).join(", ");
   let objType = type(obj).toLowerCase();
   if (!types.some(function(expected) {
@@ -8127,11 +8471,23 @@ function objDisplay(obj) {
   let str = inspect22(obj), type3 = Object.prototype.toString.call(obj);
   if (config.truncateThreshold && str.length >= config.truncateThreshold) {
     if (type3 === "[object Function]") {
-      return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";
+      const objAsFunction = (
+        /** @type {Function} */
+        obj
+      );
+      return !objAsFunction.name || objAsFunction.name === "" ? "[Function]" : "[Function: " + objAsFunction.name + "]";
     } else if (type3 === "[object Array]") {
-      return "[ Array(" + obj.length + ") ]";
+      const objAsArray = (
+        /** @type {unknown[]} */
+        obj
+      );
+      return "[ Array(" + objAsArray.length + ") ]";
     } else if (type3 === "[object Object]") {
-      let keys2 = Object.keys(obj), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
+      const objAsObject = (
+        /** @type {Record<PropertyKey, unknown>} */
+        obj
+      );
+      let keys2 = Object.keys(objAsObject), kstr = keys2.length > 2 ? keys2.splice(0, 2).join(", ") + ", ..." : keys2.join(", ");
       return "{ Object (" + kstr + ") }";
     } else {
       return str;
@@ -8146,29 +8502,40 @@ function getMessage2(obj, args) {
   let val = flag(obj, "object");
   let expected = args[3];
   let actual = getActual(obj, args);
-  let msg = negate ? args[2] : args[1];
+  let rawMsg = negate ? args[2] : args[1];
   let flagMsg = flag(obj, "message");
-  if (typeof msg === "function") msg = msg();
-  msg = msg || "";
-  msg = msg.replace(/#\{this\}/g, function() {
-    return objDisplay(val);
-  }).replace(/#\{act\}/g, function() {
-    return objDisplay(actual);
-  }).replace(/#\{exp\}/g, function() {
+  if (typeof rawMsg === "function") rawMsg = rawMsg();
+  const template = (
+    /** @type {string} */
+    rawMsg || ""
+  );
+  const msg = template.replace(/#\{(this|act|exp)\}/g, function(_2, tag) {
+    if (tag === "this") {
+      return objDisplay(val);
+    }
+    if (tag === "act") {
+      return objDisplay(actual);
+    }
     return objDisplay(expected);
   });
   return flagMsg ? flagMsg + ": " + msg : msg;
 }
 __name(getMessage2, "getMessage");
-function transferFlags(assertion, object2, includeAll) {
-  let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null));
-  if (!object2.__flags) {
-    object2.__flags = /* @__PURE__ */ Object.create(null);
-  }
+function transferFlags(source, object2, includeAll) {
+  const sourceWithFlags = (
+    /** @type {{__flags?: Record<PropertyKey, unknown>}} */
+    source
+  );
+  const objWithFlags = (
+    /** @type {{__flags?: Record<PropertyKey, unknown>}} */
+    object2
+  );
+  let flags = sourceWithFlags.__flags || (sourceWithFlags.__flags = /* @__PURE__ */ Object.create(null));
+  const objFlags = objWithFlags.__flags || (objWithFlags.__flags = /* @__PURE__ */ Object.create(null));
   includeAll = arguments.length === 3 ? includeAll : true;
   for (let flag3 in flags) {
     if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {
-      object2.__flags[flag3] = flags[flag3];
+      objFlags[flag3] = flags[flag3];
     }
   }
 }
@@ -8386,9 +8753,9 @@ function iterableEqual(leftHandOperand, rightHandOperand, options) {
   if (length === 0) {
     return true;
   }
-  var index = -1;
-  while (++index < length) {
-    if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {
+  var index2 = -1;
+  while (++index2 < length) {
+    if (deepEqual(leftHandOperand[index2], rightHandOperand[index2], options) === false) {
       return false;
     }
   }
@@ -8586,9 +8953,9 @@ var _Assertion = class _Assertion2 {
    * - `eql`: This flag contains the deepEqual function to be used by the assertion.
    *
    * @param {unknown} obj target of the assertion
-   * @param {string} [msg] (optional) custom error message
-   * @param {Function} [ssfi] (optional) starting point for removing stack frames
-   * @param {boolean} [lockSsfi] (optional) whether or not the ssfi flag is locked
+   * @param {string=} msg (optional) custom error message
+   * @param {Function=} ssfi (optional) starting point for removing stack frames
+   * @param {boolean=} lockSsfi (optional) whether or not the ssfi flag is locked
    */
   constructor(obj, msg, ssfi, lockSsfi) {
     __publicField2(this, "__flags", {});
@@ -8629,44 +8996,44 @@ var _Assertion = class _Assertion2 {
   }
   /**
    * @param {string} name
-   * @param {Function} fn
+   * @param {(...args: never) => unknown} fn
    */
   static addProperty(name, fn2) {
     addProperty(this.prototype, name, fn2);
   }
   /**
    * @param {string} name
-   * @param {Function} fn
+   * @param {(...args: never) => unknown} fn
    */
   static addMethod(name, fn2) {
     addMethod(this.prototype, name, fn2);
   }
   /**
    * @param {string} name
-   * @param {Function} fn
-   * @param {Function} chainingBehavior
+   * @param {(...args: never) => unknown} fn
+   * @param {(...args: never) => unknown} chainingBehavior
    */
   static addChainableMethod(name, fn2, chainingBehavior) {
     addChainableMethod(this.prototype, name, fn2, chainingBehavior);
   }
   /**
    * @param {string} name
-   * @param {Function} fn
+   * @param {(...args: never) => unknown} fn
    */
   static overwriteProperty(name, fn2) {
     overwriteProperty(this.prototype, name, fn2);
   }
   /**
    * @param {string} name
-   * @param {Function} fn
+   * @param {(...args: never) => unknown} fn
    */
   static overwriteMethod(name, fn2) {
     overwriteMethod(this.prototype, name, fn2);
   }
   /**
    * @param {string} name
-   * @param {Function} fn
-   * @param {Function} chainingBehavior
+   * @param {(...args: never) => unknown} fn
+   * @param {(...args: never) => unknown} chainingBehavior
    */
   static overwriteChainableMethod(name, fn2, chainingBehavior) {
     overwriteChainableMethod(this.prototype, name, fn2, chainingBehavior);
@@ -8705,7 +9072,6 @@ var _Assertion = class _Assertion2 {
       throw new AssertionError(
         msg,
         assertionErrorObjectProperties,
-        // @ts-expect-error Not sure what to do about these types yet
         config.includeStack ? this.assert : flag(this, "ssfi")
       );
     }
@@ -8731,6 +9097,11 @@ __name(_Assertion, "Assertion");
 var Assertion = _Assertion;
 var events = new EventTarget();
 var _PluginEvent = class _PluginEvent2 extends Event {
+  /**
+   * @param {string} type
+   * @param {string} name
+   * @param {Function} fn
+   */
   constructor(type3, name, fn2) {
     super(type3);
     this.name = String(name);
@@ -8765,7 +9136,7 @@ __name(addProperty, "addProperty");
 var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {
 }, "length");
 function addLengthGuard(fn2, assertionName, isChainable) {
-  if (!fnLengthDesc.configurable) return fn2;
+  if (!fnLengthDesc?.configurable) return fn2;
   Object.defineProperty(fn2, "length", {
     get: /* @__PURE__ */ __name(function() {
       if (isChainable) {
@@ -8805,7 +9176,7 @@ function proxify(obj, nonChainableMethodName) {
       if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
         if (nonChainableMethodName) {
           throw Error(
-            "Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".'
+            "Invalid Chai property: " + String(nonChainableMethodName) + "." + property + '. See docs for proper usage of "' + String(nonChainableMethodName) + '".'
           );
         }
         let suggestion = null;
@@ -8880,12 +9251,17 @@ function addMethod(ctx, name, method) {
     return newAssertion;
   }, "methodWrapper");
   addLengthGuard(methodWrapper, name, false);
-  ctx[name] = proxify(methodWrapper, name);
+  ctx[name] = proxify(
+    methodWrapper,
+    name
+  );
   events.dispatchEvent(new PluginEvent("addMethod", name, method));
 }
 __name(addMethod, "addMethod");
 function overwriteProperty(ctx, name, getter) {
-  let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() {
+  let _get = Object.getOwnPropertyDescriptor(ctx, name);
+  let _super = /* @__PURE__ */ __name(function() {
+    return;
   }, "_super");
   if (_get && "function" === typeof _get.get) _super = _get.get;
   Object.defineProperty(ctx, name, {
@@ -8909,11 +9285,15 @@ function overwriteProperty(ctx, name, getter) {
 }
 __name(overwriteProperty, "overwriteProperty");
 function overwriteMethod(ctx, name, method) {
-  let _method = ctx[name], _super = /* @__PURE__ */ __name(function() {
-    throw new Error(name + " is not a function");
+  let _method = (
+    /** @type {Record<PropertyKey, unknown>} */
+    ctx[name]
+  );
+  let _super = /* @__PURE__ */ __name(function() {
+    throw new Error(String(name) + " is not a function");
   }, "_super");
   if (_method && "function" === typeof _method) _super = _method;
-  let overwritingMethodWrapper = /* @__PURE__ */ __name(function() {
+  function overwritingMethodWrapper() {
     if (!flag(this, "lockSsfi")) {
       flag(this, "ssfi", overwritingMethodWrapper);
     }
@@ -8927,9 +9307,13 @@ function overwriteMethod(ctx, name, method) {
     let newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  }, "overwritingMethodWrapper");
-  addLengthGuard(overwritingMethodWrapper, name, false);
-  ctx[name] = proxify(overwritingMethodWrapper, name);
+  }
+  __name(overwritingMethodWrapper, "overwritingMethodWrapper");
+  addLengthGuard(overwritingMethodWrapper, String(name), false);
+  ctx[name] = proxify(
+    overwritingMethodWrapper,
+    name
+  );
 }
 __name(overwriteMethod, "overwriteMethod");
 var canSetPrototype = typeof Object.setPrototypeOf === "function";
@@ -8943,6 +9327,12 @@ var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
 var call = Function.prototype.call;
 var apply = Function.prototype.apply;
 var _PluginAddChainableMethodEvent = class _PluginAddChainableMethodEvent2 extends PluginEvent {
+  /**
+   * @param {string} type
+   * @param {string} name
+   * @param {Function} fn
+   * @param {Function} chainingBehavior
+   */
   constructor(type3, name, fn2, chainingBehavior) {
     super(type3, name, fn2);
     this.chainingBehavior = chainingBehavior;
@@ -8951,6 +9341,10 @@ var _PluginAddChainableMethodEvent = class _PluginAddChainableMethodEvent2 exten
 __name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent");
 var PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent;
 function addChainableMethod(ctx, name, method, chainingBehavior) {
+  const ctxChainable = (
+    /** @type {T & {__methods: Record<PropertyKey, ChainableBehavior>}} */
+    ctx
+  );
   if (typeof chainingBehavior !== "function") {
     chainingBehavior = /* @__PURE__ */ __name(function() {
     }, "chainingBehavior");
@@ -8959,25 +9353,29 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
     method,
     chainingBehavior
   };
-  if (!ctx.__methods) {
-    ctx.__methods = {};
+  if (!ctxChainable.__methods) {
+    ctxChainable.__methods = {};
   }
-  ctx.__methods[name] = chainableBehavior;
+  ctxChainable.__methods[name] = chainableBehavior;
   Object.defineProperty(ctx, name, {
     get: /* @__PURE__ */ __name(function chainableMethodGetter() {
       chainableBehavior.chainingBehavior.call(this);
-      let chainableMethodWrapper = /* @__PURE__ */ __name(function() {
+      function chainableMethodWrapper(...args) {
         if (!flag(this, "lockSsfi")) {
           flag(this, "ssfi", chainableMethodWrapper);
         }
-        let result = chainableBehavior.method.apply(this, arguments);
+        let result = (
+          /** @type {(...args: unknown[]) => unknown} */
+          chainableBehavior.method.apply(this, args)
+        );
         if (result !== void 0) {
           return result;
         }
         let newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
-      }, "chainableMethodWrapper");
+      }
+      __name(chainableMethodWrapper, "chainableMethodWrapper");
       addLengthGuard(chainableMethodWrapper, name, true);
       if (canSetPrototype) {
         let prototype = Object.create(this);
@@ -8991,7 +9389,9 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
             return;
           }
           let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
-          Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+          if (pd) {
+            Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+          }
         });
       }
       transferFlags(this, chainableMethodWrapper);
@@ -9010,9 +9410,15 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
 }
 __name(addChainableMethod, "addChainableMethod");
 function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
-  let chainableBehavior = ctx.__methods[name];
+  let chainableBehavior = (
+    /** @type {{__methods: Record<PropertyKey, ChainableBehavior>}} */
+    ctx.__methods[name]
+  );
   let _chainingBehavior = chainableBehavior.chainingBehavior;
-  chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
+  chainableBehavior.chainingBehavior = /**
+  * @this {T}
+  */
+  /* @__PURE__ */ __name(function overwritingChainableMethodGetter() {
     let result = chainingBehavior(_chainingBehavior).call(this);
     if (result !== void 0) {
       return result;
@@ -9033,19 +9439,24 @@ function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   }, "overwritingChainableMethodWrapper");
 }
 __name(overwriteChainableMethod, "overwriteChainableMethod");
-function compareByInspect(a2, b2) {
-  return inspect22(a2) < inspect22(b2) ? -1 : 1;
+function compareByInspect(a, b2) {
+  return inspect22(a) < inspect22(b2) ? -1 : 1;
 }
 __name(compareByInspect, "compareByInspect");
 function getOwnEnumerablePropertySymbols(obj) {
   if (typeof Object.getOwnPropertySymbols !== "function") return [];
   return Object.getOwnPropertySymbols(obj).filter(function(sym) {
-    return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
+    return Object.getOwnPropertyDescriptor(obj, sym)?.enumerable;
   });
 }
 __name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols");
 function getOwnEnumerableProperties(obj) {
-  return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
+  return (
+    /** @type {PropertyKey[]} */
+    Object.keys(obj).concat(
+      getOwnEnumerablePropertySymbols(obj)
+    )
+  );
 }
 __name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
 var isNaN2 = Number.isNaN;
@@ -9061,18 +9472,19 @@ function getOperator(obj, args) {
   let expected = args[3];
   let msg = negate ? args[2] : args[1];
   if (operator) {
-    return operator;
+    return String(operator);
   }
   if (typeof msg === "function") msg = msg();
   msg = msg || "";
   if (!msg) {
     return void 0;
   }
-  if (/\shave\s/.test(msg)) {
+  const msgString = String(msg);
+  if (/\shave\s/.test(msgString)) {
     return void 0;
   }
   let isObject3 = isObjectType(expected);
-  if (/\snot\s/.test(msg)) {
+  if (/\snot\s/.test(msgString)) {
     return isObject3 ? "notDeepStrictEqual" : "notStrictEqual";
   }
   return isObject3 ? "deepStrictEqual" : "strictEqual";
@@ -9168,8 +9580,8 @@ function an(type3, msg) {
 __name(an, "an");
 Assertion.addChainableMethod("an", an);
 Assertion.addChainableMethod("a", an);
-function SameValueZero(a2, b2) {
-  return isNaN2(a2) && isNaN2(b2) || a2 === b2;
+function SameValueZero(a, b2) {
+  return isNaN2(a) && isNaN2(b2) || a === b2;
 }
 __name(SameValueZero, "SameValueZero");
 function includeChainingBehavior() {
@@ -9433,9 +9845,9 @@ function assertEql(obj, msg) {
 __name(assertEql, "assertEql");
 Assertion.addMethod("eql", assertEql);
 Assertion.addMethod("eqls", assertEql);
-function assertAbove(n3, msg) {
+function assertAbove(n2, msg) {
   if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n3).toLowerCase();
+  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n2).toLowerCase();
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
   }
@@ -9445,7 +9857,7 @@ function assertAbove(n3, msg) {
       void 0,
       ssfi
     );
-  } else if (!isNumeric(n3) && (doLength || isNumeric(obj))) {
+  } else if (!isNumeric(n2) && (doLength || isNumeric(obj))) {
     throw new AssertionError(
       msgPrefix + "the argument to above must be a number",
       void 0,
@@ -9468,18 +9880,18 @@ function assertAbove(n3, msg) {
       itemsCount = obj.length;
     }
     this.assert(
-      itemsCount > n3,
+      itemsCount > n2,
       "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}",
       "expected #{this} to not have a " + descriptor + " above #{exp}",
-      n3,
+      n2,
       itemsCount
     );
   } else {
     this.assert(
-      obj > n3,
+      obj > n2,
       "expected #{this} to be above #{exp}",
       "expected #{this} to be at most #{exp}",
-      n3
+      n2
     );
   }
 }
@@ -9487,15 +9899,15 @@ __name(assertAbove, "assertAbove");
 Assertion.addMethod("above", assertAbove);
 Assertion.addMethod("gt", assertAbove);
 Assertion.addMethod("greaterThan", assertAbove);
-function assertLeast(n3, msg) {
+function assertLeast(n2, msg) {
   if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n3).toLowerCase(), errorMessage, shouldThrow = true;
+  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n2).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
   }
   if (!doLength && objType === "date" && nType !== "date") {
     errorMessage = msgPrefix + "the argument to least must be a date";
-  } else if (!isNumeric(n3) && (doLength || isNumeric(obj))) {
+  } else if (!isNumeric(n2) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to least must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
     let printObj = objType === "string" ? "'" + obj + "'" : obj;
@@ -9515,18 +9927,18 @@ function assertLeast(n3, msg) {
       itemsCount = obj.length;
     }
     this.assert(
-      itemsCount >= n3,
+      itemsCount >= n2,
       "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}",
       "expected #{this} to have a " + descriptor + " below #{exp}",
-      n3,
+      n2,
       itemsCount
     );
   } else {
     this.assert(
-      obj >= n3,
+      obj >= n2,
       "expected #{this} to be at least #{exp}",
       "expected #{this} to be below #{exp}",
-      n3
+      n2
     );
   }
 }
@@ -9534,15 +9946,15 @@ __name(assertLeast, "assertLeast");
 Assertion.addMethod("least", assertLeast);
 Assertion.addMethod("gte", assertLeast);
 Assertion.addMethod("greaterThanOrEqual", assertLeast);
-function assertBelow(n3, msg) {
+function assertBelow(n2, msg) {
   if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n3).toLowerCase(), errorMessage, shouldThrow = true;
+  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n2).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
   }
   if (!doLength && objType === "date" && nType !== "date") {
     errorMessage = msgPrefix + "the argument to below must be a date";
-  } else if (!isNumeric(n3) && (doLength || isNumeric(obj))) {
+  } else if (!isNumeric(n2) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to below must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
     let printObj = objType === "string" ? "'" + obj + "'" : obj;
@@ -9562,18 +9974,18 @@ function assertBelow(n3, msg) {
       itemsCount = obj.length;
     }
     this.assert(
-      itemsCount < n3,
+      itemsCount < n2,
       "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}",
       "expected #{this} to not have a " + descriptor + " below #{exp}",
-      n3,
+      n2,
       itemsCount
     );
   } else {
     this.assert(
-      obj < n3,
+      obj < n2,
       "expected #{this} to be below #{exp}",
       "expected #{this} to be at least #{exp}",
-      n3
+      n2
     );
   }
 }
@@ -9581,15 +9993,15 @@ __name(assertBelow, "assertBelow");
 Assertion.addMethod("below", assertBelow);
 Assertion.addMethod("lt", assertBelow);
 Assertion.addMethod("lessThan", assertBelow);
-function assertMost(n3, msg) {
+function assertMost(n2, msg) {
   if (msg) flag2(this, "message", msg);
-  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n3).toLowerCase(), errorMessage, shouldThrow = true;
+  let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n2).toLowerCase(), errorMessage, shouldThrow = true;
   if (doLength && objType !== "map" && objType !== "set") {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
   }
   if (!doLength && objType === "date" && nType !== "date") {
     errorMessage = msgPrefix + "the argument to most must be a date";
-  } else if (!isNumeric(n3) && (doLength || isNumeric(obj))) {
+  } else if (!isNumeric(n2) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + "the argument to most must be a number";
   } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
     let printObj = objType === "string" ? "'" + obj + "'" : obj;
@@ -9609,18 +10021,18 @@ function assertMost(n3, msg) {
       itemsCount = obj.length;
     }
     this.assert(
-      itemsCount <= n3,
+      itemsCount <= n2,
       "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}",
       "expected #{this} to have a " + descriptor + " above #{exp}",
-      n3,
+      n2,
       itemsCount
     );
   } else {
     this.assert(
-      obj <= n3,
+      obj <= n2,
       "expected #{this} to be at most #{exp}",
       "expected #{this} to be above #{exp}",
-      n3
+      n2
     );
   }
 }
@@ -9806,7 +10218,7 @@ function assertLengthChain() {
   flag2(this, "doLength", true);
 }
 __name(assertLengthChain, "assertLengthChain");
-function assertLength(n3, msg) {
+function assertLength(n2, msg) {
   if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
   switch (objType) {
@@ -9820,10 +10232,10 @@ function assertLength(n3, msg) {
       itemsCount = obj.length;
   }
   this.assert(
-    itemsCount == n3,
+    itemsCount == n2,
     "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}",
     "expected #{this} to not have a " + descriptor + " of #{act}",
-    n3,
+    n2,
     itemsCount
   );
 }
@@ -9893,21 +10305,22 @@ function assertKeys(keys2) {
   if (!any && !all) {
     all = true;
   }
+  const uniqueExpected = [...new Set(expected)];
   if (any) {
-    ok = expected.some(function(expectedKey) {
+    ok = uniqueExpected.some(function(expectedKey) {
       return actual.some(function(actualKey) {
         return isEql(expectedKey, actualKey);
       });
     });
   }
   if (all) {
-    ok = expected.every(function(expectedKey) {
+    ok = uniqueExpected.every(function(expectedKey) {
       return actual.some(function(actualKey) {
         return isEql(expectedKey, actualKey);
       });
     });
     if (!flag2(this, "contains")) {
-      ok = ok && keys2.length == actual.length;
+      ok = ok && uniqueExpected.length == actual.length;
     }
   }
   if (len > 1) {
@@ -10177,7 +10590,7 @@ Assertion.addProperty("iterable", function(msg) {
   if (msg) flag2(this, "message", msg);
   let obj = flag2(this, "object");
   this.assert(
-    obj != void 0 && obj[Symbol.iterator],
+    obj != void 0 && typeof obj[Symbol.iterator] === "function",
     "expected #{this} to be an iterable",
     "expected #{this} to not be an iterable",
     obj
@@ -10190,10 +10603,12 @@ function oneOf(list, msg) {
   if (contains) {
     this.assert(
       list.some(function(possibility) {
-        return expected.indexOf(possibility) > -1;
+        return expected.indexOf(possibility) > -1 || isDeep && Array.isArray(expected) && expected.some(function(item) {
+          return eql(item, possibility);
+        });
       }),
-      "expected #{this} to contain one of #{exp}",
-      "expected #{this} to not contain one of #{exp}",
+      "expected #{this} to " + (isDeep ? "deeply " : "") + "contain one of #{exp}",
+      "expected #{this} to not " + (isDeep ? "deeply " : "") + "contain one of #{exp}",
       list,
       expected
     );
@@ -10204,7 +10619,7 @@ function oneOf(list, msg) {
           return eql(expected, possibility);
         }),
         "expected #{this} to deeply equal one of #{exp}",
-        "expected #{this} to deeply equal one of #{exp}",
+        "expected #{this} to not deeply equal one of #{exp}",
         list,
         expected
       );
@@ -10223,18 +10638,31 @@ __name(oneOf, "oneOf");
 Assertion.addMethod("oneOf", oneOf);
 function assertChanges(subject, prop, msg) {
   if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  const fn2 = (
+    /** @type {() => void} */
+    flag2(this, "object")
+  );
+  const flagMsg = flag2(this, "message");
+  const ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
   let initial;
-  if (!prop) {
+  if (prop === null || prop === void 0) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
-    initial = subject();
+    initial = /** @type {() => unknown} */
+    subject();
   } else {
     new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
-    initial = subject[prop];
+    initial = /** @type {Record<PropertyKey, unknown>} */
+    subject[prop];
   }
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let final = prop === void 0 || prop === null ? (
+    /** @type {() => unknown} */
+    subject()
+  ) : (
+    /** @type {Record<PropertyKey, unknown>} */
+    subject[prop]
+  );
   let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
@@ -10252,19 +10680,32 @@ Assertion.addMethod("change", assertChanges);
 Assertion.addMethod("changes", assertChanges);
 function assertIncreases(subject, prop, msg) {
   if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  const fn2 = (
+    /** @type {() => void} */
+    flag2(this, "object")
+  );
+  const flagMsg = flag2(this, "message");
+  const ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
   let initial;
-  if (!prop) {
+  if (prop === null || prop === void 0) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
-    initial = subject();
+    initial = /** @type {() => number} */
+    subject();
   } else {
     new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
-    initial = subject[prop];
+    initial = /** @type {Record<PropertyKey, number>} */
+    subject[prop];
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let final = prop === void 0 || prop === null ? (
+    /** @type {() => number} */
+    subject()
+  ) : (
+    /** @type {Record<PropertyKey, number>} */
+    subject[prop]
+  );
   let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
@@ -10282,19 +10723,32 @@ Assertion.addMethod("increase", assertIncreases);
 Assertion.addMethod("increases", assertIncreases);
 function assertDecreases(subject, prop, msg) {
   if (msg) flag2(this, "message", msg);
-  let fn2 = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+  const fn2 = (
+    /** @type {() => void} */
+    flag2(this, "object")
+  );
+  const flagMsg = flag2(this, "message");
+  const ssfi = flag2(this, "ssfi");
   new Assertion(fn2, flagMsg, ssfi, true).is.a("function");
   let initial;
-  if (!prop) {
+  if (prop === null || prop === void 0) {
     new Assertion(subject, flagMsg, ssfi, true).is.a("function");
-    initial = subject();
+    initial = /** @type {() => number} */
+    subject();
   } else {
     new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
-    initial = subject[prop];
+    initial = /** @type {Record<PropertyKey, number>} */
+    subject[prop];
   }
   new Assertion(initial, flagMsg, ssfi, true).is.a("number");
   fn2();
-  let final = prop === void 0 || prop === null ? subject() : subject[prop];
+  let final = prop === void 0 || prop === null ? (
+    /** @type {() => number} */
+    subject()
+  ) : (
+    /** @type {Record<PropertyKey, number>} */
+    subject[prop]
+  );
   let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
   flag2(this, "deltaMsgObj", msgObj);
   flag2(this, "initialDeltaValue", initial);
@@ -10426,13 +10880,14 @@ function expect(val, message) {
 }
 __name(expect, "expect");
 expect.fail = function(actual, expected, message, operator) {
+  let msg = message;
   if (arguments.length < 2) {
-    message = actual;
+    msg = /** @type {string | undefined} */
+    actual;
     actual = void 0;
   }
-  message = message || "expect.fail()";
   throw new AssertionError(
-    message,
+    msg || "expect.fail()",
     {
       actual,
       expected,
@@ -11098,7 +11553,7 @@ assert3.oneOf = function(inList, list, msg) {
   new Assertion(inList, msg, assert3.oneOf, true).to.be.oneOf(list);
 };
 assert3.isIterable = function(obj, msg) {
-  if (obj == void 0 || !obj[Symbol.iterator]) {
+  if (obj == void 0 || typeof obj[Symbol.iterator] !== "function") {
     msg = msg ? `${msg} expected ${inspect22(obj)} to be an iterable` : `expected ${inspect22(obj)} to be an iterable`;
     throw new AssertionError(msg, void 0, assert3.isIterable);
   }
@@ -11306,7 +11761,7 @@ function use(fn2) {
 }
 __name(use, "use");
 
-// node_modules/vitest/dist/chunks/plugins.Cigb0uSy.js
+// ../../node_modules/vitest/dist/chunks/plugins.DPQHVT0p.js
 var serialize2 = (val, config2, indentation, depth, refs, printer2) => {
   const name = val.getMockName();
   const nameString = name === "vi.fn()" ? "" : ` ${name}`;
@@ -11339,7 +11794,7 @@ function getSerializers() {
   return PLUGINS3;
 }
 
-// node_modules/vitest/dist/chunks/offset.Dy-5Fdfn.js
+// ../../node_modules/vitest/dist/chunks/offset.Dy-5Fdfn.js
 var lineSplitRE = /\r?\n/;
 function positionToOffset(source, lineNumber, columnNumber) {
   const lines = source.split(lineSplitRE);
@@ -11373,13 +11828,13 @@ var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar2 = /* @__PURE__ */ new Uint8Array(64);
 var charToInt2 = /* @__PURE__ */ new Uint8Array(128);
 for (let i3 = 0; i3 < chars2.length; i3++) {
-  let c = chars2.charCodeAt(i3);
-  intToChar2[i3] = c, charToInt2[c] = i3;
+  let c2 = chars2.charCodeAt(i3);
+  intToChar2[i3] = c2, charToInt2[c2] = i3;
 }
 var textDecoder = new TextDecoder();
 var decodeBase64 = (() => {
   let capturedBuffer = typeof Buffer == "function" ? Buffer : void 0;
-  return capturedBuffer && typeof capturedBuffer.from == "function" ? (base64) => capturedBuffer.from(base64, "base64").toString("utf-8") : (base64) => textDecoder.decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
+  return capturedBuffer && typeof capturedBuffer.from == "function" ? (base64) => capturedBuffer.from(base64, "base64").toString("utf-8") : (base64) => textDecoder.decode(Uint8Array.from(atob(base64), (c2) => c2.charCodeAt(0)));
 })();
 var MODULE_RUNNER_SOURCEMAPPING_REGEXP = RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
 var customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
@@ -11396,8 +11851,8 @@ export async function resolve(specifier, context, nextResolve) {
 }
 
 `;
-var envProxy = new Proxy({}, { get(_, p) {
-  throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+var envProxy = new Proxy({}, { get(_2, p2) {
+  throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p2)}" instead.`);
 } });
 var retrieveFileHandlers = /* @__PURE__ */ new Set();
 var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
@@ -11412,55 +11867,46 @@ var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
 var retrieveSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
 var originalPrepare = Error.prepareStackTrace;
 
-// node_modules/tinybench/dist/index.js
-var t = Object.freeze(() => {
+// ../../node_modules/tinybench/dist/index.js
+var e = Object.freeze(() => {
 });
-var _e, _t, _n, _a;
-var n = (_a = class extends globalThis.Event {
-  constructor(e, t2, n3) {
-    super(e);
-    __privateAdd(this, _e);
-    __privateAdd(this, _t);
-    __privateAdd(this, _n);
-    t2 != null && __privateSet(this, _n, t2), typeof n3 == "string" ? __privateSet(this, _t, n3) : n3 != null && __privateSet(this, _e, n3);
-  }
-  get error() {
-    return __privateGet(this, _e);
-  }
-  get reason() {
-    return __privateGet(this, _t);
-  }
-  get task() {
-    return __privateGet(this, _n);
-  }
-}, _e = new WeakMap(), _t = new WeakMap(), _n = new WeakMap(), _a);
-function r(e = globalThis) {
-  let t2 = "unknown", n3 = "unknown";
-  return e.Bun || e.process && e.process.versions?.bun ? (t2 = "bun", n3 = e.Bun.version || "unknown") : e.Deno ? (t2 = "deno", n3 = e.Deno.version?.deno ?? "unknown") : e.process && e.process.release?.name === "node" ? (t2 = "node", n3 = e.process.versions?.node ?? "unknown") : e.HermesInternal ? (t2 = "hermes", n3 = e.HermesInternal.getRuntimeProperties?.()["OSS Release Version"] ?? "unknown") : i2(e) && e.navigator.userAgent === "Cloudflare-Workers" ? t2 = "workerd" : i2(e) && e.navigator.userAgent.toLowerCase().startsWith("quickjs-ng") ? (t2 = "quickjs-ng", n3 = e.navigator.userAgent.split("/")[1] ?? "unknown") : typeof e.Netlify == "object" ? t2 = "netlify" : typeof e.EdgeRuntime == "string" ? t2 = "edge-light" : e.__lagon__ ? t2 = "lagon" : e.fastly ? t2 = "fastly" : e.$262 && e.lockdown && e.AsyncDisposableStack ? t2 = "moddable" : e.d8 ? (t2 = "v8", n3 = typeof e.version == "function" ? e.version() : "unknown") : e.inIon && e.performance && e.performance.mozMemory ? t2 = "spidermonkey" : typeof e.$ == "object" && e.$ !== null && "IsHTMLDDA" in e.$ ? t2 = "jsc" : e.window && e.navigator && (t2 = "browser"), {
-    runtime: t2,
-    version: n3
+var t2 = globalThis.Event;
+var i2 = (async () => {
+}).constructor;
+function p(e2 = globalThis) {
+  let t3 = "unknown", n2 = "unknown";
+  if (e2.Bun || e2.process && e2.process.versions?.bun) {
+    t3 = "bun";
+    let r = e2.Bun?.version;
+    if (r) n2 = r;
+    else {
+      let t4 = e2.process?.versions?.bun;
+      t4 && (n2 = t4);
+    }
+  } else e2.Deno ? (t3 = "deno", n2 = e2.Deno.version?.deno ?? "unknown") : e2.process && e2.process.release?.name === "node" ? (t3 = "node", n2 = e2.process.versions?.node ?? "unknown") : e2.HermesInternal ? (t3 = "hermes", n2 = e2.HermesInternal.getRuntimeProperties?.()["OSS Release Version"] ?? "unknown") : m(e2) && e2.navigator.userAgent === "Cloudflare-Workers" ? t3 = "workerd" : m(e2) && e2.navigator.userAgent.toLowerCase().startsWith("quickjs-ng") ? (t3 = "quickjs-ng", n2 = e2.navigator.userAgent.split("/")[1] ?? "unknown") : typeof e2.Netlify == "object" ? t3 = "netlify" : typeof e2.EdgeRuntime == "string" ? t3 = "edge-light" : e2.__lagon__ ? t3 = "lagon" : e2.fastly ? t3 = "fastly" : e2.$262 && e2.lockdown && e2.AsyncDisposableStack ? t3 = "moddable" : e2.d8 ? (t3 = "v8", n2 = typeof e2.version == "function" ? e2.version() : "unknown") : e2.inIon && e2.performance && e2.performance.mozMemory ? t3 = "spidermonkey" : typeof e2.$ == "object" && e2.$ !== null && "IsHTMLDDA" in e2.$ ? t3 = "jsc" : e2.window && e2.navigator && (t3 = "browser");
+  return {
+    runtime: t3,
+    version: n2
   };
 }
-function i2(e = globalThis) {
-  return typeof e.navigator == "object" && e.navigator !== null && typeof e.navigator.userAgent == "string";
+function m(e2 = globalThis) {
+  return typeof e2.navigator == "object" && e2.navigator !== null && typeof e2.navigator.userAgent == "string";
 }
-var { runtime: a, version: o } = r();
-var m = (async () => {
-}).constructor;
-var P = globalThis.performance.now.bind(globalThis.performance);
-var I = globalThis.process?.hrtime?.bigint.bind(globalThis.process?.hrtime) ?? (() => {
+var { runtime: h2, version: g } = p();
+var _ = globalThis.performance.now.bind(globalThis.performance);
+var y2 = globalThis.process?.hrtime?.bigint.bind(globalThis.process?.hrtime) ?? (() => {
   throw Error("hrtime.bigint() is not supported in this JS environment");
 });
-var z = globalThis.Bun?.nanoseconds;
+var S = globalThis.Bun?.nanoseconds;
 
-// node_modules/vitest/dist/chunks/index.DGdajAO2.js
+// ../../node_modules/vitest/dist/chunks/index.aTZaPVhf.js
 var import_expect_type = __toESM(require_dist(), 1);
 var naturalCompare$1 = { exports: {} };
 var hasRequiredNaturalCompare;
 function requireNaturalCompare() {
   if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
   hasRequiredNaturalCompare = 1;
-  var naturalCompare2 = function(a2, b2) {
+  var naturalCompare2 = function(a, b2) {
     var i3, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
     function getCode(str, pos, code) {
       if (code) {
@@ -11470,11 +11916,11 @@ function requireNaturalCompare() {
       code = alphabet && alphabet.indexOf(str.charAt(pos));
       return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
     }
-    if ((a2 += "") != (b2 += "")) for (; codeB; ) {
-      codeA = getCode(a2, posA++);
+    if ((a += "") != (b2 += "")) for (; codeB; ) {
+      codeA = getCode(a, posA++);
       codeB = getCode(b2, posB++);
       if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
-        codeA = getCode(a2, posA, posA);
+        codeA = getCode(a, posA, posA);
         codeB = getCode(b2, posB, posA = i3);
         posB = i3;
       }
@@ -11484,13 +11930,13 @@ function requireNaturalCompare() {
   };
   try {
     naturalCompare$1.exports = naturalCompare2;
-  } catch (e) {
+  } catch (e2) {
     String.naturalCompare = naturalCompare2;
   }
   return naturalCompare$1.exports;
 }
 var naturalCompareExports = requireNaturalCompare();
-var naturalCompare = /* @__PURE__ */ getDefaultExportFromCjs2(naturalCompareExports);
+var naturalCompare = /* @__PURE__ */ getDefaultExportFromCjs(naturalCompareExports);
 function testNameToKey(testName2, count) {
   return `${testName2} ${count}`;
 }
@@ -11527,7 +11973,7 @@ function serialize3(val, indent = 2, formatOverrides = {}) {
   }));
 }
 function escapeBacktickString(str) {
-  return str.replace(/`|\\|\$\{/g, "\\$&");
+  return str.replace(/`|\\|\$\{/g, "\\$&").replace(/\r/g, "\\r");
 }
 function printBacktickString(str) {
   return `\`${escapeBacktickString(str)}\``;
@@ -11547,12 +11993,12 @@ ${snapshots.join("\n\n")}
 }
 function deepMergeArray(target = [], source = []) {
   const mergedOutput = Array.from(target);
-  source.forEach((sourceElement, index) => {
-    const targetElement = mergedOutput[index];
-    if (Array.isArray(target[index])) mergedOutput[index] = deepMergeArray(target[index], sourceElement);
-    else if (isObject(targetElement)) mergedOutput[index] = deepMergeSnapshot(target[index], sourceElement);
+  source.forEach((sourceElement, index2) => {
+    const targetElement = mergedOutput[index2];
+    if (Array.isArray(target[index2])) mergedOutput[index2] = deepMergeArray(target[index2], sourceElement);
+    else if (isObject(targetElement)) mergedOutput[index2] = deepMergeSnapshot(target[index2], sourceElement);
     else
-      mergedOutput[index] = sourceElement;
+      mergedOutput[index2] = sourceElement;
   });
   return mergedOutput;
 }
@@ -11560,9 +12006,10 @@ function deepMergeSnapshot(target, source) {
   if (isObject(target) && isObject(source)) {
     const mergedOutput = { ...target };
     Object.keys(source).forEach((key) => {
-      if (isObject(source[key]) && !source[key].$$typeof) if (!(key in target)) Object.assign(mergedOutput, { [key]: source[key] });
-      else mergedOutput[key] = deepMergeSnapshot(target[key], source[key]);
-      else if (Array.isArray(source[key])) mergedOutput[key] = deepMergeArray(target[key], source[key]);
+      if (isObject(source[key]) && !source[key].$$typeof) {
+        if (!(key in target)) Object.assign(mergedOutput, { [key]: source[key] });
+        else mergedOutput[key] = deepMergeSnapshot(target[key], source[key]);
+      } else if (Array.isArray(source[key])) mergedOutput[key] = deepMergeArray(target[key], source[key]);
       else Object.assign(mergedOutput, { [key]: source[key] });
     });
     return mergedOutput;
@@ -11633,34 +12080,34 @@ var buildStartObjectRegex = /* @__PURE__ */ memo((assertionName) => {
   const replaced = defaultStartObjectRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
   return new RegExp(replaced);
 });
-function replaceObjectSnap(code, s, index, newSnap, assertionName) {
-  let _code = code.slice(index);
+function replaceObjectSnap(code, s, index2, newSnap, assertionName) {
+  let _code = code.slice(index2);
   const startMatch = (assertionName ? buildStartObjectRegex(assertionName) : defaultStartObjectRegex).exec(_code);
   if (!startMatch) return false;
   _code = _code.slice(startMatch.index);
   let callEnd = getCallLastIndex(_code);
   if (callEnd === null) return false;
-  callEnd += index + startMatch.index;
-  const shapeEnd = getObjectShapeEndIndex(code, index + startMatch.index + startMatch[0].length);
-  const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+  callEnd += index2 + startMatch.index;
+  const shapeEnd = getObjectShapeEndIndex(code, index2 + startMatch.index + startMatch[0].length);
+  const snap = `, ${prepareSnapString(newSnap, code, index2)}`;
   if (shapeEnd === callEnd)
     s.appendLeft(callEnd, snap);
   else
     s.overwrite(shapeEnd, callEnd, snap);
   return true;
 }
-function getObjectShapeEndIndex(code, index) {
+function getObjectShapeEndIndex(code, index2) {
   let startBraces = 1;
   let endBraces = 0;
-  while (startBraces !== endBraces && index < code.length) {
-    const s = code[index++];
+  while (startBraces !== endBraces && index2 < code.length) {
+    const s = code[index2++];
     if (s === "{") startBraces++;
     else if (s === "}") endBraces++;
   }
-  return index;
+  return index2;
 }
-function prepareSnapString(snap, source, index) {
-  const lineNumber = offsetToLineNumber(source, index);
+function prepareSnapString(snap, source, index2) {
+  const lineNumber = offsetToLineNumber(source, index2);
   const indent = source.split(lineSplitRE)[lineNumber - 1].match(/^\s*/)[0] || "";
   const indentNext = indent.includes("	") ? `${indent}	` : `${indent}  `;
   const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
@@ -11672,17 +12119,17 @@ ${lines.map((i3) => i3 ? indentNext + i3 : "").join("\n").replace(/`/g, "\\`").r
 ${indent}${quote}`;
 }
 var defaultMethodNames = ["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"];
-function getCodeStartingAtIndex(code, index, methodNames) {
+function getCodeStartingAtIndex(code, index2, methodNames) {
   for (const name of methodNames) {
-    const adjusted = index - name.length;
-    if (adjusted >= 0 && code.slice(adjusted, index) === name) return {
+    const adjusted = index2 - name.length;
+    if (adjusted >= 0 && code.slice(adjusted, index2) === name) return {
       code: code.slice(adjusted),
       index: adjusted
     };
   }
   return {
-    code: code.slice(index),
-    index
+    code: code.slice(index2),
+    index: index2
   };
 }
 var defaultStartRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
@@ -11691,13 +12138,13 @@ var buildStartRegex = /* @__PURE__ */ memo((assertionName) => {
   return new RegExp(replaced);
 });
 function replaceInlineSnap(code, s, currentIndex, newSnap, assertionName) {
-  const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex, assertionName ? [assertionName] : defaultMethodNames);
+  const { code: codeStartingAtIndex, index: index2 } = getCodeStartingAtIndex(code, currentIndex, assertionName ? [assertionName] : defaultMethodNames);
   const startMatch = (assertionName ? buildStartRegex(assertionName) : defaultStartRegex).exec(codeStartingAtIndex);
   const firstKeywordMatch = (assertionName ? new RegExp(escapeRegExp(assertionName)) : /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/).exec(codeStartingAtIndex);
-  if (!startMatch || startMatch.index !== firstKeywordMatch?.index) return replaceObjectSnap(code, s, index, newSnap, assertionName);
+  if (!startMatch || startMatch.index !== firstKeywordMatch?.index) return replaceObjectSnap(code, s, index2, newSnap, assertionName);
   const quote = startMatch[1];
-  const startIndex = index + startMatch.index + startMatch[0].length;
-  const snapString = prepareSnapString(newSnap, code, index);
+  const startIndex = index2 + startMatch.index + startMatch[0].length;
+  const snapString = prepareSnapString(newSnap, code, index2);
   if (quote === ")") {
     s.appendRight(startIndex - 1, snapString);
     return true;
@@ -11733,8 +12180,8 @@ async function saveRawSnapshots(environment, snapshots) {
     if (!snap.readonly) await environment.saveSnapshotFile(snap.file, snap.snapshot);
   }));
 }
-function isSameStackPosition(x, y2) {
-  return x.file === y2.file && x.column === y2.column && x.line === y2.line;
+function isSameStackPosition(x, y3) {
+  return x.file === y3.file && x.column === y3.column && x.line === y3.line;
 }
 var SnapshotState = class _SnapshotState {
   constructor(testFilePath, snapshotPath, fileData, options) {
@@ -11749,6 +12196,7 @@ var SnapshotState = class _SnapshotState {
     __publicField(this, "_inlineSnapshotStacks");
     __publicField(this, "_testIdToKeys", new DefaultMap(() => []));
     __publicField(this, "_rawSnapshots");
+    __publicField(this, "_rawSnapshotFiles", /* @__PURE__ */ new Set());
     __publicField(this, "_uncheckedKeys");
     __publicField(this, "_snapshotFormat");
     __publicField(this, "_environment");
@@ -11916,17 +12364,18 @@ ${message}`);
   }
   _reconcile(opts) {
     if (opts.hasSnapshot && this._updateSnapshot === "all" || (!opts.hasSnapshot || !opts.snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-      if (this._updateSnapshot === "all") if (!opts.pass) {
-        if (opts.hasSnapshot) this.updated.increment(opts.testId);
-        else this.added.increment(opts.testId);
-        this._addSnapshot(opts.key, opts.addValue, {
-          stack: opts.stack,
-          testId: opts.testId,
-          rawSnapshot: opts.rawSnapshot,
-          assertionName: opts.assertionName
-        });
-      } else this.matched.increment(opts.testId);
-      else {
+      if (this._updateSnapshot === "all") {
+        if (!opts.pass) {
+          if (opts.hasSnapshot) this.updated.increment(opts.testId);
+          else this.added.increment(opts.testId);
+          this._addSnapshot(opts.key, opts.addValue, {
+            stack: opts.stack,
+            testId: opts.testId,
+            rawSnapshot: opts.rawSnapshot,
+            assertionName: opts.assertionName
+          });
+        } else this.matched.increment(opts.testId);
+      } else {
         this._addSnapshot(opts.key, opts.addValue, {
           stack: opts.stack,
           testId: opts.testId,
@@ -12023,6 +12472,7 @@ ${message}`);
     let receivedSerialized = rawSnapshot && typeof received === "string" ? received : serialize3(received, void 0, this._snapshotFormat);
     if (!rawSnapshot) receivedSerialized = addExtraLineBreaks(receivedSerialized);
     if (rawSnapshot) {
+      this._rawSnapshotFiles.add(rawSnapshot.file);
       if (rawSnapshot.content && /\r\n/.test(rawSnapshot.content) && !/\r\n/.test(receivedSerialized)) rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
     }
     const expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];
@@ -12076,6 +12526,14 @@ ${message}`);
       assertionName
     });
   }
+  /**
+  * The snapshot file, if the test file stores snapshots in it, and every asserted file snapshot.
+  */
+  getSnapshotFiles() {
+    const files = Array.from(this._rawSnapshotFiles);
+    if (this._fileExists || Object.keys(this._snapshotData).length) files.unshift(this.snapshotPath);
+    return files;
+  }
   async pack() {
     const snapshot = {
       filepath: this.testFilePath,
@@ -12253,9 +12711,9 @@ var SnapshotClient = class {
       adapter,
       poll: () => poll({ signal: timeoutController.signal }),
       interval,
-      timedOut: timeout > 0 ? new Promise((r2) => setTimeout(() => {
+      timedOut: timeout > 0 ? new Promise((r) => setTimeout(() => {
         timeoutController.abort();
-        r2();
+        r();
       }, timeout)) : void 0,
       match: reference ? (captured) => adapter.match(captured, reference).pass : void 0
     });
@@ -12325,7 +12783,7 @@ async function getStableSnapshot({ adapter, poll, interval, timedOut, match }) {
       lastStable = void 0;
       lastPollError = pollError;
     }
-    if (!(await raceWith$1(new Promise((r2) => setTimeout(r2, interval)), timedOut)).ok) break;
+    if (!(await raceWith$1(new Promise((r) => setTimeout(r, interval)), timedOut)).ok) break;
   }
   return {
     ...lastStable,
@@ -12374,7 +12832,7 @@ var ChaiStyleAssertions = (chai, utils) => {
   defMethod("calledOnceWith", "toHaveBeenCalledExactlyOnceWith");
   defMethod("lastCalledWith", "toHaveBeenLastCalledWith");
   defMethod("nthCalledWith", "toHaveBeenNthCalledWith");
-  defMethod("returned", "toHaveReturned");
+  defMethod("returned", "toHaveReturnedWith");
   defMethod("returnedWith", "toHaveReturnedWith");
   defMethod("returnedTimes", "toHaveReturnedTimes");
   defMethod("lastReturnedWith", "toHaveLastReturnedWith");
@@ -12408,10 +12866,11 @@ ${printReceived3(actual)}`
   },
   toBeOneOf(actual, expected) {
     const { equals: equals2, customTesters } = this;
-    const { printReceived: printReceived3, printExpected: printExpected3, matcherHint: matcherHint2 } = this.utils;
+    const { printReceived: printReceived3, printExpected: printExpected3, matcherHint: matcherHint2, iterableEquality: iterableEquality2 } = this.utils;
+    const testers = [...customTesters, iterableEquality2];
     let pass;
-    if (Array.isArray(expected)) pass = expected.length === 0 || expected.some((item) => equals2(item, actual, customTesters));
-    else if (expected instanceof Set) pass = expected.size === 0 || expected.has(actual) || [...expected].some((item) => equals2(item, actual, customTesters));
+    if (Array.isArray(expected)) pass = expected.length === 0 || expected.some((item) => equals2(item, actual, testers));
+    else if (expected instanceof Set) pass = expected.size === 0 || expected.has(actual) || [...expected].some((item) => equals2(item, actual, testers));
     else throw new TypeError(`You must provide an array or set to ${matcherHint2(".toBeOneOf")}, not '${typeof expected}'.`);
     return {
       pass,
@@ -12430,11 +12889,11 @@ ${printReceived3(actual)}`
     };
   }
 };
-var EXPECTED_COLOR = y.green;
-var RECEIVED_COLOR = y.red;
-var INVERTED_COLOR = y.inverse;
-var BOLD_WEIGHT = y.bold;
-var DIM_COLOR = y.dim;
+var EXPECTED_COLOR = $.green;
+var RECEIVED_COLOR = $.red;
+var INVERTED_COLOR = $.inverse;
+var BOLD_WEIGHT = $.bold;
+var DIM_COLOR = $.dim;
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
   const { comment = "", isDirectExpectCall = false, isNot = false, promise = "", secondArgument = "", expectedColor = EXPECTED_COLOR, receivedColor = RECEIVED_COLOR, secondArgumentColor = EXPECTED_COLOR } = options;
   let hint = "";
@@ -12504,20 +12963,20 @@ function addCustomEqualityTesters(newTesters) {
 function getCustomEqualityTesters() {
   return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
 }
-function equals(a2, b2, customTesters, strictCheck) {
+function equals(a, b2, customTesters, strictCheck) {
   customTesters = customTesters || [];
-  return eq(a2, b2, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+  return eq(a, b2, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
 }
 function isAsymmetric(obj) {
   return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
 }
-function asymmetricMatch(a2, b2, customTesters) {
-  const asymmetricA = isAsymmetric(a2);
+function asymmetricMatch(a, b2, customTesters) {
+  const asymmetricA = isAsymmetric(a);
   const asymmetricB = isAsymmetric(b2);
   if (asymmetricA && asymmetricB) return;
   const testers = customTesters.filter((tester) => !isSubsetEqualityTester(tester));
-  if (asymmetricA) return a2.asymmetricMatch(b2, testers);
-  if (asymmetricB) return b2.asymmetricMatch(a2, testers);
+  if (asymmetricA) return a.asymmetricMatch(b2, testers);
+  if (asymmetricB) return b2.asymmetricMatch(a, testers);
 }
 function isError(value) {
   if (typeof Error.isError === "function") return Error.isError(value);
@@ -12530,38 +12989,38 @@ function isError(value) {
       return value instanceof Error;
   }
 }
-function eq(a2, b2, aStack, bStack, customTesters, hasKey2) {
+function eq(a, b2, aStack, bStack, customTesters, hasKey2) {
   let result = true;
-  const asymmetricResult = asymmetricMatch(a2, b2, customTesters);
+  const asymmetricResult = asymmetricMatch(a, b2, customTesters);
   if (asymmetricResult !== void 0) return asymmetricResult;
   const testerContext = { equals };
   for (let i3 = 0; i3 < customTesters.length; i3++) {
-    const customTesterResult = customTesters[i3].call(testerContext, a2, b2, customTesters);
+    const customTesterResult = customTesters[i3].call(testerContext, a, b2, customTesters);
     if (customTesterResult !== void 0) return customTesterResult;
   }
-  if (typeof URL === "function" && a2 instanceof URL && b2 instanceof URL) return a2.href === b2.href;
-  if (Object.is(a2, b2)) return true;
-  if (a2 === null || b2 === null) return a2 === b2;
-  const className = Object.prototype.toString.call(a2);
+  if (typeof URL === "function" && a instanceof URL && b2 instanceof URL) return a.href === b2.href;
+  if (Object.is(a, b2)) return true;
+  if (a === null || b2 === null) return a === b2;
+  const className = Object.prototype.toString.call(a);
   if (className !== Object.prototype.toString.call(b2)) return false;
   switch (className) {
     case "[object Boolean]":
     case "[object String]":
     case "[object Number]":
-      if (typeof a2 !== typeof b2)
+      if (typeof a !== typeof b2)
         return false;
-      else if (typeof a2 !== "object" && typeof b2 !== "object")
-        return Object.is(a2, b2);
+      else if (typeof a !== "object" && typeof b2 !== "object")
+        return Object.is(a, b2);
       else
-        return Object.is(a2.valueOf(), b2.valueOf());
+        return Object.is(a.valueOf(), b2.valueOf());
     case "[object Date]": {
-      const numA = +a2;
+      const numA = +a;
       const numB = +b2;
       return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
     }
     // RegExps are compared by their source patterns and flags.
     case "[object RegExp]":
-      return a2.source === b2.source && a2.flags === b2.flags;
+      return a.source === b2.source && a.flags === b2.flags;
     case "[object Temporal.Instant]":
     case "[object Temporal.ZonedDateTime]":
     case "[object Temporal.PlainDateTime]":
@@ -12569,43 +13028,43 @@ function eq(a2, b2, aStack, bStack, customTesters, hasKey2) {
     case "[object Temporal.PlainTime]":
     case "[object Temporal.PlainYearMonth]":
     case "[object Temporal.PlainMonthDay]":
-      return a2.equals(b2);
+      return a.equals(b2);
     case "[object Temporal.Duration]":
-      return a2.toString() === b2.toString();
+      return a.toString() === b2.toString();
   }
-  if (typeof a2 !== "object" || typeof b2 !== "object") return false;
-  if (isDomNode(a2) && isDomNode(b2)) return a2.isEqualNode(b2);
+  if (typeof a !== "object" || typeof b2 !== "object") return false;
+  if (isDomNode(a) && isDomNode(b2)) return a.isEqualNode(b2);
   let length = aStack.length;
   while (length--)
-    if (aStack[length] === a2) return bStack[length] === b2;
+    if (aStack[length] === a) return bStack[length] === b2;
     else if (bStack[length] === b2) return false;
-  aStack.push(a2);
+  aStack.push(a);
   bStack.push(b2);
-  if (className === "[object Array]" && a2.length !== b2.length) return false;
-  if (isError(a2) && isError(b2)) try {
-    return isErrorEqual(a2, b2, aStack, bStack, customTesters, hasKey2);
+  if (className === "[object Array]" && a.length !== b2.length) return false;
+  if (isError(a) && isError(b2)) try {
+    return isErrorEqual(a, b2, aStack, bStack, customTesters, hasKey2);
   } finally {
     aStack.pop();
     bStack.pop();
   }
-  const aKeys = keys(a2, hasKey2);
+  const aKeys = keys(a, hasKey2);
   let key;
   let size = aKeys.length;
   if (keys(b2, hasKey2).length !== size) return false;
   while (size--) {
     key = aKeys[size];
-    result = hasKey2(b2, key) && eq(a2[key], b2[key], aStack, bStack, customTesters, hasKey2);
+    result = hasKey2(b2, key) && eq(a[key], b2[key], aStack, bStack, customTesters, hasKey2);
     if (!result) return false;
   }
   aStack.pop();
   bStack.pop();
   return result;
 }
-function isErrorEqual(a2, b2, aStack, bStack, customTesters, hasKey2) {
-  let result = Object.prototype.toString.call(a2) === Object.prototype.toString.call(b2) && a2.name === b2.name && a2.message === b2.message;
-  if (typeof b2.cause !== "undefined") result && (result = eq(a2.cause, b2.cause, aStack, bStack, customTesters, hasKey2));
-  if (a2 instanceof AggregateError && b2 instanceof AggregateError) result && (result = eq(a2.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
-  result && (result = eq({ ...a2 }, { ...b2 }, aStack, bStack, customTesters, hasKey2));
+function isErrorEqual(a, b2, aStack, bStack, customTesters, hasKey2) {
+  let result = Object.prototype.toString.call(a) === Object.prototype.toString.call(b2) && a.name === b2.name && a.message === b2.message;
+  if (typeof b2.cause !== "undefined") result && (result = eq(a.cause, b2.cause, aStack, bStack, customTesters, hasKey2));
+  if (a instanceof AggregateError && b2 instanceof AggregateError) result && (result = eq(a.errors, b2.errors, aStack, bStack, customTesters, hasKey2));
+  result && (result = eq({ ...a }, { ...b2 }, aStack, bStack, customTesters, hasKey2));
   return result;
 }
 function keys(obj, hasKey2) {
@@ -12655,23 +13114,23 @@ var IteratorSymbol = Symbol.iterator;
 function hasIterator(object2) {
   return !!(object2 != null && object2[IteratorSymbol]);
 }
-function iterableEquality(a2, b2, customTesters = [], aStack = [], bStack = []) {
-  if (typeof a2 !== "object" || typeof b2 !== "object" || Array.isArray(a2) || Array.isArray(b2) || !hasIterator(a2) || !hasIterator(b2)) return;
-  if (a2.constructor !== b2.constructor) return false;
+function iterableEquality(a, b2, customTesters = [], aStack = [], bStack = []) {
+  if (typeof a !== "object" || typeof b2 !== "object" || Array.isArray(a) || Array.isArray(b2) || !hasIterator(a) || !hasIterator(b2)) return;
+  if (a.constructor !== b2.constructor) return false;
   let length = aStack.length;
   while (length--)
-    if (aStack[length] === a2) return bStack[length] === b2;
-  aStack.push(a2);
+    if (aStack[length] === a) return bStack[length] === b2;
+  aStack.push(a);
   bStack.push(b2);
-  const filteredCustomTesters = [...customTesters.filter((t2) => t2 !== iterableEquality), iterableEqualityWithStack];
-  function iterableEqualityWithStack(a3, b3) {
-    return iterableEquality(a3, b3, [...customTesters], [...aStack], [...bStack]);
+  const filteredCustomTesters = [...customTesters.filter((t3) => t3 !== iterableEquality), iterableEqualityWithStack];
+  function iterableEqualityWithStack(a2, b3) {
+    return iterableEquality(a2, b3, [...customTesters], [...aStack], [...bStack]);
   }
-  if (a2.size !== void 0) {
-    if (a2.size !== b2.size) return false;
-    else if (isA("Set", a2) || isImmutableUnorderedSet(a2)) {
+  if (a.size !== void 0) {
+    if (a.size !== b2.size) return false;
+    else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
       let allFound = true;
-      for (const aValue of a2) if (!b2.has(aValue)) {
+      for (const aValue of a) if (!b2.has(aValue)) {
         let has = false;
         for (const bValue of b2) if (equals(aValue, bValue, filteredCustomTesters) === true) has = true;
         if (has === false) {
@@ -12682,9 +13141,9 @@ function iterableEquality(a2, b2, customTesters = [], aStack = [], bStack = [])
       aStack.pop();
       bStack.pop();
       return allFound;
-    } else if (isA("Map", a2) || isImmutableUnorderedKeyed(a2)) {
+    } else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
       let allFound = true;
-      for (const aEntry of a2) if (!b2.has(aEntry[0]) || !equals(aEntry[1], b2.get(aEntry[0]), filteredCustomTesters)) {
+      for (const aEntry of a) if (!b2.has(aEntry[0]) || !equals(aEntry[1], b2.get(aEntry[0]), filteredCustomTesters)) {
         let has = false;
         for (const bEntry of b2) {
           const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
@@ -12703,13 +13162,13 @@ function iterableEquality(a2, b2, customTesters = [], aStack = [], bStack = [])
     }
   }
   const bIterator = b2[IteratorSymbol]();
-  for (const aValue of a2) {
+  for (const aValue of a) {
     const nextB = bIterator.next();
     if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) return false;
   }
   if (!bIterator.next().done) return false;
-  if (!isImmutableList(a2) && !isImmutableOrderedKeyed(a2) && !isImmutableOrderedSet(a2) && !isImmutableRecord(a2)) {
-    if (!equals(Object.entries(a2), Object.entries(b2), filteredCustomTesters)) return false;
+  if (!isImmutableList(a) && !isImmutableOrderedKeyed(a) && !isImmutableOrderedSet(a) && !isImmutableRecord(a)) {
+    if (!equals(Object.entries(a), Object.entries(b2), filteredCustomTesters)) return false;
   }
   aStack.pop();
   bStack.pop();
@@ -12719,8 +13178,8 @@ function hasPropertyInObject(object2, key) {
   if (!object2 || typeof object2 !== "object" || object2 === Object.prototype) return false;
   return Object.hasOwn(object2, key) || hasPropertyInObject(Object.getPrototypeOf(object2), key);
 }
-function isObjectWithKeys(a2) {
-  return isObject(a2) && !isError(a2) && !Array.isArray(a2) && !(a2 instanceof Date) && !(a2 instanceof Set) && !(a2 instanceof Map);
+function isObjectWithKeys(a) {
+  return isObject(a) && !isError(a) && !Array.isArray(a) && !(a instanceof Date) && !(a instanceof Set) && !(a instanceof Map);
 }
 var subsetEqualityTesters = /* @__PURE__ */ new WeakSet();
 function registerSubsetEqualityTester(tester) {
@@ -12731,7 +13190,7 @@ function isSubsetEqualityTester(tester) {
   return tester === subsetEquality || subsetEqualityTesters.has(tester);
 }
 function subsetEquality(object2, subset, customTesters = []) {
-  const filteredCustomTesters = customTesters.filter((t2) => t2 !== subsetEquality);
+  const filteredCustomTesters = customTesters.filter((t3) => t3 !== subsetEquality);
   const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => registerSubsetEqualityTester((object3, subset2) => {
     if (!isObjectWithKeys(subset2)) return;
     return Object.keys(subset2).every((key) => {
@@ -12746,17 +13205,17 @@ function subsetEquality(object2, subset, customTesters = []) {
   });
   return subsetEqualityWithContext()(object2, subset);
 }
-function typeEquality(a2, b2) {
-  if (a2 == null || b2 == null || a2.constructor === b2.constructor) return;
+function typeEquality(a, b2) {
+  if (a == null || b2 == null || a.constructor === b2.constructor) return;
   return false;
 }
-function arrayBufferEquality(a2, b2) {
-  let dataViewA = a2;
+function arrayBufferEquality(a, b2) {
+  let dataViewA = a;
   let dataViewB = b2;
-  if (!(a2 instanceof DataView && b2 instanceof DataView)) {
-    if (!(a2 instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) return;
+  if (!(a instanceof DataView && b2 instanceof DataView)) {
+    if (!(a instanceof ArrayBuffer) || !(b2 instanceof ArrayBuffer)) return;
     try {
-      dataViewA = new DataView(a2);
+      dataViewA = new DataView(a);
       dataViewB = new DataView(b2);
     } catch {
       return;
@@ -12766,11 +13225,11 @@ function arrayBufferEquality(a2, b2) {
   for (let i3 = 0; i3 < dataViewA.byteLength; i3++) if (dataViewA.getUint8(i3) !== dataViewB.getUint8(i3)) return false;
   return true;
 }
-function sparseArrayEquality(a2, b2, customTesters = []) {
-  if (!Array.isArray(a2) || !Array.isArray(b2)) return;
-  const aKeys = Object.keys(a2);
+function sparseArrayEquality(a, b2, customTesters = []) {
+  if (!Array.isArray(a) || !Array.isArray(b2)) return;
+  const aKeys = Object.keys(a);
   const bKeys = Object.keys(b2);
-  return equals(a2, b2, customTesters.filter((t2) => t2 !== sparseArrayEquality), true) && equals(aKeys, bKeys);
+  return equals(a, b2, customTesters.filter((t3) => t3 !== sparseArrayEquality), true) && equals(aKeys, bKeys);
 }
 function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
@@ -13110,8 +13569,8 @@ function recordAsyncExpect(_test2, promise, assertion, error, isSoft) {
   if (test5 && promise instanceof Promise) {
     promise = promise.finally(() => {
       if (!test5.promises) return;
-      const index = test5.promises.indexOf(promise);
-      if (index !== -1) test5.promises.splice(index, 1);
+      const index2 = test5.promises.indexOf(promise);
+      if (index2 !== -1) test5.promises.splice(index2, 1);
     });
     if (!test5.promises) test5.promises = [];
     if (isSoft) promise = promise.then(noop, (err) => {
@@ -13149,10 +13608,10 @@ await ${assertion}
   return promise;
 }
 function handleTestError(test5, err) {
-  var _a2;
+  var _a;
   test5.result || (test5.result = { state: "fail" });
   test5.result.state = "fail";
-  (_a2 = test5.result).errors || (_a2.errors = []);
+  (_a = test5.result).errors || (_a.errors = []);
   test5.result.errors.push(processError(err));
 }
 function wrapAssertion(utils, name, fn2) {
@@ -13180,12 +13639,12 @@ var JestChaiExpect = (chai, utils) => {
   const { AssertionError: AssertionError2 } = chai;
   const customTesters = getCustomEqualityTesters();
   function def(name, fn2) {
-    const addMethod2 = (n3) => {
-      const softWrapper = wrapAssertion(utils, n3, fn2);
-      utils.addMethod(chai.Assertion.prototype, n3, softWrapper);
-      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, n3, softWrapper);
+    const addMethod2 = (n2) => {
+      const softWrapper = wrapAssertion(utils, n2, fn2);
+      utils.addMethod(chai.Assertion.prototype, n2, softWrapper);
+      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, n2, softWrapper);
     };
-    if (Array.isArray(name)) name.forEach((n3) => addMethod2(n3));
+    if (Array.isArray(name)) name.forEach((n2) => addMethod2(n2));
     else addMethod2(name);
   }
   [
@@ -13201,10 +13660,12 @@ var JestChaiExpect = (chai, utils) => {
         if (promise === "rejects") utils.flag(this, "object", () => {
           throw object2;
         });
-        else if (promise === "resolves" && typeof object2 !== "function") if (!isNot) {
-          const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
-          throw new AssertionError2(message, { showDiff: false }, utils.flag(this, "ssfi"));
-        } else return;
+        else if (promise === "resolves" && typeof object2 !== "function") {
+          if (!isNot) {
+            const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
+            throw new AssertionError2(message, { showDiff: false }, utils.flag(this, "ssfi"));
+          } else return;
+        }
         _super.apply(this, args);
       };
     });
@@ -13294,10 +13755,10 @@ var JestChaiExpect = (chai, utils) => {
   });
   def("toContainEqual", function(expected) {
     const obj = utils.flag(this, "object");
-    const index = Array.from(obj).findIndex((item) => {
-      return equals(item, expected, customTesters);
+    const index2 = Array.from(obj).findIndex((item) => {
+      return equals(item, expected, [...customTesters, iterableEquality]);
     });
-    this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
+    this.assert(index2 !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
   });
   def("toBeTruthy", function() {
     const obj = utils.flag(this, "object");
@@ -13375,7 +13836,7 @@ var JestChaiExpect = (chai, utils) => {
       return utils.getPathInfo(actual, propertyName);
     };
     const { value, exists } = getValue();
-    const pass = exists && (args.length === 1 || equals(expected, value, customTesters));
+    const pass = exists && (args.length === 1 || equals(expected, value, [...customTesters, iterableEquality]));
     const valueString = args.length === 1 ? "" : ` with value ${inspect(expected, { truncate: 40 })}`;
     return this.assert(pass, `expected #{this} to have property "${propertyName}"${valueString}`, `expected #{this} to not have property "${propertyName}"${valueString}`, expected, exists ? value : void 0);
   });
@@ -13428,8 +13889,8 @@ var JestChaiExpect = (chai, utils) => {
     if (called && isNot) msg = formatCalls(spy, msg);
     if (called && isNot || !called && !isNot) throw new AssertionError2(msg);
   });
-  function equalsArgumentArray(a2, b2) {
-    return a2.length === b2.length && a2.every((aItem, i3) => equals(aItem, b2[i3], [...customTesters, iterableEquality]));
+  function equalsArgumentArray(a, b2) {
+    return a.length === b2.length && a.every((aItem, i3) => equals(aItem, b2[i3], [...customTesters, iterableEquality]));
   }
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
@@ -13500,11 +13961,12 @@ var JestChaiExpect = (chai, utils) => {
     const isNot = utils.flag(this, "negate");
     let thrown = null;
     if (promise === "rejects") thrown = obj;
-    else if (promise === "resolves" && typeof obj !== "function") if (!isNot) {
-      const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
-      throw new AssertionError2(message, { showDiff: false }, utils.flag(this, "ssfi"));
-    } else return;
-    else {
+    else if (promise === "resolves" && typeof obj !== "function") {
+      if (!isNot) {
+        const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
+        throw new AssertionError2(message, { showDiff: false }, utils.flag(this, "ssfi"));
+      } else return;
+    } else {
       let isThrow = false;
       try {
         obj();
@@ -13527,7 +13989,7 @@ var JestChaiExpect = (chai, utils) => {
     }
     if (typeof expected === "object" && "asymmetricMatch" in expected && typeof expected.asymmetricMatch === "function") {
       const matcher = expected;
-      return this.assert(thrown && matcher.asymmetricMatch(thrown), "expected error to match asymmetric matcher", "expected error not to match asymmetric matcher", matcher, thrown);
+      return this.assert(thrown && matcher.asymmetricMatch(thrown, [...customTesters, iterableEquality]), "expected error to match asymmetric matcher", "expected error not to match asymmetric matcher", matcher, thrown);
     }
     const equal = equals(thrown, expected, [...customTesters, iterableEquality]);
     return this.assert(equal, "expected a thrown value to equal #{exp}", "expected a thrown value not to equal #{exp}", expected, thrown);
@@ -13566,11 +14028,11 @@ var JestChaiExpect = (chai, utils) => {
   });
   [{
     name: "toHaveResolvedWith",
-    condition: (spy, value) => spy.mock.settledResults.some(({ type: type3, value: result }) => type3 === "fulfilled" && equals(value, result)),
+    condition: (spy, value) => spy.mock.settledResults.some(({ type: type3, value: result }) => type3 === "fulfilled" && equals(value, result, [...customTesters, iterableEquality])),
     action: "resolve"
   }, {
     name: ["toHaveReturnedWith", "toReturnWith"],
-    condition: (spy, value) => spy.mock.results.some(({ type: type3, value: result }) => type3 === "return" && equals(value, result)),
+    condition: (spy, value) => spy.mock.results.some(({ type: type3, value: result }) => type3 === "return" && equals(value, result, [...customTesters, iterableEquality])),
     action: "return"
   }].forEach(({ name, condition, action }) => {
     def(name, function(value) {
@@ -13594,14 +14056,14 @@ var JestChaiExpect = (chai, utils) => {
     name: "toHaveLastResolvedWith",
     condition: (spy, value) => {
       const result = spy.mock.settledResults.at(-1);
-      return Boolean(result && result.type === "fulfilled" && equals(result.value, value));
+      return Boolean(result && result.type === "fulfilled" && equals(result.value, value, [...customTesters, iterableEquality]));
     },
     action: "resolve"
   }, {
     name: "toHaveLastReturnedWith",
     condition: (spy, value) => {
       const result = spy.mock.results.at(-1);
-      return Boolean(result && result.type === "return" && equals(result.value, value));
+      return Boolean(result && result.type === "return" && equals(result.value, value, [...customTesters, iterableEquality]));
     },
     action: "return"
   }].forEach(({ name, condition, action }) => {
@@ -13614,16 +14076,16 @@ var JestChaiExpect = (chai, utils) => {
   });
   [{
     name: "toHaveNthResolvedWith",
-    condition: (spy, index, value) => {
-      const result = spy.mock.settledResults[index - 1];
-      return result && result.type === "fulfilled" && equals(result.value, value);
+    condition: (spy, index2, value) => {
+      const result = spy.mock.settledResults[index2 - 1];
+      return result && result.type === "fulfilled" && equals(result.value, value, [...customTesters, iterableEquality]);
     },
     action: "resolve"
   }, {
     name: "toHaveNthReturnedWith",
-    condition: (spy, index, value) => {
-      const result = spy.mock.results[index - 1];
-      return result && result.type === "return" && equals(result.value, value);
+    condition: (spy, index2, value) => {
+      const result = spy.mock.results[index2 - 1];
+      return result && result.type === "return" && equals(result.value, value, [...customTesters, iterableEquality]);
     },
     action: "return"
   }].forEach(({ name, condition, action }) => {
@@ -13702,12 +14164,12 @@ var JestChaiExpect = (chai, utils) => {
   });
 };
 function formatCalls(spy, msg, showActualCall) {
-  if (spy.mock.calls.length) msg += y.gray(`
+  if (spy.mock.calls.length) msg += $.gray(`
 
 Received:
 
 ${spy.mock.calls.map((callArg, i3) => {
-    let methodCall = y.bold(`  ${ordinal(i3 + 1)} ${spy.getMockName()} call:
+    let methodCall = $.bold(`  ${ordinal(i3 + 1)} ${spy.getMockName()} call:
 
 `);
     if (showActualCall) methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
@@ -13715,19 +14177,19 @@ ${spy.mock.calls.map((callArg, i3) => {
     methodCall += "\n";
     return methodCall;
   }).join("\n")}`);
-  msg += y.gray(`
+  msg += $.gray(`
 
-Number of calls: ${y.bold(spy.mock.calls.length)}
+Number of calls: ${$.bold(spy.mock.calls.length)}
 `);
   return msg;
 }
 function formatReturns(spy, results, msg, showActualReturn) {
-  if (results.length) msg += y.gray(`
+  if (results.length) msg += $.gray(`
 
 Received:
 
 ${results.map((callReturn, i3) => {
-    let methodCall = y.bold(`  ${ordinal(i3 + 1)} ${spy.getMockName()} call return:
+    let methodCall = $.bold(`  ${ordinal(i3 + 1)} ${spy.getMockName()} call return:
 
 `);
     if (showActualReturn) methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
@@ -13735,9 +14197,9 @@ ${results.map((callReturn, i3) => {
     methodCall += "\n";
     return methodCall;
   }).join("\n")}`);
-  msg += y.gray(`
+  msg += $.gray(`
 
-Number of calls: ${y.bold(spy.mock.calls.length)}
+Number of calls: ${$.bold(spy.mock.calls.length)}
 `);
   return msg;
 }
@@ -13789,8 +14251,8 @@ var JestExtendError = class extends Error {
     this.__vitest_error_context__ = __vitest_error_context__;
   }
 };
-function JestExtendPlugin(c, expect2, matchers) {
-  return (_, utils) => {
+function JestExtendPlugin(c2, expect2, matchers) {
+  return (_2, utils) => {
     Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
       function __VITEST_EXTEND_ASSERTION__(...args) {
         const { state, isNot, obj, customMessage } = getMatcherState(this, expect2);
@@ -13815,17 +14277,21 @@ function JestExtendPlugin(c, expect2, matchers) {
       }
       const softWrapper = wrapAssertion(utils, expectAssertionName, __VITEST_EXTEND_ASSERTION__);
       utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, softWrapper);
-      utils.addMethod(c.Assertion.prototype, expectAssertionName, softWrapper);
+      utils.addMethod(c2.Assertion.prototype, expectAssertionName, softWrapper);
       if (expectAssertion.__vitest_poll_takeover__) {
-        const addedMethod = c.Assertion.prototype[expectAssertionName];
+        const addedMethod = c2.Assertion.prototype[expectAssertionName];
         Object.defineProperty(addedMethod, "__vitest_poll_takeover__", { value: true });
       }
       class CustomMatcher extends AsymmetricMatcher4 {
         constructor(inverse = false, ...sample) {
           super(sample, inverse);
         }
-        asymmetricMatch(other) {
-          const { pass } = expectAssertion.call(this.getMatcherContext(expect2), other, ...this.sample);
+        asymmetricMatch(other, customTesters) {
+          const context = this.getMatcherContext(expect2);
+          const { pass } = expectAssertion.call(customTesters ? {
+            ...context,
+            customTesters
+          } : context, other, ...this.sample);
           return this.inverse ? !pass : pass;
         }
         toString() {
@@ -13957,7 +14423,7 @@ function requireThrowsOnProto() {
     const object2 = {};
     object2.__proto__;
     throwsOnProto = false;
-  } catch (_) {
+  } catch (_2) {
     throwsOnProto = true;
   }
   throwsOnProto_1 = throwsOnProto;
@@ -14018,10 +14484,10 @@ function requireCalledInOrder() {
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index, spies) {
+  function checkAdjacentCalls(callMap, spy, index2, spies) {
     var calledBeforeNext = true;
-    if (index !== spies.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    if (index2 !== spies.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -14093,7 +14559,7 @@ function requireEvery() {
           throw new Error();
         }
       });
-    } catch (e) {
+    } catch (e2) {
       pass = false;
     }
     return pass;
@@ -14115,7 +14581,7 @@ function requireFunctionName() {
       // doesn't debugging will be slightly less informative
       // (i.e. toString will say 'spy' rather than 'myFunc').
       (String(func).match(/function ([^\s(]+)/) || [])[1];
-    } catch (e) {
+    } catch (e2) {
       return "";
     }
   };
@@ -14128,8 +14594,8 @@ function requireOrderByFirstCall() {
   hasRequiredOrderByFirstCall = 1;
   var sort2 = requireArray().sort;
   var slice = requireArray().slice;
-  function comparator(a2, b2) {
-    var aCall = a2.getCall(0);
+  function comparator(a, b2) {
+    var aCall = a.getCall(0);
     var bCall = b2.getCall(0);
     var aId = aCall && aCall.callId || -1;
     var bId = bCall && bCall.callId || -1;
@@ -14766,18 +15232,18 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
        * @returns {boolean}
        */
       remove(timer) {
-        const index = timer.heapIndex;
-        if (index === void 0 || this.timers[index] !== timer) {
+        const index2 = timer.heapIndex;
+        if (index2 === void 0 || this.timers[index2] !== timer) {
           return false;
         }
         const last = this.timers.pop();
         if (timer !== last) {
-          this.timers[index] = last;
-          last.heapIndex = index;
+          this.timers[index2] = last;
+          last.heapIndex = index2;
           if (compareTimers(last, timer) < 0) {
-            this.bubbleUp(index);
+            this.bubbleUp(index2);
           } else {
-            this.bubbleDown(index);
+            this.bubbleDown(index2);
           }
         }
         delete timer.heapIndex;
@@ -14792,9 +15258,9 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
        * swapping it upward until it is no longer out of place.
        * @param {number} index
        */
-      bubbleUp(index) {
-        const timer = this.timers[index];
-        let currentIndex = index;
+      bubbleUp(index2) {
+        const timer = this.timers[index2];
+        let currentIndex = index2;
         while (currentIndex > 0) {
           const parentIndex = Math.floor((currentIndex - 1) / 2);
           const parent = this.timers[parentIndex];
@@ -14819,9 +15285,9 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
        * room is ordered again.
        * @param {number} index
        */
-      bubbleDown(index) {
-        const timer = this.timers[index];
-        let currentIndex = index;
+      bubbleDown(index2) {
+        const timer = this.timers[index2];
+        let currentIndex = index2;
         const halfLength = Math.floor(this.timers.length / 2);
         while (currentIndex < halfLength) {
           const leftIndex = currentIndex * 2 + 1;
@@ -14960,41 +15426,41 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return timer.id;
     }
-    function compareTimers(a2, b2) {
-      if (a2.type === "IdleCallback" && b2.type !== "IdleCallback") {
+    function compareTimers(a, b2) {
+      if (a.type === "IdleCallback" && b2.type !== "IdleCallback") {
         return 1;
       }
-      if (a2.type !== "IdleCallback" && b2.type === "IdleCallback") {
+      if (a.type !== "IdleCallback" && b2.type === "IdleCallback") {
         return -1;
       }
-      if (a2.callAt < b2.callAt) {
+      if (a.callAt < b2.callAt) {
         return -1;
       }
-      if (a2.callAt > b2.callAt) {
+      if (a.callAt > b2.callAt) {
         return 1;
       }
-      if (a2.immediate && !b2.immediate) {
+      if (a.immediate && !b2.immediate) {
         return -1;
       }
-      if (!a2.immediate && b2.immediate) {
+      if (!a.immediate && b2.immediate) {
         return 1;
       }
-      if (a2.order < b2.order) {
+      if (a.order < b2.order) {
         return -1;
       }
-      if (a2.order > b2.order) {
+      if (a.order > b2.order) {
         return 1;
       }
-      if (a2.createdAt < b2.createdAt) {
+      if (a.createdAt < b2.createdAt) {
         return -1;
       }
-      if (a2.createdAt > b2.createdAt) {
+      if (a.createdAt > b2.createdAt) {
         return 1;
       }
-      if (a2.id < b2.id) {
+      if (a.id < b2.id) {
         return -1;
       }
-      if (a2.id > b2.id) {
+      if (a.id > b2.id) {
         return 1;
       }
       return 0;
@@ -15523,8 +15989,8 @@ ${stackTrace}`
             try {
               runJobs(clock);
               callTimer(clock, state.timer);
-            } catch (e) {
-              state.firstException = state.firstException || e;
+            } catch (e2) {
+              state.firstException = state.firstException || e2;
             }
             if (isAsync) {
               originalSetTimeout(nextPromiseTick);
@@ -15545,8 +16011,8 @@ ${stackTrace}`
         if (state.timer) {
           try {
             clock.tick(state.tickTo - clock.now);
-          } catch (e) {
-            state.firstException = state.firstException || e;
+          } catch (e2) {
+            state.firstException = state.firstException || e2;
           }
         } else {
           clock.now = state.tickTo;
@@ -15576,8 +16042,8 @@ ${stackTrace}`
             compensationCheck();
             selectNextTimerInRange(state);
             doTickInner();
-          } catch (e) {
-            reject(e);
+          } catch (e2) {
+            reject(e2);
           }
         };
         function doTickInner() {
@@ -15620,8 +16086,8 @@ ${stackTrace}`
             originalSetTimeout(function() {
               try {
                 callback(resolve2, reject);
-              } catch (e) {
-                reject(e);
+              } catch (e2) {
+                reject(e2);
               }
             });
           })
@@ -15674,8 +16140,8 @@ ${stackTrace}`
             clock.now = timer.callAt;
             try {
               callTimer(clock, timer);
-            } catch (e) {
-              err = e;
+            } catch (e2) {
+              err = e2;
             }
             clock.duringTick = false;
             originalSetTimeout(function() {
@@ -15715,8 +16181,8 @@ ${stackTrace}`
               }
               const excessJob = firstTimer(clock);
               reject(getInfiniteLoopError(clock, excessJob));
-            } catch (e) {
-              reject(e);
+            } catch (e2) {
+              reject(e2);
             }
           }
           return runAsyncWithNativeTimeout(function(resolve2, reject) {
@@ -16318,13 +16784,15 @@ var FakeTimers = class {
     return 0;
   }
   setTimerTickMode(mode, interval) {
-    if (this._checkFakeTimers()) if (mode === "manual") this._clock.setTickMode({ mode: "manual" });
-    else if (mode === "nextTimerAsync") this._clock.setTickMode({ mode: "nextAsync" });
-    else if (mode === "interval") this._clock.setTickMode({
-      mode: "interval",
-      delta: interval
-    });
-    else throw new Error(`Invalid tick mode: ${mode}`);
+    if (this._checkFakeTimers()) {
+      if (mode === "manual") this._clock.setTickMode({ mode: "manual" });
+      else if (mode === "nextTimerAsync") this._clock.setTickMode({ mode: "nextAsync" });
+      else if (mode === "interval") this._clock.setTickMode({
+        mode: "interval",
+        delta: interval
+      });
+      else throw new Error(`Invalid tick mode: ${mode}`);
+    }
   }
   configure(config2) {
     this._userConfig = config2;
@@ -16463,10 +16931,10 @@ function markWhenChain(input) {
   return input;
 }
 function formatActions(actions) {
-  const lines = actions.map((action, index) => {
+  const lines = actions.map((action, index2) => {
     const method = getMethodName(action.type);
     const left = `  ${getSymbol(action)} ${method}(${stringify(action.value)}${action.times === Number.POSITIVE_INFINITY ? "" : `, { times: ${action.times} }`})`;
-    const unreachable = !hasBeenConsumed(action) && actions.slice(index + 1).some((later) => later.times === Number.POSITIVE_INFINITY);
+    const unreachable = !hasBeenConsumed(action) && actions.slice(index2 + 1).some((later) => later.times === Number.POSITIVE_INFINITY);
     return {
       left,
       remaining: getRemainingLabel(action) + (unreachable ? "  \u2192 unreachable action" : "")
@@ -16833,7 +17301,7 @@ function createVitest() {
 var vitest = createVitest();
 var vi = vitest;
 function _mocker() {
-  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
+  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_2, name) {
     throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
   } });
 }
@@ -16857,7 +17325,7 @@ async function waitForImportsToResolve() {
   const state = getWorkerState();
   const promises = [];
   const resolvingCount = state.resolvingModules.size;
-  for (const [_, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
+  for (const [_2, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
   if (!promises.length && !resolvingCount) return;
   await Promise.allSettled(promises);
   await waitForImportsToResolve();
@@ -17037,8 +17505,8 @@ function getError(expected, promise) {
   }
   try {
     expected();
-  } catch (e) {
-    return e;
+  } catch (e2) {
+    return e2;
   }
   throw new Error("snapshot function didn't throw");
 }
@@ -17260,7 +17728,7 @@ var kPerProject = Symbol("perProject");
 var kWriteResult = Symbol("writeResult");
 var kFinalize = Symbol("finalize");
 
-// node_modules/vitest/dist/index.js
+// ../../node_modules/vitest/dist/index.js
 var import_expect_type2 = __toESM(require_dist(), 1);
 
 // src/testing/index.ts
@@ -17334,27 +17802,45 @@ export {
 };
 /*! Bundled license information:
 
-vitest/dist/chunks/index.M2dsQ_UQ.js:
+vitest/dist/chunks/index.D0heQG4v.js:
   (**
-  * @license React
-  * react-is.production.js
-  *
-  * Copyright (c) Meta Platforms, Inc. and affiliates.
-  *
-  * This source code is licensed under the MIT license found in the
-  * LICENSE file in the root directory of this source tree.
-  *)
+   * @license React
+   * react-is.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
   (**
-  * @license React
-  * react-is.production.min.js
-  *
-  * Copyright (c) Facebook, Inc. and its affiliates.
-  *
-  * This source code is licensed under the MIT license found in the
-  * LICENSE file in the root directory of this source tree.
-  *)
+   * @license React
+   * react-is.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+  (**
+   * @license React
+   * react-is.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+  (**
+   * @license React
+   * react-is.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
 
-vitest/dist/chunks/index.DGdajAO2.js:
+vitest/dist/chunks/index.aTZaPVhf.js:
   (*
    * @version    1.4.0
    * @date       2015-10-26