@lokascript/framework 2.3.1 → 2.4.0

package/dist/testing/index.js

@@ -2429,6 +2429,7 @@ function findPlugin(plugins2, val) {
   return null;
 }
 function printer(val, config2, indentation, depth, refs, hasCalledToJSON) {
+  var _a;
   let result;
   const plugin3 = findPlugin(config2.plugins, val);
   if (plugin3 !== null) {
@@ -2441,8 +2442,9 @@ function printer(val, config2, indentation, depth, refs, hasCalledToJSON) {
       result = printComplexValue(val, config2, indentation, depth, refs, hasCalledToJSON);
     }
   }
-  config2.outputLength += result.length;
-  if (config2.outputLength > config2.maxOutputLength) {
+  (_a = config2._outputLengthPerDepth)[depth] ?? (_a[depth] = 0);
+  config2._outputLengthPerDepth[depth] += result.length;
+  if (config2._outputLengthPerDepth[depth] > config2.maxOutputLength) {
     config2.maxDepth = 0;
   }
   return result;
@@ -2530,7 +2532,7 @@ function getConfig(options) {
     spacingInner: options?.min ? " " : "\n",
     spacingOuter: options?.min ? "" : "\n",
     maxOutputLength: options?.maxOutputLength ?? DEFAULT_OPTIONS.maxOutputLength,
-    outputLength: 0
+    _outputLengthPerDepth: []
   };
 }
 function createIndent(indent) {
@@ -4893,7 +4895,8 @@ var FALLBACK_FORMAT_OPTIONS = {
   maxDepth: 8,
   plugins: PLUGINS2
 };
-function diff(a, b2, options) {
+var DEFAULT_MEMORIZE = (_, v) => v;
+function diff(a, b2, options, memorize = DEFAULT_MEMORIZE) {
   if (Object.is(a, b2)) {
     return "";
   }
@@ -4920,8 +4923,8 @@ function diff(a, b2, options) {
     let aDisplay = format(a, formatOptions);
     let bDisplay = format(b2, formatOptions);
     const MAX_LENGTH = 1e5;
-    aDisplay = truncate4(aDisplay);
-    bDisplay = truncate4(bDisplay);
+    aDisplay = memorize("expected", truncate4(aDisplay));
+    bDisplay = memorize("actual", truncate4(bDisplay));
     const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)}
 ${aDisplay}`;
     const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)}
@@ -4938,18 +4941,24 @@ ${bDiff}`;
       return diffLinesUnified(a.split("\n"), b2.split("\n"), options);
     case "boolean":
     case "number":
-      return comparePrimitive(a, b2, options);
+      return comparePrimitive(a, b2, options, memorize);
     case "map":
-      return compareObjects(sortMap(a), sortMap(b2), options);
+      return compareObjects(sortMap(a), sortMap(b2), options, memorize);
     case "set":
-      return compareObjects(sortSet(a), sortSet(b2), options);
+      return compareObjects(sortSet(a), sortSet(b2), options, memorize);
     default:
-      return compareObjects(a, b2, options);
+      return compareObjects(a, b2, options, memorize);
   }
 }
-function comparePrimitive(a, b2, options) {
-  const aFormat = format(a, FORMAT_OPTIONS);
-  const bFormat = format(b2, FORMAT_OPTIONS);
+function createMemorize(memory) {
+  return (pointer, stringifiedValue) => {
+    memory[pointer] = stringifiedValue;
+    return stringifiedValue;
+  };
+}
+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);
 }
 function sortMap(map2) {
@@ -4958,19 +4967,19 @@ function sortMap(map2) {
 function sortSet(set3) {
   return new Set(Array.from(set3.values()).sort());
 }
-function compareObjects(a, b2, options) {
+function compareObjects(a, b2, options, memorize = DEFAULT_MEMORIZE) {
   let difference;
   let hasThrown = false;
   try {
     const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a, b2, formatOptions, options);
+    difference = getObjectsDifference(a, b2, formatOptions, options, memorize);
   } catch {
     hasThrown = true;
   }
   const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
   if (difference === void 0 || difference === noDiffMessage) {
     const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a, b2, formatOptions, options);
+    difference = getObjectsDifference(a, b2, formatOptions, options, memorize);
     if (difference !== noDiffMessage && !hasThrown) {
       difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
 
@@ -4979,6 +4988,9 @@ ${difference}`;
   }
   return difference;
 }
+function getDefaultFormatOptions(options) {
+  return getFormatOptions(FORMAT_OPTIONS, options);
+}
 function getFormatOptions(formatOptions, options) {
   const { compareKeys, printBasicPrototype, maxDepth } = normalizeDiffOptions(options);
   return {
@@ -4988,7 +5000,7 @@ function getFormatOptions(formatOptions, options) {
     maxDepth: maxDepth ?? formatOptions.maxDepth
   };
 }
-function getObjectsDifference(a, b2, formatOptions, options) {
+function getObjectsDifference(a, b2, formatOptions, options, memorize = DEFAULT_MEMORIZE) {
   const formatOptionsZeroIndent = {
     ...formatOptions,
     indent: 0
@@ -4998,8 +5010,8 @@ function getObjectsDifference(a, b2, formatOptions, options) {
   if (aCompare === bCompare) {
     return getCommonMessage(NO_DIFF_MESSAGE, options);
   } else {
-    const aDisplay = format(a, formatOptions);
-    const bDisplay = format(b2, 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);
   }
 }
@@ -5013,7 +5025,7 @@ function isReplaceable(obj1, obj2) {
   const obj2Type = getType2(obj2);
   return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
 }
-function printDiffOrStringify(received, expected, options) {
+function printDiffOrStringify(received, expected, options, memory) {
   const { aAnnotation, bAnnotation } = normalizeDiffOptions(options);
   if (typeof expected === "string" && typeof received === "string" && expected.length > 0 && received.length > 0 && expected.length <= MAX_DIFF_STRING_LENGTH && received.length <= MAX_DIFF_STRING_LENGTH && expected !== received) {
     if (expected.includes("\n") || received.includes("\n")) {
@@ -5030,7 +5042,8 @@ ${receivedLine}`;
   const clonedExpected = deepClone(expected, { forceWritable: true });
   const clonedReceived = deepClone(received, { forceWritable: true });
   const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedReceived, clonedExpected);
-  const difference = diff(replacedExpected, replacedActual, options);
+  const memorize = memory ? createMemorize(memory) : DEFAULT_MEMORIZE;
+  const difference = diff(replacedExpected, replacedActual, options, memorize);
   return difference;
 }
 function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
@@ -5223,16 +5236,13 @@ function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
   }
   const err = _err;
   if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
-    err.diff = printDiffOrStringify(err.actual, err.expected, {
+    const options = {
       ...diffOptions,
       ...err.diffOptions
-    });
-  }
-  if ("expected" in err && typeof err.expected !== "string") {
-    err.expected = stringify(err.expected, 10);
-  }
-  if ("actual" in err && typeof err.actual !== "string") {
-    err.actual = stringify(err.actual, 10);
+    };
+    err.diff = printDiffOrStringify(err.actual, err.expected, options, err);
+    err.expected = prettifyValue(err.expected, options);
+    err.actual = prettifyValue(err.actual, options);
   }
   try {
     if (!seen.has(err) && typeof err.cause === "object") {
@@ -5248,6 +5258,12 @@ function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
 Inner error message: ${err?.message}`));
   }
 }
+function prettifyValue(value, options) {
+  if (typeof value !== "string") {
+    return format(value, getDefaultFormatOptions(options));
+  }
+  return value;
+}
 
 // ../../node_modules/@vitest/utils/dist/timers.js
 var SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
@@ -5556,8 +5572,8 @@ function originalPositionFor(map2, needle) {
 function OMapping(source, line, column, name) {
   return { source, line, column, name };
 }
-function traceSegmentInternal(segments, memo, line, column, bias) {
-  let index2 = memoizedBinarySearch(segments, column, memo, line);
+function traceSegmentInternal(segments, memo2, line, column, bias) {
+  let index2 = memoizedBinarySearch(segments, column, memo2, line);
   if (found) {
     index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
   } else if (bias === LEAST_UPPER_BOUND) index2++;
@@ -5706,7 +5722,7 @@ function parseSingleV8Stack(raw) {
 function parseStacktrace(stack, options = {}) {
   const { ignoreStackEntries = stackIgnorePatterns } = options;
   let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
-  const helperIndex = stacks.findLastIndex((s) => s.method === "__VITEST_HELPER__" || s.method === "async*__VITEST_HELPER__");
+  const helperIndex = stacks.findLastIndex((s) => s.method.includes("__VITEST_HELPER__"));
   if (helperIndex >= 0) {
     stacks = stacks.slice(helperIndex + 1);
   }
@@ -6057,7 +6073,7 @@ function withFixtures(fn2, options) {
     const usedFixtures = [];
     const usedProps = getUsedProps(fn2);
     for (const fixture of registrations.values()) {
-      if (fixture.auto || usedProps.has(fixture.name)) {
+      if (isAutoFixture(fixture, options) || usedProps.has(fixture.name)) {
         usedFixtures.push(fixture);
       }
     }
@@ -6111,6 +6127,15 @@ function withFixtures(fn2, options) {
     return fn2(context);
   };
 }
+function isAutoFixture(fixture, options) {
+  if (!fixture.auto) {
+    return false;
+  }
+  if (options?.suiteHook && fixture.scope === "test") {
+    return false;
+  }
+  return true;
+}
 function isFixtureFunction(value) {
   return typeof value === "function";
 }
@@ -6621,7 +6646,7 @@ function createSuiteCollector(name, factory = () => {
     if (task2.mode === "run" && !handler) {
       task2.mode = "todo";
     }
-    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
+    if (options.concurrent ?? (!options.sequential && runner.config.sequence.concurrent)) {
       task2.concurrent = true;
     }
     task2.shuffle = suiteOptions?.shuffle;
@@ -7366,9 +7391,15 @@ function manageArtifactAttachment(attachment) {
   if (attachment.body && attachment.path) {
     throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
   }
+  if (attachment.path && attachment.bodyEncoding) {
+    throw new TypeError(`Test attachment with "path" should not have "bodyEncoding" specified.`);
+  }
   if (attachment.body instanceof Uint8Array) {
     attachment.body = encodeUint8Array(attachment.body);
   }
+  if (attachment.body != null) {
+    attachment.bodyEncoding ?? (attachment.bodyEncoding = "base64");
+  }
 }
 
 // ../../node_modules/vitest/dist/chunks/utils.BX5Fg8C4.js
@@ -9468,29 +9499,29 @@ function stringDistanceCapped(strA, strB, cap) {
   if (Math.abs(strA.length - strB.length) >= cap) {
     return cap;
   }
-  let memo = [];
+  let memo2 = [];
   for (let i2 = 0; i2 <= strA.length; i2++) {
-    memo[i2] = Array(strB.length + 1).fill(0);
-    memo[i2][0] = i2;
+    memo2[i2] = Array(strB.length + 1).fill(0);
+    memo2[i2][0] = i2;
   }
   for (let j = 0; j < strB.length; j++) {
-    memo[0][j] = j;
+    memo2[0][j] = j;
   }
   for (let i2 = 1; i2 <= strA.length; i2++) {
     let ch = strA.charCodeAt(i2 - 1);
     for (let j = 1; j <= strB.length; j++) {
       if (Math.abs(i2 - j) >= cap) {
-        memo[i2][j] = cap;
+        memo2[i2][j] = cap;
         continue;
       }
-      memo[i2][j] = Math.min(
-        memo[i2 - 1][j] + 1,
-        memo[i2][j - 1] + 1,
-        memo[i2 - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
+      memo2[i2][j] = Math.min(
+        memo2[i2 - 1][j] + 1,
+        memo2[i2][j - 1] + 1,
+        memo2[i2 - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1)
       );
     }
   }
-  return memo[strA.length][strB.length];
+  return memo2[strA.length][strB.length];
 }
 __name(stringDistanceCapped, "stringDistanceCapped");
 function addMethod(ctx, name, method) {
@@ -13633,7 +13664,6 @@ function getMatcherState(assertion, expect2) {
   }
   const matcherState = {
     ...getState(expect2),
-    task,
     currentTestName,
     customTesters: getCustomEqualityTesters(),
     isNot,
@@ -13642,8 +13672,10 @@ function getMatcherState(assertion, expect2) {
     equals,
     suppressedErrors: [],
     soft: utils_exports.flag(assertion, "soft"),
-    poll: utils_exports.flag(assertion, "poll")
+    poll: utils_exports.flag(assertion, "poll"),
+    assertion
   };
+  Object.assign(matcherState, { task });
   return {
     state: matcherState,
     isNot,
@@ -13652,36 +13684,47 @@ function getMatcherState(assertion, expect2) {
   };
 }
 var JestExtendError = class extends Error {
-  constructor(message, actual, expected) {
+  constructor(message, actual, expected, __vitest_error_context__) {
     super(message);
     this.actual = actual;
     this.expected = expected;
+    this.__vitest_error_context__ = __vitest_error_context__;
   }
 };
 function JestExtendPlugin(c, expect2, matchers) {
   return (_, utils) => {
     Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
-      function expectWrapper(...args) {
+      function __VITEST_EXTEND_ASSERTION__(...args) {
         const { state, isNot, obj, customMessage } = getMatcherState(this, expect2);
         const result = expectAssertion.call(state, obj, ...args);
         if (result && typeof result === "object" && typeof result.then === "function") {
           const thenable = result;
-          return thenable.then(({ pass: pass2, message: message2, actual: actual2, expected: expected2 }) => {
+          return thenable.then(({ pass: pass2, message: message2, actual: actual2, expected: expected2, meta: meta2 }) => {
             if (pass2 && isNot || !pass2 && !isNot) {
-              const errorMessage = customMessage != null ? customMessage : message2();
-              throw new JestExtendError(errorMessage, actual2, expected2);
+              const errorMessage = (customMessage ? `${customMessage}: ` : "") + message2();
+              throw new JestExtendError(errorMessage, actual2, expected2, {
+                assertionName: expectAssertionName,
+                meta: meta2
+              });
             }
           });
         }
-        const { pass, message, actual, expected } = result;
+        const { pass, message, actual, expected, meta } = result;
         if (pass && isNot || !pass && !isNot) {
-          const errorMessage = customMessage != null ? customMessage : message();
-          throw new JestExtendError(errorMessage, actual, expected);
+          const errorMessage = (customMessage ? `${customMessage}: ` : "") + message();
+          throw new JestExtendError(errorMessage, actual, expected, {
+            assertionName: expectAssertionName,
+            meta
+          });
         }
       }
-      const softWrapper = wrapAssertion(utils, expectAssertionName, expectWrapper);
+      const softWrapper = wrapAssertion(utils, expectAssertionName, __VITEST_EXTEND_ASSERTION__);
       utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, softWrapper);
       utils.addMethod(c.Assertion.prototype, expectAssertionName, softWrapper);
+      if (expectAssertion.__vitest_poll_takeover__) {
+        const addedMethod = c.Assertion.prototype[expectAssertionName];
+        Object.defineProperty(addedMethod, "__vitest_poll_takeover__", { value: true });
+      }
       class CustomMatcher extends AsymmetricMatcher3 {
         constructor(inverse = false, ...sample) {
           super(sample, inverse);
@@ -13760,157 +13803,59 @@ function offsetToLineNumber(source, offset) {
   return line + 1;
 }
 
-// ../../node_modules/@vitest/snapshot/dist/index.js
-async function saveInlineSnapshots(environment, snapshots) {
-  const MagicString2 = (await Promise.resolve().then(() => (init_magic_string_es(), magic_string_es_exports))).default;
-  const files = new Set(snapshots.map((i2) => i2.file));
-  await Promise.all(Array.from(files).map(async (file) => {
-    const snaps = snapshots.filter((i2) => i2.file === file);
-    const code = await environment.readSnapshotFile(file);
-    if (code == null) {
-      throw new Error(`cannot read ${file} when saving inline snapshot`);
-    }
-    const s = new MagicString2(code);
-    for (const snap of snaps) {
-      const index2 = positionToOffset(code, snap.line, snap.column);
-      replaceInlineSnap(code, s, index2, snap.snapshot);
-    }
-    const transformed = s.toString();
-    if (transformed !== code) {
-      await environment.saveSnapshotFile(file, transformed);
-    }
-  }));
-}
-var startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
-function replaceObjectSnap(code, s, index2, newSnap) {
-  let _code = code.slice(index2);
-  const startMatch = startObjectRegex.exec(_code);
-  if (!startMatch) {
-    return false;
-  }
-  _code = _code.slice(startMatch.index);
-  let callEnd = getCallLastIndex(_code);
-  if (callEnd === null) {
-    return false;
-  }
-  callEnd += index2 + startMatch.index;
-  const shapeStart = index2 + startMatch.index + startMatch[0].length;
-  const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
-  const snap = `, ${prepareSnapString(newSnap, code, index2)}`;
-  if (shapeEnd === callEnd) {
-    s.appendLeft(callEnd, snap);
-  } else {
-    s.overwrite(shapeEnd, callEnd, snap);
-  }
-  return true;
-}
-function getObjectShapeEndIndex(code, index2) {
-  let startBraces = 1;
-  let endBraces = 0;
-  while (startBraces !== endBraces && index2 < code.length) {
-    const s = code[index2++];
-    if (s === "{") {
-      startBraces++;
-    } else if (s === "}") {
-      endBraces++;
-    }
-  }
-  return index2;
-}
-function prepareSnapString(snap, source, index2) {
-  const lineNumber = offsetToLineNumber(source, index2);
-  const line = source.split(lineSplitRE)[lineNumber - 1];
-  const indent = line.match(/^\s*/)[0] || "";
-  const indentNext = indent.includes("	") ? `${indent}	` : `${indent}  `;
-  const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
-  const isOneline = lines.length <= 1;
-  const quote = "`";
-  if (isOneline) {
-    return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
-  }
-  return `${quote}
-${lines.map((i2) => i2 ? indentNext + i2 : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
-${indent}${quote}`;
-}
-var toMatchInlineName = "toMatchInlineSnapshot";
-var toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
-function getCodeStartingAtIndex(code, index2) {
-  const indexInline = index2 - toMatchInlineName.length;
-  if (code.slice(indexInline, index2) === toMatchInlineName) {
-    return {
-      code: code.slice(indexInline),
-      index: indexInline
-    };
-  }
-  const indexThrowInline = index2 - toThrowErrorMatchingInlineName.length;
-  if (code.slice(index2 - indexThrowInline, index2) === toThrowErrorMatchingInlineName) {
-    return {
-      code: code.slice(index2 - indexThrowInline),
-      index: index2 - indexThrowInline
-    };
-  }
-  return {
-    code: code.slice(index2),
-    index: index2
-  };
-}
-var startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
-function replaceInlineSnap(code, s, currentIndex, newSnap) {
-  const { code: codeStartingAtIndex, index: index2 } = getCodeStartingAtIndex(code, currentIndex);
-  const startMatch = startRegex.exec(codeStartingAtIndex);
-  const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);
-  if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
-    return replaceObjectSnap(code, s, index2, newSnap);
-  }
-  const quote = startMatch[1];
-  const startIndex = index2 + startMatch.index + startMatch[0].length;
-  const snapString = prepareSnapString(newSnap, code, index2);
-  if (quote === ")") {
-    s.appendRight(startIndex - 1, snapString);
-    return true;
-  }
-  const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
-  const endMatch = quoteEndRE.exec(code.slice(startIndex));
-  if (!endMatch) {
-    return false;
-  }
-  const endIndex = startIndex + endMatch.index + endMatch[0].length;
-  s.overwrite(startIndex - 1, endIndex, snapString);
-  return true;
-}
-var INDENTATION_REGEX = /^([^\S\n]*)\S/m;
-function stripSnapshotIndentation(inlineSnapshot) {
-  const match = inlineSnapshot.match(INDENTATION_REGEX);
-  if (!match || !match[1]) {
-    return inlineSnapshot;
-  }
-  const indentation = match[1];
-  const lines = inlineSnapshot.split(/\n/g);
-  if (lines.length <= 2) {
-    return inlineSnapshot;
-  }
-  if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
-    return inlineSnapshot;
-  }
-  for (let i2 = 1; i2 < lines.length - 1; i2++) {
-    if (lines[i2] !== "") {
-      if (lines[i2].indexOf(indentation) !== 0) {
-        return inlineSnapshot;
-      }
-      lines[i2] = lines[i2].substring(indentation.length);
+// ../../node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+
+// ../../node_modules/vitest/dist/chunks/rpc.MzXet3jl.js
+var RealDate = Date;
+var now2 = null;
+var MockDate = class _MockDate extends RealDate {
+  constructor(y2, m, d2, h, M, s, ms) {
+    super();
+    let date;
+    switch (arguments.length) {
+      case 0:
+        if (now2 !== null) date = new RealDate(now2.valueOf());
+        else date = new RealDate();
+        break;
+      case 1:
+        date = new RealDate(y2);
+        break;
+      default:
+        d2 = typeof d2 === "undefined" ? 1 : d2;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y2, m, d2, h, M, s, ms);
+        break;
     }
+    Object.setPrototypeOf(date, _MockDate.prototype);
+    return date;
   }
-  lines[lines.length - 1] = "";
-  inlineSnapshot = lines.join("\n");
-  return inlineSnapshot;
+};
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+  return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+  return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+  return RealDate.toString();
+};
+function mockDate(date) {
+  const dateObj = new RealDate(date.valueOf());
+  if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  globalThis.Date = MockDate;
+  now2 = dateObj.valueOf();
 }
-async function saveRawSnapshots(environment, snapshots) {
-  await Promise.all(snapshots.map(async (snap) => {
-    if (!snap.readonly) {
-      await environment.saveSnapshotFile(snap.file, snap.snapshot);
-    }
-  }));
+function resetDate() {
+  globalThis.Date = RealDate;
 }
+var { get: get2 } = Reflect;
+
+// ../../node_modules/@vitest/snapshot/dist/index.js
 function getDefaultExportFromCjs3(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -14131,64 +14076,234 @@ var CounterMap = class extends DefaultMap {
     return total;
   }
 };
-function isSameStackPosition(x, y2) {
-  return x.file === y2.file && x.column === y2.column && x.line === y2.line;
+// @__NO_SIDE_EFFECTS__
+function memo(fn2) {
+  const cache = /* @__PURE__ */ new Map();
+  return (arg) => {
+    if (!cache.has(arg)) {
+      cache.set(arg, fn2(arg));
+    }
+    return cache.get(arg);
+  };
 }
-var SnapshotState = class _SnapshotState {
-  constructor(testFilePath, snapshotPath, snapshotContent, options) {
-    __publicField(this, "_counters", new CounterMap());
-    __publicField(this, "_dirty");
-    __publicField(this, "_updateSnapshot");
-    __publicField(this, "_snapshotData");
-    __publicField(this, "_initialData");
-    __publicField(this, "_inlineSnapshots");
-    __publicField(this, "_inlineSnapshotStacks");
-    __publicField(this, "_testIdToKeys", new DefaultMap(() => []));
-    __publicField(this, "_rawSnapshots");
-    __publicField(this, "_uncheckedKeys");
-    __publicField(this, "_snapshotFormat");
-    __publicField(this, "_environment");
-    __publicField(this, "_fileExists");
-    __publicField(this, "expand");
-    // getter/setter for jest-image-snapshot compat
-    // https://github.com/vitest-dev/vitest/issues/7322
-    __publicField(this, "_added", new CounterMap());
-    __publicField(this, "_matched", new CounterMap());
-    __publicField(this, "_unmatched", new CounterMap());
-    __publicField(this, "_updated", new CounterMap());
-    this.testFilePath = testFilePath;
-    this.snapshotPath = snapshotPath;
-    const { data, dirty } = getSnapshotData(snapshotContent, options);
-    this._fileExists = snapshotContent != null;
-    this._initialData = { ...data };
-    this._snapshotData = { ...data };
-    this._dirty = dirty;
-    this._inlineSnapshots = [];
-    this._inlineSnapshotStacks = [];
-    this._rawSnapshots = [];
-    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
-    this.expand = options.expand || false;
-    this._updateSnapshot = options.updateSnapshot;
-    this._snapshotFormat = {
-      printBasicPrototype: false,
-      escapeString: false,
-      ...options.snapshotFormat
-    };
-    this._environment = options.snapshotEnvironment;
-  }
-  get added() {
-    return this._added;
-  }
-  set added(value) {
-    this._added._total = value;
-  }
-  get matched() {
-    return this._matched;
-  }
-  set matched(value) {
-    this._matched._total = value;
-  }
-  get unmatched() {
+async function saveInlineSnapshots(environment, snapshots) {
+  const MagicString2 = (await Promise.resolve().then(() => (init_magic_string_es(), magic_string_es_exports))).default;
+  const files = new Set(snapshots.map((i2) => i2.file));
+  await Promise.all(Array.from(files).map(async (file) => {
+    const snaps = snapshots.filter((i2) => i2.file === file);
+    const code = await environment.readSnapshotFile(file);
+    if (code == null) {
+      throw new Error(`cannot read ${file} when saving inline snapshot`);
+    }
+    const s = new MagicString2(code);
+    for (const snap of snaps) {
+      const index2 = positionToOffset(code, snap.line, snap.column);
+      replaceInlineSnap(code, s, index2, snap.snapshot, snap.assertionName);
+    }
+    const transformed = s.toString();
+    if (transformed !== code) {
+      await environment.saveSnapshotFile(file, transformed);
+    }
+  }));
+}
+var defaultStartObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var buildStartObjectRegex = /* @__PURE__ */ memo((assertionName) => {
+  const replaced = defaultStartObjectRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+  return new RegExp(replaced);
+});
+function replaceObjectSnap(code, s, index2, newSnap, assertionName) {
+  let _code = code.slice(index2);
+  const regex = assertionName ? buildStartObjectRegex(assertionName) : defaultStartObjectRegex;
+  const startMatch = regex.exec(_code);
+  if (!startMatch) {
+    return false;
+  }
+  _code = _code.slice(startMatch.index);
+  let callEnd = getCallLastIndex(_code);
+  if (callEnd === null) {
+    return false;
+  }
+  callEnd += index2 + startMatch.index;
+  const shapeStart = index2 + startMatch.index + startMatch[0].length;
+  const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+  const snap = `, ${prepareSnapString(newSnap, code, index2)}`;
+  if (shapeEnd === callEnd) {
+    s.appendLeft(callEnd, snap);
+  } else {
+    s.overwrite(shapeEnd, callEnd, snap);
+  }
+  return true;
+}
+function getObjectShapeEndIndex(code, index2) {
+  let startBraces = 1;
+  let endBraces = 0;
+  while (startBraces !== endBraces && index2 < code.length) {
+    const s = code[index2++];
+    if (s === "{") {
+      startBraces++;
+    } else if (s === "}") {
+      endBraces++;
+    }
+  }
+  return index2;
+}
+function prepareSnapString(snap, source, index2) {
+  const lineNumber = offsetToLineNumber(source, index2);
+  const line = source.split(lineSplitRE)[lineNumber - 1];
+  const indent = line.match(/^\s*/)[0] || "";
+  const indentNext = indent.includes("	") ? `${indent}	` : `${indent}  `;
+  const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
+  const isOneline = lines.length <= 1;
+  const quote = "`";
+  if (isOneline) {
+    return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
+  }
+  return `${quote}
+${lines.map((i2) => i2 ? indentNext + i2 : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
+${indent}${quote}`;
+}
+var defaultMethodNames = ["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"];
+function getCodeStartingAtIndex(code, index2, methodNames) {
+  for (const name of methodNames) {
+    const adjusted = index2 - name.length;
+    if (adjusted >= 0 && code.slice(adjusted, index2) === name) {
+      return {
+        code: code.slice(adjusted),
+        index: adjusted
+      };
+    }
+  }
+  return {
+    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$]*(['"`)])/;
+var buildStartRegex = /* @__PURE__ */ memo((assertionName) => {
+  const replaced = defaultStartRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+  return new RegExp(replaced);
+});
+function replaceInlineSnap(code, s, currentIndex, newSnap, assertionName) {
+  const methodNames = assertionName ? [assertionName] : defaultMethodNames;
+  const { code: codeStartingAtIndex, index: index2 } = getCodeStartingAtIndex(code, currentIndex, methodNames);
+  const startRegex = assertionName ? buildStartRegex(assertionName) : defaultStartRegex;
+  const startMatch = startRegex.exec(codeStartingAtIndex);
+  const keywordRegex = assertionName ? new RegExp(escapeRegExp(assertionName)) : /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/;
+  const firstKeywordMatch = keywordRegex.exec(codeStartingAtIndex);
+  if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
+    return replaceObjectSnap(code, s, index2, newSnap, assertionName);
+  }
+  const quote = startMatch[1];
+  const startIndex = index2 + startMatch.index + startMatch[0].length;
+  const snapString = prepareSnapString(newSnap, code, index2);
+  if (quote === ")") {
+    s.appendRight(startIndex - 1, snapString);
+    return true;
+  }
+  const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+  const endMatch = quoteEndRE.exec(code.slice(startIndex));
+  if (!endMatch) {
+    return false;
+  }
+  const endIndex = startIndex + endMatch.index + endMatch[0].length;
+  s.overwrite(startIndex - 1, endIndex, snapString);
+  return true;
+}
+var INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+  const match = inlineSnapshot.match(INDENTATION_REGEX);
+  if (!match || !match[1]) {
+    return inlineSnapshot;
+  }
+  const indentation = match[1];
+  const lines = inlineSnapshot.split(/\n/g);
+  if (lines.length <= 2) {
+    return inlineSnapshot;
+  }
+  if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
+    return inlineSnapshot;
+  }
+  for (let i2 = 1; i2 < lines.length - 1; i2++) {
+    if (lines[i2] !== "") {
+      if (lines[i2].indexOf(indentation) !== 0) {
+        return inlineSnapshot;
+      }
+      lines[i2] = lines[i2].substring(indentation.length);
+    }
+  }
+  lines[lines.length - 1] = "";
+  inlineSnapshot = lines.join("\n");
+  return inlineSnapshot;
+}
+async function saveRawSnapshots(environment, snapshots) {
+  await Promise.all(snapshots.map(async (snap) => {
+    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;
+}
+var SnapshotState = class _SnapshotState {
+  constructor(testFilePath, snapshotPath, snapshotContent, options) {
+    __publicField(this, "_counters", new CounterMap());
+    __publicField(this, "_dirty");
+    __publicField(this, "_updateSnapshot");
+    __publicField(this, "_snapshotData");
+    __publicField(this, "_initialData");
+    __publicField(this, "_inlineSnapshots");
+    __publicField(this, "_inlineSnapshotStacks");
+    __publicField(this, "_testIdToKeys", new DefaultMap(() => []));
+    __publicField(this, "_rawSnapshots");
+    __publicField(this, "_uncheckedKeys");
+    __publicField(this, "_snapshotFormat");
+    __publicField(this, "_environment");
+    __publicField(this, "_fileExists");
+    __publicField(this, "expand");
+    // getter/setter for jest-image-snapshot compat
+    // https://github.com/vitest-dev/vitest/issues/7322
+    __publicField(this, "_added", new CounterMap());
+    __publicField(this, "_matched", new CounterMap());
+    __publicField(this, "_unmatched", new CounterMap());
+    __publicField(this, "_updated", new CounterMap());
+    this.testFilePath = testFilePath;
+    this.snapshotPath = snapshotPath;
+    const { data, dirty } = getSnapshotData(snapshotContent, options);
+    this._fileExists = snapshotContent != null;
+    this._initialData = { ...data };
+    this._snapshotData = { ...data };
+    this._dirty = dirty;
+    this._inlineSnapshots = [];
+    this._inlineSnapshotStacks = [];
+    this._rawSnapshots = [];
+    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
+    this.expand = options.expand || false;
+    this._updateSnapshot = options.updateSnapshot;
+    this._snapshotFormat = {
+      printBasicPrototype: false,
+      escapeString: false,
+      maxOutputLength: 2 ** 27,
+      ...options.snapshotFormat
+    };
+    this._environment = options.snapshotEnvironment;
+  }
+  get added() {
+    return this._added;
+  }
+  set added(value) {
+    this._added._total = value;
+  }
+  get matched() {
+    return this._matched;
+  }
+  set matched(value) {
+    this._matched._total = value;
+  }
+  get unmatched() {
     return this._unmatched;
   }
   set unmatched(value) {
@@ -14205,6 +14320,9 @@ var SnapshotState = class _SnapshotState {
     const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
     return new _SnapshotState(testFilePath, snapshotPath, content, options);
   }
+  get snapshotUpdateState() {
+    return this._updateSnapshot;
+  }
   get environment() {
     return this._environment;
   }
@@ -14239,12 +14357,20 @@ var SnapshotState = class _SnapshotState {
     if (promiseIndex !== -1) {
       return stacks[promiseIndex + 3];
     }
+    const pollChainIndex = stacks.findIndex((i2) => i2.method.match(/__VITEST_POLL_CHAIN__/));
+    if (pollChainIndex !== -1) {
+      return stacks[pollChainIndex + 1];
+    }
     for (let i2 = 0; i2 < stacks.length; i2++) {
       const match = stacks[i2].method.match(/__INLINE_SNAPSHOT_OFFSET_(\d+)__/);
       if (match) {
         return stacks[i2 + Number(match[1])] ?? null;
       }
     }
+    const customMatcherIndex = stacks.findIndex((i2) => i2.method.includes("__VITEST_EXTEND_ASSERTION__"));
+    if (customMatcherIndex !== -1) {
+      return stacks[customMatcherIndex + 3] ?? null;
+    }
     const stackIndex = stacks.findIndex((i2) => i2.method.includes("__INLINE_SNAPSHOT__"));
     return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
   }
@@ -14252,9 +14378,10 @@ var SnapshotState = class _SnapshotState {
     this._dirty = true;
     if (options.stack) {
       this._inlineSnapshots.push({
+        ...options.stack,
         snapshot: receivedSerialized,
         testId: options.testId,
-        ...options.stack
+        assertionName: options.assertionName
       });
     } else if (options.rawSnapshot) {
       this._rawSnapshots.push({
@@ -14265,6 +14392,103 @@ var SnapshotState = class _SnapshotState {
       this._snapshotData[key] = receivedSerialized;
     }
   }
+  _resolveKey(testId, testName2, key) {
+    this._counters.increment(testName2);
+    const count = this._counters.get(testName2);
+    if (!key) {
+      key = testNameToKey(testName2, count);
+    }
+    this._testIdToKeys.get(testId).push(key);
+    return {
+      key,
+      count
+    };
+  }
+  _resolveInlineStack(options) {
+    const { testId, snapshot, assertionName, error } = options;
+    const stacks = parseErrorStacktrace(error, { ignoreStackEntries: [] });
+    const _stack = this._inferInlineSnapshotStack(stacks);
+    if (!_stack) {
+      const message = stacks.map((s) => `  ${s.file}:${s.line}:${s.column}${s.method ? ` (${s.method})` : ""}`).join("\n");
+      throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.
+${message}`);
+    }
+    const stack = this.environment.processStackTrace?.(_stack) || _stack;
+    stack.column--;
+    const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
+    if (snapshotsWithSameStack.length > 0) {
+      this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
+      const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== snapshot);
+      if (differentSnapshot) {
+        throw Object.assign(new Error(`${assertionName} with different snapshots cannot be called at the same location`), {
+          actual: snapshot,
+          expected: differentSnapshot.snapshot
+        });
+      }
+    }
+    this._inlineSnapshotStacks.push({
+      ...stack,
+      testId,
+      snapshot
+    });
+    return stack;
+  }
+  _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 {
+        this._addSnapshot(opts.key, opts.addValue, {
+          stack: opts.stack,
+          testId: opts.testId,
+          rawSnapshot: opts.rawSnapshot,
+          assertionName: opts.assertionName
+        });
+        this.added.increment(opts.testId);
+      }
+      return {
+        actual: "",
+        count: opts.count,
+        expected: "",
+        key: opts.key,
+        pass: true
+      };
+    } else {
+      if (!opts.pass) {
+        this.unmatched.increment(opts.testId);
+        return {
+          actual: opts.actualDisplay,
+          count: opts.count,
+          expected: opts.expectedDisplay,
+          key: opts.key,
+          pass: false
+        };
+      } else {
+        this.matched.increment(opts.testId);
+        return {
+          actual: "",
+          count: opts.count,
+          expected: "",
+          key: opts.key,
+          pass: true
+        };
+      }
+    }
+  }
   async save() {
     const hasExternalSnapshots = Object.keys(this._snapshotData).length;
     const hasInlineSnapshots = this._inlineSnapshots.length;
@@ -14308,13 +14532,24 @@ var SnapshotState = class _SnapshotState {
       this._uncheckedKeys.clear();
     }
   }
-  match({ testId, testName: testName2, received, key, inlineSnapshot, isInline, error, rawSnapshot }) {
-    this._counters.increment(testName2);
-    const count = this._counters.get(testName2);
-    if (!key) {
-      key = testNameToKey(testName2, count);
-    }
-    this._testIdToKeys.get(testId).push(key);
+  probeExpectedSnapshot(options) {
+    const count = this._counters.get(options.testName) + 1;
+    const key = testNameToKey(options.testName, count);
+    return {
+      key,
+      count,
+      data: options?.isInline ? options.inlineSnapshot : this._snapshotData[key],
+      markAsChecked: () => {
+        this._counters.increment(options.testName);
+        this._testIdToKeys.get(options.testId).push(key);
+        this._uncheckedKeys.delete(key);
+      }
+    };
+  }
+  match({ testId, testName: testName2, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }) {
+    const resolved = this._resolveKey(testId, testName2, key);
+    key = resolved.key;
+    const count = resolved.count;
     if (!(isInline && this._snapshotData[key] !== void 0)) {
       this._uncheckedKeys.delete(key);
     }
@@ -14335,85 +14570,49 @@ var SnapshotState = class _SnapshotState {
     if (pass && !isInline && !rawSnapshot) {
       this._snapshotData[key] = receivedSerialized;
     }
-    let stack;
-    if (isInline) {
-      const stacks = parseErrorStacktrace(error || new Error("snapshot"), { ignoreStackEntries: [] });
-      const _stack = this._inferInlineSnapshotStack(stacks);
-      if (!_stack) {
-        throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.
-${JSON.stringify(stacks)}`);
-      }
-      stack = this.environment.processStackTrace?.(_stack) || _stack;
-      stack.column--;
-      const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
-      if (snapshotsWithSameStack.length > 0) {
-        this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
-        const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== receivedSerialized);
-        if (differentSnapshot) {
-          throw Object.assign(new Error("toMatchInlineSnapshot with different snapshots cannot be called at the same location"), {
-            actual: receivedSerialized,
-            expected: differentSnapshot.snapshot
-          });
-        }
-      }
-      this._inlineSnapshotStacks.push({
-        ...stack,
-        testId,
-        snapshot: receivedSerialized
-      });
-    }
-    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-      if (this._updateSnapshot === "all") {
-        if (!pass) {
-          if (hasSnapshot) {
-            this.updated.increment(testId);
-          } else {
-            this.added.increment(testId);
-          }
-          this._addSnapshot(key, receivedSerialized, {
-            stack,
-            testId,
-            rawSnapshot
-          });
-        } else {
-          this.matched.increment(testId);
-        }
-      } else {
-        this._addSnapshot(key, receivedSerialized, {
-          stack,
-          testId,
-          rawSnapshot
-        });
-        this.added.increment(testId);
-      }
-      return {
-        actual: "",
-        count,
-        expected: "",
-        key,
-        pass: true
-      };
-    } else {
-      if (!pass) {
-        this.unmatched.increment(testId);
-        return {
-          actual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
-          count,
-          expected: expectedTrimmed !== void 0 ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : void 0,
-          key,
-          pass: false
-        };
-      } else {
-        this.matched.increment(testId);
-        return {
-          actual: "",
-          count,
-          expected: "",
-          key,
-          pass: true
-        };
-      }
-    }
+    const stack = isInline ? this._resolveInlineStack({
+      testId,
+      snapshot: receivedSerialized,
+      assertionName: assertionName || "toMatchInlineSnapshot",
+      error: error || new Error("snapshot")
+    }) : void 0;
+    return this._reconcile({
+      testId,
+      key,
+      count,
+      pass,
+      hasSnapshot,
+      snapshotIsPersisted: !!snapshotIsPersisted,
+      addValue: receivedSerialized,
+      actualDisplay: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
+      expectedDisplay: expectedTrimmed !== void 0 ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : void 0,
+      stack,
+      rawSnapshot,
+      assertionName
+    });
+  }
+  processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }) {
+    const stack = isInline ? this._resolveInlineStack({
+      testId,
+      snapshot: received,
+      assertionName,
+      error: error || new Error("STACK_TRACE_ERROR")
+    }) : void 0;
+    const actualResolved = matchResult?.resolved ?? received;
+    const expectedResolved = matchResult?.expected ?? expectedSnapshot.data;
+    return this._reconcile({
+      testId,
+      key: expectedSnapshot.key,
+      count: expectedSnapshot.count,
+      pass: matchResult?.pass ?? false,
+      hasSnapshot: !!expectedSnapshot.data,
+      snapshotIsPersisted: isInline ? true : this._fileExists,
+      addValue: actualResolved,
+      actualDisplay: removeExtraLineBreaks(actualResolved),
+      expectedDisplay: expectedResolved !== void 0 ? removeExtraLineBreaks(expectedResolved) : void 0,
+      stack,
+      assertionName
+    });
   }
   async pack() {
     const snapshot = {
@@ -14491,30 +14690,43 @@ var SnapshotClient = class {
     }
     return state;
   }
-  assert(options) {
-    const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot } = options;
+  match(options) {
+    const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot, assertionName } = options;
     let { received } = options;
     if (!filepath) {
       throw new Error("Snapshot cannot be used outside of test");
     }
     const snapshotState = this.getSnapshotState(filepath);
+    const testName2 = [name, ...message ? [message] : []].join(" > ");
+    const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+      testName: testName2,
+      testId,
+      isInline,
+      inlineSnapshot
+    });
     if (typeof properties === "object") {
       if (typeof received !== "object" || !received) {
+        expectedSnapshot.markAsChecked();
         throw new Error("Received value must be an object when the matcher has properties");
       }
+      let propertiesPass;
       try {
-        const pass2 = this.options.isEqual?.(received, properties) ?? false;
-        if (!pass2) {
-          throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, received, properties);
-        } else {
-          received = deepMergeSnapshot(received, properties);
-        }
+        propertiesPass = this.options.isEqual?.(received, properties) ?? false;
       } catch (err) {
-        err.message = errorMessage || "Snapshot mismatched";
+        expectedSnapshot.markAsChecked();
         throw err;
       }
+      if (!propertiesPass) {
+        expectedSnapshot.markAsChecked();
+        return {
+          pass: false,
+          message: () => errorMessage || "Snapshot properties mismatched",
+          actual: received,
+          expected: properties
+        };
+      }
+      received = deepMergeSnapshot(received, properties);
     }
-    const testName2 = [name, ...message ? [message] : []].join(" > ");
     const { actual, expected, key, pass } = snapshotState.match({
       testId,
       testName: testName2,
@@ -14522,11 +14734,104 @@ var SnapshotClient = class {
       isInline,
       error,
       inlineSnapshot,
-      rawSnapshot
+      rawSnapshot,
+      assertionName
     });
-    if (!pass) {
-      throw createMismatchError(`Snapshot \`${key || "unknown"}\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual?.trim(), rawSnapshot ? expected : expected?.trim());
+    return {
+      pass,
+      message: () => `Snapshot \`${key || "unknown"}\` mismatched`,
+      actual: rawSnapshot ? actual : actual?.trim(),
+      expected: rawSnapshot ? expected : expected?.trim()
+    };
+  }
+  assert(options) {
+    const result = this.match(options);
+    if (!result.pass) {
+      const snapshotState = this.getSnapshotState(options.filepath);
+      throw createMismatchError(result.message(), snapshotState.expand, result.actual, result.expected);
+    }
+  }
+  matchDomain(options) {
+    const { received, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error } = options;
+    if (!filepath) {
+      throw new Error("Snapshot cannot be used outside of test");
+    }
+    const captured = adapter.capture(received);
+    const rendered = adapter.render(captured);
+    const snapshotState = this.getSnapshotState(filepath);
+    const testName2 = [name, ...message ? [message] : []].join(" > ");
+    const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+      testName: testName2,
+      testId,
+      isInline,
+      inlineSnapshot
+    });
+    expectedSnapshot.markAsChecked();
+    const matchResult = expectedSnapshot.data ? adapter.match(captured, adapter.parseExpected(expectedSnapshot.data)) : void 0;
+    const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+      testId,
+      received: rendered,
+      expectedSnapshot,
+      matchResult,
+      isInline,
+      error,
+      assertionName: options.assertionName
+    });
+    return {
+      pass,
+      message: () => `Snapshot \`${key}\` mismatched`,
+      actual: actual?.trim(),
+      expected: expected?.trim()
+    };
+  }
+  async pollMatchDomain(options) {
+    const { poll, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error, timeout = 1e3, interval = 50 } = options;
+    if (!filepath) {
+      throw new Error("Snapshot cannot be used outside of test");
     }
+    const snapshotState = this.getSnapshotState(filepath);
+    const testName2 = [name, ...message ? [message] : []].join(" > ");
+    const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+      testName: testName2,
+      testId,
+      isInline,
+      inlineSnapshot
+    });
+    const reference = expectedSnapshot.data && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : void 0;
+    const timedOut = timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : void 0;
+    const stableResult = await getStableSnapshot({
+      adapter,
+      poll,
+      interval,
+      timedOut,
+      match: reference ? (captured) => adapter.match(captured, reference).pass : void 0
+    });
+    expectedSnapshot.markAsChecked();
+    if (!stableResult?.rendered) {
+      if (stableResult?.lastPollError) {
+        throw stableResult.lastPollError;
+      }
+      return {
+        pass: false,
+        message: () => `poll() did not produce a stable snapshot within the timeout`
+      };
+    }
+    const matchResult = expectedSnapshot.data ? adapter.match(stableResult.captured, adapter.parseExpected(expectedSnapshot.data)) : void 0;
+    const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+      testId,
+      received: stableResult.rendered,
+      expectedSnapshot,
+      matchResult,
+      isInline,
+      error,
+      assertionName: options.assertionName
+    });
+    return {
+      pass,
+      message: () => `Snapshot \`${key}\` mismatched`,
+      actual: actual?.trim(),
+      expected: expected?.trim()
+    };
   }
   async assertRaw(options) {
     if (!options.rawSnapshot) {
@@ -14548,363 +14853,60 @@ var SnapshotClient = class {
     this.snapshotStateMap.clear();
   }
 };
-
-// ../../node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-
-// ../../node_modules/vitest/dist/chunks/rpc.MzXet3jl.js
-var RealDate = Date;
-var now2 = null;
-var MockDate = class _MockDate extends RealDate {
-  constructor(y2, m, d2, h, M, s, ms) {
-    super();
-    let date;
-    switch (arguments.length) {
-      case 0:
-        if (now2 !== null) date = new RealDate(now2.valueOf());
-        else date = new RealDate();
-        break;
-      case 1:
-        date = new RealDate(y2);
-        break;
-      default:
-        d2 = typeof d2 === "undefined" ? 1 : d2;
-        h = h || 0;
-        M = M || 0;
-        s = s || 0;
-        ms = ms || 0;
-        date = new RealDate(y2, m, d2, h, M, s, ms);
+async function getStableSnapshot({ adapter, poll, interval, timedOut, match }) {
+  let lastRendered;
+  let lastPollError;
+  let lastStable;
+  while (true) {
+    try {
+      const pollResult = await raceWith(Promise.resolve(poll()), timedOut);
+      if (!pollResult.ok) {
         break;
-    }
-    Object.setPrototypeOf(date, _MockDate.prototype);
-    return date;
-  }
-};
-MockDate.UTC = RealDate.UTC;
-MockDate.now = function() {
-  return new MockDate().valueOf();
-};
-MockDate.parse = function(dateString) {
-  return RealDate.parse(dateString);
-};
-MockDate.toString = function() {
-  return RealDate.toString();
-};
-function mockDate(date) {
-  const dateObj = new RealDate(date.valueOf());
-  if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-  globalThis.Date = MockDate;
-  now2 = dateObj.valueOf();
-}
-function resetDate() {
-  globalThis.Date = RealDate;
-}
-var { get: get2 } = Reflect;
-
-// ../../node_modules/vitest/dist/chunks/test.CBQUpOM3.js
-var unsupported = [
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-];
-function throwWithCause(error, source) {
-  if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
-  throw copyStackTrace$1(error, source);
-}
-function createExpectPoll(expect2) {
-  return function poll(fn2, options = {}) {
-    const defaults = getWorkerState().config.expect?.poll ?? {};
-    const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
-    const assertion = expect2(null, message).withContext({ poll: true });
-    fn2 = fn2.bind(assertion);
-    const test5 = chai_exports.util.flag(assertion, "vitest-test");
-    if (!test5) throw new Error("expect.poll() must be called inside a test");
-    const proxy = new Proxy(assertion, { get(target, key, receiver) {
-      const assertionFunction = Reflect.get(target, key, receiver);
-      if (typeof assertionFunction !== "function") return assertionFunction instanceof chai_exports.Assertion ? proxy : assertionFunction;
-      if (key === "assert") return assertionFunction;
-      if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
-      return function(...args) {
-        const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
-        const promise = async () => {
-          const { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = getSafeTimers();
-          let executionPhase = "fn";
-          let hasTimedOut = false;
-          const timerId = setTimeout3(() => {
-            hasTimedOut = true;
-          }, timeout);
-          chai_exports.util.flag(assertion, "_name", key);
-          const onSettled = chai_exports.util.flag(assertion, "_poll.onSettled");
-          try {
-            while (true) {
-              const isLastAttempt = hasTimedOut;
-              if (isLastAttempt) chai_exports.util.flag(assertion, "_isLastPollAttempt", true);
-              try {
-                executionPhase = "fn";
-                const obj = await fn2();
-                chai_exports.util.flag(assertion, "object", obj);
-                executionPhase = "assertion";
-                const output = await assertionFunction.call(assertion, ...args);
-                await onSettled?.({
-                  assertion,
-                  status: "pass"
-                });
-                return output;
-              } catch (err) {
-                if (isLastAttempt || executionPhase === "assertion" && chai_exports.util.flag(assertion, "_poll.assert_once")) {
-                  await onSettled?.({
-                    assertion,
-                    status: "fail"
-                  });
-                  throwWithCause(err, STACK_TRACE_ERROR);
-                }
-                await delay(interval, setTimeout3);
-              }
-            }
-          } finally {
-            clearTimeout3(timerId);
-          }
-        };
-        let awaited = false;
-        test5.onFinished ?? (test5.onFinished = []);
-        test5.onFinished.push(() => {
-          if (!awaited) {
-            const negated = chai_exports.util.flag(assertion, "negate") ? "not." : "";
-            const assertionString = `expect.${chai_exports.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
-            throw copyStackTrace$1(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
-
-await ${assertionString}
-`), STACK_TRACE_ERROR);
-          }
-        });
-        let resultPromise;
-        return {
-          then(onFulfilled, onRejected) {
-            awaited = true;
-            return (resultPromise || (resultPromise = promise())).then(onFulfilled, onRejected);
-          },
-          catch(onRejected) {
-            awaited = true;
-            return (resultPromise || (resultPromise = promise())).catch(onRejected);
-          },
-          finally(onFinally) {
-            awaited = true;
-            return (resultPromise || (resultPromise = promise())).finally(onFinally);
-          },
-          [Symbol.toStringTag]: "Promise"
+      }
+      const captured = adapter.capture(pollResult.value);
+      const rendered = adapter.render(captured);
+      if (lastRendered !== void 0 && rendered === lastRendered) {
+        lastStable = {
+          captured,
+          rendered
         };
-      };
-    } });
-    return proxy;
-  };
-}
-function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
-  return target;
-}
-var _client;
-function getSnapshotClient() {
-  if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
-    return equals(received, expected, [iterableEquality, subsetEquality]);
-  } });
-  return _client;
-}
-function getError(expected, promise) {
-  if (typeof expected !== "function") {
-    if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
-    return expected;
-  }
-  try {
-    expected();
-  } catch (e) {
-    return e;
+        if (!match || match(captured)) {
+          break;
+        }
+      } else {
+        lastRendered = rendered;
+        lastStable = void 0;
+      }
+    } catch (pollError) {
+      lastRendered = void 0;
+      lastStable = void 0;
+      lastPollError = pollError;
+    }
+    const delayed = await raceWith(new Promise((r) => setTimeout(r, interval)), timedOut);
+    if (!delayed.ok) {
+      break;
+    }
   }
-  throw new Error("snapshot function didn't throw");
-}
-function getTestNames(test5) {
   return {
-    filepath: test5.file.filepath,
-    name: getNames(test5).slice(1).join(" > "),
-    testId: test5.id
+    ...lastStable,
+    lastPollError
   };
 }
-var SnapshotPlugin = (chai, utils) => {
-  function getTest(assertionName, obj) {
-    const test5 = utils.flag(obj, "vitest-test");
-    if (!test5) throw new Error(`'${assertionName}' cannot be used without test context`);
-    return test5;
-  }
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(properties, message) {
-    utils.flag(this, "_name", key);
-    if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
-    const expected = utils.flag(this, "object");
-    const test5 = getTest(key, this);
-    if (typeof properties === "string" && typeof message === "undefined") {
-      message = properties;
-      properties = void 0;
-    }
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: expected,
-      message,
-      isInline: false,
-      properties,
-      errorMessage,
-      ...getTestNames(test5)
-    });
-  }));
-  utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
-    utils.flag(this, "_name", "toMatchFileSnapshot");
-    if (utils.flag(this, "negate")) throw new Error('toMatchFileSnapshot cannot be used with "not"');
-    const error = /* @__PURE__ */ new Error("resolves");
-    const expected = utils.flag(this, "object");
-    const test5 = getTest("toMatchFileSnapshot", this);
-    const errorMessage = utils.flag(this, "message");
-    return recordAsyncExpect(test5, getSnapshotClient().assertRaw({
-      received: expected,
-      message,
-      isInline: false,
-      rawSnapshot: { file },
-      errorMessage,
-      ...getTestNames(test5)
-    }), createAssertionMessage(utils, this, true), error, utils.flag(this, "soft"));
-  });
-  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(properties, inlineSnapshot, message) {
-    utils.flag(this, "_name", "toMatchInlineSnapshot");
-    if (utils.flag(this, "negate")) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-    const test5 = getTest("toMatchInlineSnapshot", this);
-    const expected = utils.flag(this, "object");
-    const error = utils.flag(this, "error");
-    if (typeof properties === "string") {
-      message = inlineSnapshot;
-      inlineSnapshot = properties;
-      properties = void 0;
-    }
-    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: expected,
-      message,
-      isInline: true,
-      properties,
-      inlineSnapshot,
-      error,
-      errorMessage,
-      ...getTestNames(test5)
-    });
-  }));
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(properties, message) {
-    utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
-    if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
-    const expected = utils.flag(this, "object");
-    const test5 = getTest("toThrowErrorMatchingSnapshot", this);
-    const promise = utils.flag(this, "promise");
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: getError(expected, promise),
-      message,
-      errorMessage,
-      ...getTestNames(test5)
-    });
-  }));
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshot, message) {
-    if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
-    const test5 = getTest("toThrowErrorMatchingInlineSnapshot", this);
-    const expected = utils.flag(this, "object");
-    const error = utils.flag(this, "error");
-    const promise = utils.flag(this, "promise");
-    const errorMessage = utils.flag(this, "message");
-    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-    getSnapshotClient().assert({
-      received: getError(expected, promise),
-      message,
-      inlineSnapshot,
-      isInline: true,
-      error,
-      errorMessage,
-      ...getTestNames(test5)
-    });
-  }));
-  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
-};
-chai_exports.use(JestExtend);
-chai_exports.use(JestChaiExpect);
-chai_exports.use(ChaiStyleAssertions);
-chai_exports.use(SnapshotPlugin);
-chai_exports.use(JestAsymmetricMatchers);
-function createExpect(test5) {
-  const expect2 = ((value, message) => {
-    const { assertionCalls } = getState(expect2);
-    setState({ assertionCalls: assertionCalls + 1 }, expect2);
-    const assert5 = chai_exports.expect(value, message);
-    const _test2 = test5 || getCurrentTest();
-    if (_test2)
-      return assert5.withTest(_test2);
-    else return assert5;
-  });
-  Object.assign(expect2, chai_exports.expect);
-  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-  expect2.getState = () => getState(expect2);
-  expect2.setState = (state) => setState(state, expect2);
-  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
-  setState({
-    ...globalState,
-    assertionCalls: 0,
-    isExpectingAssertions: false,
-    isExpectingAssertionsError: null,
-    expectedAssertionsNumber: null,
-    expectedAssertionsNumberErrorGen: null,
-    get testPath() {
-      return getWorkerState().filepath;
-    },
-    currentTestName: test5 ? test5.fullTestName ?? "" : globalState.currentTestName
-  }, expect2);
-  expect2.assert = chai_exports.assert;
-  expect2.extend = (matchers) => chai_exports.expect.extend(expect2, matchers);
-  expect2.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-  expect2.soft = (...args) => {
-    return expect2(...args).withContext({ soft: true });
-  };
-  expect2.poll = createExpectPoll(expect2);
-  expect2.unreachable = (message) => {
-    chai_exports.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
-  };
-  function assertions(expected) {
-    const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
-    if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
-    expect2.setState({
-      expectedAssertionsNumber: expected,
-      expectedAssertionsNumberErrorGen: errorGen
-    });
-  }
-  function hasAssertions() {
-    const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
-    expect2.setState({
-      isExpectingAssertions: true,
-      isExpectingAssertionsError: error
-    });
+function raceWith(promise, other) {
+  const left = promise.then((value) => ({
+    ok: true,
+    value
+  }));
+  if (!other) {
+    return left;
   }
-  chai_exports.util.addMethod(expect2, "assertions", assertions);
-  chai_exports.util.addMethod(expect2, "hasAssertions", hasAssertions);
-  expect2.extend(customMatchers);
-  return expect2;
+  return Promise.race([left, other.then((value) => ({
+    ok: false,
+    value
+  }))]);
 }
-var globalExpect = createExpect();
-Object.defineProperty(globalThis, GLOBAL_EXPECT, {
-  value: globalExpect,
-  writable: true,
-  configurable: true
-});
-var assert4 = chai_exports.assert;
-var should2 = chai_exports.should;
+
+// ../../node_modules/vitest/dist/chunks/test.DNmyFkvJ.js
 var fakeTimersSrc = {};
 var global2;
 var hasRequiredGlobal;
@@ -16926,7 +16928,7 @@ var FakeTimers = class {
     return this._fakingTime;
   }
 };
-function copyStackTrace(target, source) {
+function copyStackTrace$1(target, source) {
   if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
   return target;
 }
@@ -16947,7 +16949,7 @@ function waitFor(callback, options = {}) {
     const handleTimeout = () => {
       if (intervalId) clearInterval2(intervalId);
       let error = lastError;
-      if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+      if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
       reject(error);
     };
     const checkCallback = () => {
@@ -16988,7 +16990,7 @@ function waitUntil(callback, options = {}) {
     let intervalId;
     const onReject = (error) => {
       if (intervalId) clearInterval2(intervalId);
-      if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+      if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
       reject(error);
     };
     const onResolve = (result) => {
@@ -17125,7 +17127,7 @@ function createVitest() {
     waitUntil,
     defineHelper: (fn2) => {
       return function __VITEST_HELPER__(...args) {
-        const result = fn2(...args);
+        const result = fn2.apply(this, args);
         if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__2() {
           return await result;
         })();
@@ -17254,6 +17256,358 @@ function getImporter(name) {
     return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
   }) + 1])?.file || "";
 }
+var unsupported = [
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+];
+function throwWithCause(error, source) {
+  if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+  throw copyStackTrace(error, source);
+}
+function createExpectPoll(expect2) {
+  return function poll(fn2, options = {}) {
+    const defaults = getWorkerState().config.expect?.poll ?? {};
+    const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+    const assertion = expect2(null, message).withContext({ poll: true });
+    fn2 = fn2.bind(assertion);
+    chai_exports.util.flag(assertion, "_poll.fn", fn2);
+    chai_exports.util.flag(assertion, "_poll.timeout", timeout);
+    chai_exports.util.flag(assertion, "_poll.interval", interval);
+    const test5 = chai_exports.util.flag(assertion, "vitest-test");
+    if (!test5) throw new Error("expect.poll() must be called inside a test");
+    const proxy = new Proxy(assertion, { get(target, key, receiver) {
+      const assertionFunction = Reflect.get(target, key, receiver);
+      if (typeof assertionFunction !== "function") return assertionFunction instanceof chai_exports.Assertion ? proxy : assertionFunction;
+      if (key === "assert") return assertionFunction;
+      if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+      return function __VITEST_POLL_CHAIN__(...args) {
+        const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+        const promise = async () => {
+          chai_exports.util.flag(assertion, "_name", key);
+          chai_exports.util.flag(assertion, "error", STACK_TRACE_ERROR);
+          const onSettled = chai_exports.util.flag(assertion, "_poll.onSettled");
+          if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
+            const output = await assertionFunction.call(assertion, ...args);
+            await onSettled?.({
+              assertion,
+              status: "pass"
+            });
+            return output;
+          } catch (err) {
+            await onSettled?.({
+              assertion,
+              status: "fail"
+            });
+            throwWithCause(err, STACK_TRACE_ERROR);
+          }
+          const { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = getSafeTimers();
+          let executionPhase = "fn";
+          let hasTimedOut = false;
+          const timerId = setTimeout3(() => {
+            hasTimedOut = true;
+          }, timeout);
+          try {
+            while (true) {
+              const isLastAttempt = hasTimedOut;
+              if (isLastAttempt) chai_exports.util.flag(assertion, "_isLastPollAttempt", true);
+              try {
+                executionPhase = "fn";
+                const obj = await fn2();
+                chai_exports.util.flag(assertion, "object", obj);
+                executionPhase = "assertion";
+                const output = await assertionFunction.call(assertion, ...args);
+                await onSettled?.({
+                  assertion,
+                  status: "pass"
+                });
+                return output;
+              } catch (err) {
+                if (isLastAttempt || executionPhase === "assertion" && chai_exports.util.flag(assertion, "_poll.assert_once")) {
+                  await onSettled?.({
+                    assertion,
+                    status: "fail"
+                  });
+                  throwWithCause(err, STACK_TRACE_ERROR);
+                }
+                await delay(interval, setTimeout3);
+                if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+              }
+            }
+          } finally {
+            clearTimeout3(timerId);
+          }
+        };
+        let awaited = false;
+        test5.onFinished ?? (test5.onFinished = []);
+        test5.onFinished.push(() => {
+          if (!awaited) {
+            const negated = chai_exports.util.flag(assertion, "negate") ? "not." : "";
+            const assertionString = `expect.${chai_exports.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
+            throw copyStackTrace(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
+
+await ${assertionString}
+`), STACK_TRACE_ERROR);
+          }
+        });
+        let resultPromise;
+        return {
+          then(onFulfilled, onRejected) {
+            awaited = true;
+            return (resultPromise || (resultPromise = promise())).then(onFulfilled, onRejected);
+          },
+          catch(onRejected) {
+            awaited = true;
+            return (resultPromise || (resultPromise = promise())).catch(onRejected);
+          },
+          finally(onFinally) {
+            awaited = true;
+            return (resultPromise || (resultPromise = promise())).finally(onFinally);
+          },
+          [Symbol.toStringTag]: "Promise"
+        };
+      };
+    } });
+    return proxy;
+  };
+}
+function copyStackTrace(target, source) {
+  if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+  return target;
+}
+var _client;
+function getSnapshotClient() {
+  if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
+    return equals(received, expected, [iterableEquality, subsetEquality]);
+  } });
+  return _client;
+}
+function getError(expected, promise) {
+  if (typeof expected !== "function") {
+    if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+    return expected;
+  }
+  try {
+    expected();
+  } catch (e) {
+    return e;
+  }
+  throw new Error("snapshot function didn't throw");
+}
+function getTestNames(test5) {
+  return {
+    filepath: test5.file.filepath,
+    name: getNames(test5).slice(1).join(" > "),
+    testId: test5.id
+  };
+}
+function getAssertionName(assertion) {
+  const name = chai_exports.util.flag(assertion, "_name");
+  if (!name) throw new Error("Assertion name is not set. This is a bug in Vitest. Please, open a new issue with reproduction.");
+  return name;
+}
+function getTest(obj) {
+  const test5 = chai_exports.util.flag(obj, "vitest-test");
+  if (!test5) throw new Error(`'${getAssertionName(obj)}' cannot be used without test context`);
+  return test5;
+}
+function validateAssertion(assertion) {
+  if (chai_exports.util.flag(assertion, "negate")) throw new Error(`${getAssertionName(assertion)} cannot be used with "not"`);
+}
+var SnapshotPlugin = (chai, utils) => {
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(propertiesOrHint, hint) {
+    return assertMatchResult(toMatchSnapshotImpl({
+      assertion: this,
+      received: utils.flag(this, "object"),
+      ...normalizeArguments(propertiesOrHint, hint)
+    }), chai.util.flag(this, "message"));
+  }));
+  utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(filepath, hint) {
+    utils.flag(this, "_name", "toMatchFileSnapshot");
+    validateAssertion(this);
+    const assertPromise = toMatchFileSnapshotImpl({
+      assertion: this,
+      received: utils.flag(this, "object"),
+      filepath,
+      hint
+    }).then((result) => assertMatchResult(result, chai.util.flag(this, "message")));
+    return recordAsyncExpect(getTest(this), assertPromise, createAssertionMessage(utils, this, true), /* @__PURE__ */ new Error("resolves"), utils.flag(this, "soft"));
+  });
+  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+    return assertMatchResult(toMatchSnapshotImpl({
+      assertion: this,
+      received: utils.flag(this, "object"),
+      isInline: true,
+      ...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
+    }), chai.util.flag(this, "message"));
+  }));
+  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(propertiesOrHint, hint) {
+    validateAssertion(this);
+    const received = utils.flag(this, "object");
+    const promise = utils.flag(this, "promise");
+    return assertMatchResult(toMatchSnapshotImpl({
+      assertion: this,
+      received: getError(received, promise),
+      ...normalizeArguments(propertiesOrHint, hint)
+    }), chai.util.flag(this, "message"));
+  }));
+  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshotOrHint, hint) {
+    validateAssertion(this);
+    const received = utils.flag(this, "object");
+    const promise = utils.flag(this, "promise");
+    return assertMatchResult(toMatchSnapshotImpl({
+      assertion: this,
+      received: getError(received, promise),
+      isInline: true,
+      ...normalizeInlineArguments(void 0, inlineSnapshotOrHint, hint)
+    }), chai.util.flag(this, "message"));
+  }));
+  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+};
+function normalizeArguments(propertiesOrHint, hint) {
+  if (typeof propertiesOrHint === "string") return { hint: propertiesOrHint };
+  return {
+    properties: propertiesOrHint,
+    hint
+  };
+}
+function normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+  let inlineSnapshot;
+  if (typeof propertiesOrInlineSnapshot === "string") {
+    inlineSnapshot = stripSnapshotIndentation(propertiesOrInlineSnapshot);
+    return {
+      inlineSnapshot,
+      hint: inlineSnapshotOrHint
+    };
+  }
+  if (inlineSnapshotOrHint) inlineSnapshot = stripSnapshotIndentation(inlineSnapshotOrHint);
+  return {
+    properties: propertiesOrInlineSnapshot,
+    inlineSnapshot,
+    hint
+  };
+}
+function toMatchSnapshotImpl(options) {
+  const { assertion } = options;
+  validateAssertion(assertion);
+  const assertionName = getAssertionName(assertion);
+  const test5 = getTest(assertion);
+  return getSnapshotClient().match({
+    received: options.received,
+    properties: options.properties,
+    message: options.hint,
+    isInline: options.isInline,
+    inlineSnapshot: options.inlineSnapshot,
+    assertionName,
+    error: chai_exports.util.flag(assertion, "error"),
+    ...getTestNames(test5)
+  });
+}
+async function toMatchFileSnapshotImpl(options) {
+  const { assertion } = options;
+  validateAssertion(assertion);
+  const testNames = getTestNames(getTest(assertion));
+  const snapshotState = getSnapshotClient().getSnapshotState(testNames.filepath);
+  const rawSnapshotFile = await snapshotState.environment.resolveRawPath(testNames.filepath, options.filepath);
+  const rawSnapshotContent = await snapshotState.environment.readSnapshotFile(rawSnapshotFile);
+  return getSnapshotClient().match({
+    received: options.received,
+    message: options.hint,
+    rawSnapshot: {
+      file: rawSnapshotFile,
+      content: rawSnapshotContent ?? void 0
+    },
+    ...testNames
+  });
+}
+function assertMatchResult(result, customMessage) {
+  if (!result.pass) {
+    const errorMessage = (customMessage ? `${customMessage}: ` : "") + result.message();
+    throw Object.assign(new Error(errorMessage), {
+      actual: result.actual,
+      expected: result.expected,
+      diffOptions: { expand: getWorkerState().config.snapshotOptions.expand }
+    });
+  }
+}
+chai_exports.use(JestExtend);
+chai_exports.use(JestChaiExpect);
+chai_exports.use(ChaiStyleAssertions);
+chai_exports.use(SnapshotPlugin);
+chai_exports.use(JestAsymmetricMatchers);
+function createExpect(test5) {
+  const expect2 = ((value, message) => {
+    const { assertionCalls } = getState(expect2);
+    setState({ assertionCalls: assertionCalls + 1 }, expect2);
+    const assert5 = chai_exports.expect(value, message);
+    const _test2 = test5 || getCurrentTest();
+    if (_test2)
+      return assert5.withTest(_test2);
+    else return assert5;
+  });
+  Object.assign(expect2, chai_exports.expect);
+  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+  expect2.getState = () => getState(expect2);
+  expect2.setState = (state) => setState(state, expect2);
+  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+  setState({
+    ...globalState,
+    assertionCalls: 0,
+    isExpectingAssertions: false,
+    isExpectingAssertionsError: null,
+    expectedAssertionsNumber: null,
+    expectedAssertionsNumberErrorGen: null,
+    get testPath() {
+      return getWorkerState().filepath;
+    },
+    currentTestName: test5 ? test5.fullTestName ?? "" : globalState.currentTestName
+  }, expect2);
+  expect2.assert = chai_exports.assert;
+  expect2.extend = (matchers) => chai_exports.expect.extend(expect2, matchers);
+  expect2.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+  expect2.soft = (...args) => {
+    return expect2(...args).withContext({ soft: true });
+  };
+  expect2.poll = createExpectPoll(expect2);
+  expect2.unreachable = (message) => {
+    chai_exports.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+  };
+  function assertions(expected) {
+    const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
+    if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+    expect2.setState({
+      expectedAssertionsNumber: expected,
+      expectedAssertionsNumberErrorGen: errorGen
+    });
+  }
+  function hasAssertions() {
+    const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
+    if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
+    expect2.setState({
+      isExpectingAssertions: true,
+      isExpectingAssertionsError: error
+    });
+  }
+  chai_exports.util.addMethod(expect2, "assertions", assertions);
+  chai_exports.util.addMethod(expect2, "hasAssertions", hasAssertions);
+  expect2.extend(customMatchers);
+  return expect2;
+}
+var globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+  value: globalExpect,
+  writable: true,
+  configurable: true
+});
+var assert4 = chai_exports.assert;
+var should2 = chai_exports.should;
 
 // ../../node_modules/vite/dist/node/module-runner.js
 var SOURCEMAPPING_URL = "sourceMa";