vitest 0.26.3 → 0.27.0

package/dist/{chunk-runtime-chain.f51aa930.js → chunk-runtime-chain.6df5a66b.js}

@@ -1,15 +1,16 @@
 import util$1 from 'util';
 import * as chai$2 from 'chai';
-import { expect, AssertionError, util } from 'chai';
-import { i as isObject, b as getCallLastIndex, s as slash, g as getWorkerState, c as getNames, d as assertTypes, e as getCurrentEnvironment, f as getFullName, o as objectAttr, n as noop, h as isRunningInTest, j as isRunningInBenchmark } from './chunk-typecheck-constants.06e1fe5b.js';
+import { AssertionError, util, expect } from 'chai';
+import { i as isObject$1, b as getCallLastIndex, s as slash, g as getWorkerState, c as getNames, d as getCurrentEnvironment, e as getFullName, o as objectAttr, n as noop, f as isRunningInTest, h as isRunningInBenchmark } from './chunk-mock-date.a1c85759.js';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import { r as rpc } from './chunk-runtime-rpc.54d72169.js';
+import c from 'picocolors';
+import { c as createPatch, a as stringify, p as plugins_1, f as format_1, s as safeSetTimeout, b as safeClearTimeout } from './chunk-utils-timers.52534f96.js';
+import { i as isMockFunction } from './vendor-index.723a074f.js';
+import { c as cliTruncate, a as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, b as parseStacktrace } from './chunk-utils-source-map.60562959.js';
+import { r as rpc } from './chunk-runtime-rpc.7f83c8a9.js';
 import fs from 'node:fs';
-import { j as join, d as dirname, p as picocolors } from './chunk-utils-env.3fdc1793.js';
-import { p as plugins_1, f as format_1, u as unifiedDiff, a as stringify, m as matcherUtils, s as safeSetTimeout, b as safeClearTimeout } from './chunk-utils-timers.715da787.js';
-import { a as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, p as parseStacktrace } from './chunk-utils-source-map.5278ee22.js';
+import { j as join, d as dirname } from './chunk-utils-env.b861e3a0.js';
 import { promises } from 'fs';
-import { isMockFunction } from './spy.js';
 
 function createChainable(keys, fn) {
   function create(context) {
@@ -121,6 +122,203 @@ var chaiSubset = {exports: {}};
 
 var Subset = chaiSubset.exports;
 
+function formatLine(line, outputTruncateLength) {
+  var _a;
+  return cliTruncate(line, (outputTruncateLength ?? (((_a = process.stdout) == null ? void 0 : _a.columns) || 80)) - 4);
+}
+function unifiedDiff(actual, expected, options = {}) {
+  if (actual === expected)
+    return "";
+  const { outputTruncateLength, outputDiffLines, outputDiffMaxLines, noColor, showLegend = true } = options;
+  const indent = "  ";
+  const diffLimit = outputDiffLines || 15;
+  const diffMaxLines = outputDiffMaxLines || 50;
+  const counts = {
+    "+": 0,
+    "-": 0
+  };
+  let previousState = null;
+  let previousCount = 0;
+  const str = (str2) => str2;
+  const dim = noColor ? str : c.dim;
+  const green = noColor ? str : c.green;
+  const red = noColor ? str : c.red;
+  function preprocess(line) {
+    if (!line || line.match(/\\ No newline/))
+      return;
+    const char = line[0];
+    if ("-+".includes(char)) {
+      if (previousState !== char) {
+        previousState = char;
+        previousCount = 0;
+      }
+      previousCount++;
+      counts[char]++;
+      if (previousCount === diffLimit)
+        return dim(`${char} ...`);
+      else if (previousCount > diffLimit)
+        return;
+    }
+    return line;
+  }
+  const msg = createPatch("string", expected, actual);
+  let lines = msg.split("\n").slice(5).map(preprocess).filter(Boolean);
+  let moreLines = 0;
+  const isCompact = counts["+"] === 1 && counts["-"] === 1 && lines.length === 2;
+  if (lines.length > diffMaxLines) {
+    const firstDiff = lines.findIndex((line) => line[0] === "-" || line[0] === "+");
+    const displayLines = lines.slice(firstDiff - 2, diffMaxLines);
+    const lastDisplayedIndex = firstDiff - 2 + diffMaxLines;
+    if (lastDisplayedIndex < lines.length)
+      moreLines = lines.length - lastDisplayedIndex;
+    lines = displayLines;
+  }
+  let formatted = lines.map((line) => {
+    line = line.replace(/\\"/g, '"');
+    if (line[0] === "-") {
+      line = formatLine(line.slice(1), outputTruncateLength);
+      if (isCompact)
+        return green(line);
+      return green(`- ${formatLine(line, outputTruncateLength)}`);
+    }
+    if (line[0] === "+") {
+      line = formatLine(line.slice(1), outputTruncateLength);
+      if (isCompact)
+        return red(line);
+      return red(`+ ${formatLine(line, outputTruncateLength)}`);
+    }
+    if (line.match(/@@/))
+      return "--";
+    return ` ${line}`;
+  });
+  if (moreLines)
+    formatted.push(dim(`... ${moreLines} more lines`));
+  if (showLegend) {
+    if (isCompact) {
+      formatted = [
+        `${green("- Expected")}   ${formatted[0]}`,
+        `${red("+ Received")}   ${formatted[1]}`
+      ];
+    } else {
+      if (formatted[0].includes('"'))
+        formatted[0] = formatted[0].replace('"', "");
+      const last = formatted.length - 1;
+      if (formatted[last].endsWith('"'))
+        formatted[last] = formatted[last].slice(0, formatted[last].length - 1);
+      formatted.unshift(
+        green(`- Expected  - ${counts["-"]}`),
+        red(`+ Received  + ${counts["+"]}`),
+        ""
+      );
+    }
+  }
+  return formatted.map((i) => i ? indent + i : i).join("\n");
+}
+
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass)
+    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+
+const MATCHERS_OBJECT = Symbol.for("matchers-object");
+const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
+const GLOBAL_EXPECT = Symbol.for("expect-global");
+if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
+  const globalState = /* @__PURE__ */ new WeakMap();
+  const matchers = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
+    get: () => globalState
+  });
+  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
+    configurable: true,
+    get: () => ({
+      state: globalState.get(globalThis[GLOBAL_EXPECT]),
+      matchers
+    })
+  });
+}
+const getState = (expect) => globalThis[MATCHERS_OBJECT].get(expect);
+const setState = (state, expect) => {
+  const map = globalThis[MATCHERS_OBJECT];
+  const current = map.get(expect) || {};
+  Object.assign(current, state);
+  map.set(expect, current);
+};
+const EXPECTED_COLOR = c.green;
+const RECEIVED_COLOR = c.red;
+const INVERTED_COLOR = c.inverse;
+const BOLD_WEIGHT = c.bold;
+const DIM_COLOR = c.dim;
+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 = "";
+  let dimString = "expect";
+  if (!isDirectExpectCall && received !== "") {
+    hint += DIM_COLOR(`${dimString}(`) + receivedColor(received);
+    dimString = ")";
+  }
+  if (promise !== "") {
+    hint += DIM_COLOR(`${dimString}.`) + promise;
+    dimString = "";
+  }
+  if (isNot) {
+    hint += `${DIM_COLOR(`${dimString}.`)}not`;
+    dimString = "";
+  }
+  if (matcherName.includes(".")) {
+    dimString += matcherName;
+  } else {
+    hint += DIM_COLOR(`${dimString}.`) + matcherName;
+    dimString = "";
+  }
+  if (expected === "") {
+    dimString += "()";
+  } else {
+    hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
+    if (secondArgument)
+      hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
+    dimString = ")";
+  }
+  if (comment !== "")
+    dimString += ` // ${comment}`;
+  if (dimString !== "")
+    hint += DIM_COLOR(dimString);
+  return hint;
+}
+const SPACE_SYMBOL = "\xB7";
+const replaceTrailingSpaces = (text) => text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+const printReceived = (object) => RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
+const printExpected = (value) => EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
+function diff(a, b, options) {
+  return unifiedDiff(stringify(b), stringify(a));
+}
+var matcherUtils = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  stringify,
+  EXPECTED_COLOR,
+  RECEIVED_COLOR,
+  INVERTED_COLOR,
+  BOLD_WEIGHT,
+  DIM_COLOR,
+  matcherHint,
+  printReceived,
+  printExpected,
+  diff
+});
 function equals(a, b, customTesters, strictCheck) {
   customTesters = customTesters || [];
   return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
@@ -378,752 +576,218 @@ Received: serializes to the same string
 `;
   return toBeMessage;
 };
-
-var naturalCompare$1 = {exports: {}};
-
-/*
- * @version    1.4.0
- * @date       2015-10-26
- * @stability  3 - Stable
- * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
- * @license    MIT License
- */
-
-
-var naturalCompare = function(a, b) {
-	var i, codeA
-	, codeB = 1
-	, posA = 0
-	, posB = 0
-	, alphabet = String.alphabet;
-
-	function getCode(str, pos, code) {
-		if (code) {
-			for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
-			return +str.slice(pos - 1, i)
-		}
-		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        // 0-9
-			: code < 65 ? code - 11
-			: code < 91 ? code + 11        // A-Z
-			: code < 97 ? code - 37
-			: code < 123 ? code + 5        // a-z
-			: code - 63
-	}
-
-
-	if ((a+="") != (b+="")) for (;codeB;) {
-		codeA = getCode(a, posA++);
-		codeB = getCode(b, posB++);
-
-		if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
-			codeA = getCode(a, posA, posA);
-			codeB = getCode(b, posB, posA = i);
-			posB = i;
-		}
-
-		if (codeA != codeB) return (codeA < codeB) ? -1 : 1
-	}
-	return 0
-};
-
-try {
-	naturalCompare$1.exports = naturalCompare;
-} catch (e) {
-	String.naturalCompare = naturalCompare;
-}
-
-const serialize$1 = (val, config, indentation, depth, refs, printer) => {
-  const name = val.getMockName();
-  const nameString = name === "vi.fn()" ? "" : ` ${name}`;
-  let callsString = "";
-  if (val.mock.calls.length !== 0) {
-    const indentationNext = indentation + config.indent;
-    callsString = ` {${config.spacingOuter}${indentationNext}"calls": ${printer(val.mock.calls, config, indentationNext, depth, refs)}${config.min ? ", " : ","}${config.spacingOuter}${indentationNext}"results": ${printer(val.mock.results, config, indentationNext, depth, refs)}${config.min ? "" : ","}${config.spacingOuter}${indentation}}`;
+class AsymmetricMatcher$1 {
+  constructor(sample, inverse = false) {
+    this.sample = sample;
+    this.inverse = inverse;
+    this.$$typeof = Symbol.for("jest.asymmetricMatcher");
   }
-  return `[MockFunction${nameString}]${callsString}`;
-};
-const test$1 = (val) => val && !!val._isMockFunction;
-const plugin = { serialize: serialize$1, test: test$1 };
-
-const {
-  DOMCollection,
-  DOMElement,
-  Immutable,
-  ReactElement,
-  ReactTestComponent,
-  AsymmetricMatcher: AsymmetricMatcher$1
-} = plugins_1;
-let PLUGINS = [
-  ReactTestComponent,
-  ReactElement,
-  DOMElement,
-  DOMCollection,
-  Immutable,
-  AsymmetricMatcher$1,
-  plugin
-];
-const addSerializer = (plugin) => {
-  PLUGINS = [plugin].concat(PLUGINS);
-};
-const getSerializers = () => PLUGINS;
-
-const SNAPSHOT_VERSION = "1";
-const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}`;
-const testNameToKey = (testName, count) => `${testName} ${count}`;
-const keyToTestName = (key) => {
-  if (!/ \d+$/.test(key))
-    throw new Error("Snapshot keys must end with a number.");
-  return key.replace(/ \d+$/, "");
-};
-const getSnapshotData = (snapshotPath, update) => {
-  const data = /* @__PURE__ */ Object.create(null);
-  let snapshotContents = "";
-  let dirty = false;
-  if (fs.existsSync(snapshotPath)) {
-    try {
-      snapshotContents = fs.readFileSync(snapshotPath, "utf8");
-      const populate = new Function("exports", snapshotContents);
-      populate(data);
-    } catch {
-    }
+  getMatcherContext(expect) {
+    return {
+      ...getState(expect || globalThis[GLOBAL_EXPECT]),
+      equals,
+      isNot: this.inverse,
+      utils: matcherUtils
+    };
   }
-  const isInvalid = snapshotContents;
-  if ((update === "all" || update === "new") && isInvalid)
-    dirty = true;
-  return { data, dirty };
-};
-const addExtraLineBreaks = (string) => string.includes("\n") ? `
-${string}
-` : string;
-const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
-const escapeRegex = true;
-const printFunctionName = false;
-function serialize(val, indent = 2, formatOverrides = {}) {
-  return normalizeNewlines(
-    format_1(val, {
-      escapeRegex,
-      indent,
-      plugins: getSerializers(),
-      printFunctionName,
-      ...formatOverrides
-    })
-  );
-}
-function escapeBacktickString(str) {
-  return str.replace(/`|\\|\${/g, "\\$&");
 }
-function printBacktickString(str) {
-  return `\`${escapeBacktickString(str)}\``;
-}
-function ensureDirectoryExists(filePath) {
-  try {
-    fs.mkdirSync(join(dirname(filePath)), { recursive: true });
-  } catch {
+class StringContaining extends AsymmetricMatcher$1 {
+  constructor(sample, inverse = false) {
+    if (!isA("String", sample))
+      throw new Error("Expected is not a string");
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    const result = isA("String", other) && other.includes(this.sample);
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `String${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "string";
   }
 }
-function normalizeNewlines(string) {
-  return string.replace(/\r\n|\r/g, "\n");
-}
-async function saveSnapshotFile(snapshotData, snapshotPath) {
-  var _a, _b;
-  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map(
-    (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`
-  );
-  const content = `${writeSnapshotVersion()}
-
-${snapshots.join("\n\n")}
-`;
-  const skipWriting = fs.existsSync(snapshotPath) && await ((_a = fs) == null ? void 0 : _a.promises.readFile(snapshotPath, "utf8")) === content;
-  if (skipWriting)
-    return;
-  ensureDirectoryExists(snapshotPath);
-  await ((_b = fs) == null ? void 0 : _b.promises.writeFile(
-    snapshotPath,
-    content,
-    "utf-8"
-  ));
-}
-function prepareExpected(expected) {
-  function findStartIndent() {
-    var _a, _b;
-    const matchObject = /^( +)}\s+$/m.exec(expected || "");
-    const objectIndent = (_a = matchObject == null ? void 0 : matchObject[1]) == null ? void 0 : _a.length;
-    if (objectIndent)
-      return objectIndent;
-    const matchText = /^\n( +)"/.exec(expected || "");
-    return ((_b = matchText == null ? void 0 : matchText[1]) == null ? void 0 : _b.length) || 0;
+class Anything extends AsymmetricMatcher$1 {
+  asymmetricMatch(other) {
+    return other != null;
   }
-  const startIndent = findStartIndent();
-  let expectedTrimmed = expected == null ? void 0 : expected.trim();
-  if (startIndent) {
-    expectedTrimmed = expectedTrimmed == null ? void 0 : expectedTrimmed.replace(new RegExp(`^${" ".repeat(startIndent)}`, "gm"), "").replace(/ +}$/, "}");
+  toString() {
+    return "Anything";
+  }
+  toAsymmetricMatcher() {
+    return "Anything";
   }
-  return expectedTrimmed;
 }
-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);
-    } else {
-      mergedOutput[index] = sourceElement;
-    }
-  });
-  return mergedOutput;
-}
-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]);
-      } else {
-        Object.assign(mergedOutput, { [key]: source[key] });
-      }
-    });
-    return mergedOutput;
-  } else if (Array.isArray(target) && Array.isArray(source)) {
-    return deepMergeArray(target, source);
-  }
-  return target;
-}
-
-async function saveInlineSnapshots(snapshots) {
-  const MagicString = (await import('./chunk-magic-string.3a794426.js')).default;
-  const files = new Set(snapshots.map((i) => i.file));
-  await Promise.all(Array.from(files).map(async (file) => {
-    const snaps = snapshots.filter((i) => i.file === file);
-    const code = await promises.readFile(file, "utf8");
-    const s = new MagicString(code);
-    for (const snap of snaps) {
-      const index = positionToOffset(code, snap.line, snap.column);
-      replaceInlineSnap(code, s, index, snap.snapshot);
-    }
-    const transformed = s.toString();
-    if (transformed !== code)
-      await promises.writeFile(file, transformed, "utf-8");
-  }));
-}
-const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\S\s]*\*\/\s*|\/\/.*\s+)*\s*({)/m;
-function replaceObjectSnap(code, s, index, newSnap) {
-  code = code.slice(index);
-  const startMatch = startObjectRegex.exec(code);
-  if (!startMatch)
-    return false;
-  code = code.slice(startMatch.index);
-  const charIndex = getCallLastIndex(code);
-  if (charIndex === null)
-    return false;
-  s.appendLeft(index + startMatch.index + charIndex, `, ${prepareSnapString(newSnap, code, index)}`);
-  return true;
-}
-function prepareSnapString(snap, source, index) {
-  const lineNumber = offsetToLineNumber(source, index);
-  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 = isOneline ? "'" : "`";
-  if (isOneline)
-    return `'${lines.join("\n").replace(/'/g, "\\'")}'`;
-  else
-    return `${quote}
-${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\${/g, "\\${")}
-${indent}${quote}`;
-}
-const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\S\s]*\*\/\s*|\/\/.*\s+)*\s*[\w_$]*(['"`\)])/m;
-function replaceInlineSnap(code, s, index, newSnap) {
-  const startMatch = startRegex.exec(code.slice(index));
-  if (!startMatch)
-    return replaceObjectSnap(code, s, index, newSnap);
-  const quote = startMatch[1];
-  const startIndex = index + startMatch.index + startMatch[0].length;
-  const snapString = prepareSnapString(newSnap, code, index);
-  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;
-}
-const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
-function stripSnapshotIndentation(inlineSnapshot) {
-  const match = inlineSnapshot.match(INDENTATION_REGEX);
-  if (!match || !match[1]) {
-    return inlineSnapshot;
+class ObjectContaining extends AsymmetricMatcher$1 {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
   }
-  const indentation = match[1];
-  const lines = inlineSnapshot.split(/\n/g);
-  if (lines.length <= 2) {
-    return inlineSnapshot;
+  getPrototype(obj) {
+    if (Object.getPrototypeOf)
+      return Object.getPrototypeOf(obj);
+    if (obj.constructor.prototype === obj)
+      return null;
+    return obj.constructor.prototype;
   }
-  if (lines[0].trim() !== "" || lines[lines.length - 1].trim() !== "") {
-    return inlineSnapshot;
+  hasProperty(obj, property) {
+    if (!obj)
+      return false;
+    if (Object.prototype.hasOwnProperty.call(obj, property))
+      return true;
+    return this.hasProperty(this.getPrototype(obj), property);
   }
-  for (let i = 1; i < lines.length - 1; i++) {
-    if (lines[i] !== "") {
-      if (lines[i].indexOf(indentation) !== 0) {
-        return inlineSnapshot;
+  asymmetricMatch(other) {
+    if (typeof this.sample !== "object") {
+      throw new TypeError(
+        `You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`
+      );
+    }
+    let result = true;
+    for (const property in this.sample) {
+      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property])) {
+        result = false;
+        break;
       }
-      lines[i] = lines[i].substring(indentation.length);
     }
+    return this.inverse ? !result : result;
   }
-  lines[lines.length - 1] = "";
-  inlineSnapshot = lines.join("\n");
-  return inlineSnapshot;
-}
-
-class SnapshotState {
-  constructor(testFilePath, snapshotPath, options) {
-    this.testFilePath = testFilePath;
-    this.snapshotPath = snapshotPath;
-    const { data, dirty } = getSnapshotData(
-      this.snapshotPath,
-      options.updateSnapshot
-    );
-    this._initialData = data;
-    this._snapshotData = data;
-    this._dirty = dirty;
-    this._inlineSnapshots = [];
-    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
-    this._counters = /* @__PURE__ */ new Map();
-    this.expand = options.expand || false;
-    this.added = 0;
-    this.matched = 0;
-    this.unmatched = 0;
-    this._updateSnapshot = options.updateSnapshot;
-    this.updated = 0;
-    this._snapshotFormat = {
-      printBasicPrototype: false,
-      ...options.snapshotFormat
-    };
+  toString() {
+    return `Object${this.inverse ? "Not" : ""}Containing`;
   }
-  markSnapshotsAsCheckedForTest(testName) {
-    this._uncheckedKeys.forEach((uncheckedKey) => {
-      if (keyToTestName(uncheckedKey) === testName)
-        this._uncheckedKeys.delete(uncheckedKey);
-    });
+  getExpectedType() {
+    return "object";
   }
-  _inferInlineSnapshotStack(stacks) {
-    const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
-    if (promiseIndex !== -1)
-      return stacks[promiseIndex + 3];
-    const stackIndex = stacks.findIndex((i) => i.method.includes("__VITEST_INLINE_SNAPSHOT__"));
-    return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
+}
+class ArrayContaining extends AsymmetricMatcher$1 {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
   }
-  _addSnapshot(key, receivedSerialized, options) {
-    this._dirty = true;
-    if (options.isInline) {
-      const error = options.error || new Error("Unknown error");
-      const stacks = parseStacktrace(error, true);
-      stacks.forEach((i) => i.file = slash(i.file));
-      const stack = this._inferInlineSnapshotStack(stacks);
-      if (!stack) {
-        throw new Error(
-          `Vitest: Couldn't infer stack frame for inline snapshot.
-${JSON.stringify(stacks)}`
-        );
-      }
-      stack.column--;
-      this._inlineSnapshots.push({
-        snapshot: receivedSerialized,
-        ...stack
-      });
-    } else {
-      this._snapshotData[key] = receivedSerialized;
+  asymmetricMatch(other) {
+    if (!Array.isArray(this.sample)) {
+      throw new TypeError(
+        `You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`
+      );
     }
+    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every(
+      (item) => other.some((another) => equals(item, another))
+    );
+    return this.inverse ? !result : result;
   }
-  clear() {
-    this._snapshotData = this._initialData;
-    this._counters = /* @__PURE__ */ new Map();
-    this.added = 0;
-    this.matched = 0;
-    this.unmatched = 0;
-    this.updated = 0;
-    this._dirty = false;
+  toString() {
+    return `Array${this.inverse ? "Not" : ""}Containing`;
   }
-  async save() {
-    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
-    const hasInlineSnapshots = this._inlineSnapshots.length;
-    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
-    const status = {
-      deleted: false,
-      saved: false
-    };
-    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
-      if (hasExternalSnapshots)
-        await saveSnapshotFile(this._snapshotData, this.snapshotPath);
-      if (hasInlineSnapshots)
-        await saveInlineSnapshots(this._inlineSnapshots);
-      status.saved = true;
-    } else if (!hasExternalSnapshots && fs.existsSync(this.snapshotPath)) {
-      if (this._updateSnapshot === "all")
-        fs.unlinkSync(this.snapshotPath);
-      status.deleted = true;
+  getExpectedType() {
+    return "array";
+  }
+}
+class Any extends AsymmetricMatcher$1 {
+  constructor(sample) {
+    if (typeof sample === "undefined") {
+      throw new TypeError(
+        "any() expects to be passed a constructor function. Please pass one or use anything() to match any object."
+      );
     }
-    return status;
+    super(sample);
   }
-  getUncheckedCount() {
-    return this._uncheckedKeys.size || 0;
+  fnNameFor(func) {
+    if (func.name)
+      return func.name;
+    const functionToString2 = Function.prototype.toString;
+    const matches = functionToString2.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    return matches ? matches[1] : "<anonymous>";
   }
-  getUncheckedKeys() {
-    return Array.from(this._uncheckedKeys);
+  asymmetricMatch(other) {
+    if (this.sample === String)
+      return typeof other == "string" || other instanceof String;
+    if (this.sample === Number)
+      return typeof other == "number" || other instanceof Number;
+    if (this.sample === Function)
+      return typeof other == "function" || other instanceof Function;
+    if (this.sample === Boolean)
+      return typeof other == "boolean" || other instanceof Boolean;
+    if (this.sample === BigInt)
+      return typeof other == "bigint" || other instanceof BigInt;
+    if (this.sample === Symbol)
+      return typeof other == "symbol" || other instanceof Symbol;
+    if (this.sample === Object)
+      return typeof other == "object";
+    return other instanceof this.sample;
   }
-  removeUncheckedKeys() {
-    if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
-      this._dirty = true;
-      this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
-      this._uncheckedKeys.clear();
-    }
+  toString() {
+    return "Any";
   }
-  match({
-    testName,
-    received,
-    key,
-    inlineSnapshot,
-    isInline,
-    error
-  }) {
-    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
-    const count = Number(this._counters.get(testName));
-    if (!key)
-      key = testNameToKey(testName, count);
-    if (!(isInline && this._snapshotData[key] !== void 0))
-      this._uncheckedKeys.delete(key);
-    const receivedSerialized = addExtraLineBreaks(serialize(received, void 0, this._snapshotFormat));
-    const expected = isInline ? inlineSnapshot : this._snapshotData[key];
-    const expectedTrimmed = prepareExpected(expected);
-    const pass = expectedTrimmed === prepareExpected(receivedSerialized);
-    const hasSnapshot = expected !== void 0;
-    const snapshotIsPersisted = isInline || fs.existsSync(this.snapshotPath);
-    if (pass && !isInline) {
-      this._snapshotData[key] = receivedSerialized;
-    }
-    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-      if (this._updateSnapshot === "all") {
-        if (!pass) {
-          if (hasSnapshot)
-            this.updated++;
-          else
-            this.added++;
-          this._addSnapshot(key, receivedSerialized, { error, isInline });
-        } else {
-          this.matched++;
-        }
-      } else {
-        this._addSnapshot(key, receivedSerialized, { error, isInline });
-        this.added++;
-      }
-      return {
-        actual: "",
-        count,
-        expected: "",
-        key,
-        pass: true
-      };
-    } else {
-      if (!pass) {
-        this.unmatched++;
-        return {
-          actual: removeExtraLineBreaks(receivedSerialized),
-          count,
-          expected: expectedTrimmed !== void 0 ? removeExtraLineBreaks(expectedTrimmed) : void 0,
-          key,
-          pass: false
-        };
-      } else {
-        this.matched++;
-        return {
-          actual: "",
-          count,
-          expected: "",
-          key,
-          pass: true
-        };
-      }
-    }
+  getExpectedType() {
+    if (this.sample === String)
+      return "string";
+    if (this.sample === Number)
+      return "number";
+    if (this.sample === Function)
+      return "function";
+    if (this.sample === Object)
+      return "object";
+    if (this.sample === Boolean)
+      return "boolean";
+    return this.fnNameFor(this.sample);
   }
-  async pack() {
-    const snapshot = {
-      filepath: this.testFilePath,
-      added: 0,
-      fileDeleted: false,
-      matched: 0,
-      unchecked: 0,
-      uncheckedKeys: [],
-      unmatched: 0,
-      updated: 0
-    };
-    const uncheckedCount = this.getUncheckedCount();
-    const uncheckedKeys = this.getUncheckedKeys();
-    if (uncheckedCount)
-      this.removeUncheckedKeys();
-    const status = await this.save();
-    snapshot.fileDeleted = status.deleted;
-    snapshot.added = this.added;
-    snapshot.matched = this.matched;
-    snapshot.unmatched = this.unmatched;
-    snapshot.updated = this.updated;
-    snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
-    snapshot.uncheckedKeys = Array.from(uncheckedKeys);
-    return snapshot;
+  toAsymmetricMatcher() {
+    return `Any<${this.fnNameFor(this.sample)}>`;
   }
 }
-
-class SnapshotClient {
-  constructor() {
-    this.snapshotStateMap = /* @__PURE__ */ new Map();
-  }
-  async setTest(test) {
-    var _a;
-    this.test = test;
-    if (((_a = this.snapshotState) == null ? void 0 : _a.testFilePath) !== this.test.file.filepath) {
-      this.saveCurrent();
-      const filePath = this.test.file.filepath;
-      if (!this.getSnapshotState(test)) {
-        this.snapshotStateMap.set(
-          filePath,
-          new SnapshotState(
-            filePath,
-            await rpc().resolveSnapshotPath(filePath),
-            getWorkerState().config.snapshotOptions
-          )
-        );
-      }
-      this.snapshotState = this.getSnapshotState(test);
-    }
-  }
-  getSnapshotState(test) {
-    return this.snapshotStateMap.get(test.file.filepath);
-  }
-  clearTest() {
-    this.test = void 0;
-  }
-  skipTestSnapshots(test) {
-    var _a;
-    (_a = this.snapshotState) == null ? void 0 : _a.markSnapshotsAsCheckedForTest(test.name);
+class StringMatching extends AsymmetricMatcher$1 {
+  constructor(sample, inverse = false) {
+    if (!isA("String", sample) && !isA("RegExp", sample))
+      throw new Error("Expected is not a String or a RegExp");
+    super(new RegExp(sample), inverse);
   }
-  assert(options) {
-    const {
-      test = this.test,
-      message,
-      isInline = false,
-      properties,
-      inlineSnapshot,
-      error,
-      errorMessage
-    } = options;
-    let { received } = options;
-    if (!test)
-      throw new Error("Snapshot cannot be used outside of test");
-    if (typeof properties === "object") {
-      if (typeof received !== "object" || !received)
-        throw new Error("Received value must be an object when the matcher has properties");
-      try {
-        const pass2 = equals(received, properties, [iterableEquality, subsetEquality]);
-        if (!pass2)
-          expect(received).equals(properties);
-        else
-          received = deepMergeSnapshot(received, properties);
-      } catch (err) {
-        err.message = errorMessage || "Snapshot mismatched";
-        throw err;
-      }
-    }
-    const testName = [
-      ...getNames(test).slice(1),
-      ...message ? [message] : []
-    ].join(" > ");
-    const snapshotState = this.getSnapshotState(test);
-    const { actual, expected, key, pass } = snapshotState.match({
-      testName,
-      received,
-      isInline,
-      error,
-      inlineSnapshot
-    });
-    if (!pass) {
-      try {
-        expect(actual.trim()).equals(expected ? expected.trim() : "");
-      } catch (error2) {
-        error2.message = errorMessage || `Snapshot \`${key || "unknown"}\` mismatched`;
-        throw error2;
-      }
-    }
+  asymmetricMatch(other) {
+    const result = isA("String", other) && this.sample.test(other);
+    return this.inverse ? !result : result;
   }
-  async saveCurrent() {
-    if (!this.snapshotState)
-      return;
-    const result = await this.snapshotState.pack();
-    await rpc().snapshotSaved(result);
-    this.snapshotState = void 0;
+  toString() {
+    return `String${this.inverse ? "Not" : ""}Matching`;
   }
-  clear() {
-    this.snapshotStateMap.clear();
+  getExpectedType() {
+    return "string";
   }
 }
-
-let _client;
-function getSnapshotClient() {
-  if (!_client)
-    _client = new SnapshotClient();
-  return _client;
-}
-const getErrorMessage = (err) => {
-  if (err instanceof Error)
-    return err.message;
-  return err;
-};
-const getErrorString = (expected, promise) => {
-  if (typeof expected !== "function") {
-    if (!promise)
-      throw new Error(`expected must be a function, received ${typeof expected}`);
-    return getErrorMessage(expected);
-  }
-  try {
-    expected();
-  } catch (e) {
-    return getErrorMessage(e);
-  }
-  throw new Error("snapshot function didn't throw");
-};
-const SnapshotPlugin = (chai, utils) => {
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(
-      chai.Assertion.prototype,
-      key,
-      function(properties, message) {
-        const expected = utils.flag(this, "object");
-        const test = utils.flag(this, "vitest-test");
-        if (typeof properties === "string" && typeof message === "undefined") {
-          message = properties;
-          properties = void 0;
-        }
-        const errorMessage = utils.flag(this, "message");
-        getSnapshotClient().assert({
-          received: expected,
-          test,
-          message,
-          isInline: false,
-          properties,
-          errorMessage
-        });
-      }
-    );
-  }
+const JestAsymmetricMatchers = (chai, utils) => {
   utils.addMethod(
-    chai.Assertion.prototype,
-    "toMatchInlineSnapshot",
-    function __VITEST_INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      const expected = utils.flag(this, "object");
-      const error = utils.flag(this, "error");
-      const test = utils.flag(this, "vitest-test");
-      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,
-        test,
-        message,
-        isInline: true,
-        properties,
-        inlineSnapshot,
-        error,
-        errorMessage
-      });
-    }
+    chai.expect,
+    "anything",
+    () => new Anything()
   );
   utils.addMethod(
-    chai.Assertion.prototype,
-    "toThrowErrorMatchingSnapshot",
-    function(message) {
-      const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: getErrorString(expected, promise),
-        test,
-        message,
-        errorMessage
-      });
-    }
+    chai.expect,
+    "any",
+    (expected) => new Any(expected)
   );
   utils.addMethod(
-    chai.Assertion.prototype,
-    "toThrowErrorMatchingInlineSnapshot",
-    function __VITEST_INLINE_SNAPSHOT__(inlineSnapshot, message) {
-      const expected = utils.flag(this, "object");
-      const error = utils.flag(this, "error");
-      const test = utils.flag(this, "vitest-test");
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: getErrorString(expected, promise),
-        test,
-        message,
-        inlineSnapshot,
-        isInline: true,
-        error,
-        errorMessage
-      });
-    }
+    chai.expect,
+    "stringContaining",
+    (expected) => new StringContaining(expected)
   );
-};
-
-var chai$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getSnapshotClient: getSnapshotClient,
-  SnapshotPlugin: SnapshotPlugin
-});
-
-const GLOBAL_EXPECT = Symbol.for("expect-global");
-const MATCHERS_OBJECT = Symbol.for("matchers-object");
-const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
-
-if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
-  const globalState = /* @__PURE__ */ new WeakMap();
-  const matchers = /* @__PURE__ */ Object.create(null);
-  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
-    get: () => globalState
-  });
-  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
-    configurable: true,
-    get: () => ({
-      state: globalState.get(globalThis[GLOBAL_EXPECT]),
-      matchers
-    })
-  });
-}
-const getState = (expect) => globalThis[MATCHERS_OBJECT].get(expect);
-const setState = (state, expect) => {
-  const map = globalThis[MATCHERS_OBJECT];
-  const current = map.get(expect) || {};
-  Object.assign(current, state);
-  map.set(expect, current);
+  utils.addMethod(
+    chai.expect,
+    "objectContaining",
+    (expected) => new ObjectContaining(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "arrayContaining",
+    (expected) => new ArrayContaining(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "stringMatching",
+    (expected) => new StringMatching(expected)
+  );
+  chai.expect.not = {
+    stringContaining: (expected) => new StringContaining(expected, true),
+    objectContaining: (expected) => new ObjectContaining(expected, true),
+    arrayContaining: (expected) => new ArrayContaining(expected, true),
+    stringMatching: (expected) => new StringMatching(expected, true)
+  };
 };
 const JestChaiExpect = (chai, utils) => {
   function def(name, fn) {
@@ -1430,11 +1094,11 @@ const JestChaiExpect = (chai, utils) => {
     return `${i}th`;
   };
   const formatCalls = (spy, msg, actualCall) => {
-    msg += picocolors.exports.gray(`
+    msg += c.gray(`
 
 Received: 
 ${spy.mock.calls.map((callArg, i) => {
-      let methodCall = picocolors.exports.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call:
+      let methodCall = c.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call:
 
 `);
       if (actualCall)
@@ -1444,18 +1108,18 @@ ${spy.mock.calls.map((callArg, i) => {
       methodCall += "\n";
       return methodCall;
     }).join("\n")}`);
-    msg += picocolors.exports.gray(`
+    msg += c.gray(`
 
-Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
+Number of calls: ${c.bold(spy.mock.calls.length)}
 `);
     return msg;
   };
   const formatReturns = (spy, msg, actualReturn) => {
-    msg += picocolors.exports.gray(`
+    msg += c.gray(`
 
 Received: 
 ${spy.mock.results.map((callReturn, i) => {
-      let methodCall = picocolors.exports.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
+      let methodCall = c.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
 
 `);
       if (actualReturn)
@@ -1465,9 +1129,9 @@ ${spy.mock.results.map((callReturn, i) => {
       methodCall += "\n";
       return methodCall;
     }).join("\n")}`);
-    msg += picocolors.exports.gray(`
+    msg += c.gray(`
 
-Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
+Number of calls: ${c.bold(spy.mock.calls.length)}
 `);
     return msg;
   };
@@ -1716,7 +1380,7 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
               return result.call(this, ...args);
             },
             (err) => {
-              throw new Error(`promise rejected "${toString(err)}" instead of resolving`);
+              throw new Error(`promise rejected "${String(err)}" instead of resolving`);
             }
           );
         };
@@ -1724,353 +1388,851 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     });
     return proxy;
   });
-  utils.addProperty(chai.Assertion.prototype, "rejects", function __VITEST_REJECTS__() {
-    utils.flag(this, "promise", "rejects");
-    utils.flag(this, "error", new Error("rejects"));
-    const obj = utils.flag(this, "object");
-    const wrapper = typeof obj === "function" ? obj() : obj;
-    if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function")
-      throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
-    const proxy = new Proxy(this, {
-      get: (target, key, receiver) => {
-        const result = Reflect.get(target, key, receiver);
-        if (typeof result !== "function")
-          return result instanceof chai.Assertion ? proxy : result;
-        return async (...args) => {
-          return wrapper.then(
-            (value) => {
-              throw new Error(`promise resolved "${toString(value)}" instead of rejecting`);
-            },
-            (err) => {
-              utils.flag(this, "object", err);
-              return result.call(this, ...args);
-            }
-          );
-        };
+  utils.addProperty(chai.Assertion.prototype, "rejects", function __VITEST_REJECTS__() {
+    utils.flag(this, "promise", "rejects");
+    utils.flag(this, "error", new Error("rejects"));
+    const obj = utils.flag(this, "object");
+    const wrapper = typeof obj === "function" ? obj() : obj;
+    if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function")
+      throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
+    const proxy = new Proxy(this, {
+      get: (target, key, receiver) => {
+        const result = Reflect.get(target, key, receiver);
+        if (typeof result !== "function")
+          return result instanceof chai.Assertion ? proxy : result;
+        return async (...args) => {
+          return wrapper.then(
+            (value) => {
+              throw new Error(`promise resolved "${String(value)}" instead of rejecting`);
+            },
+            (err) => {
+              utils.flag(this, "object", err);
+              return result.call(this, ...args);
+            }
+          );
+        };
+      }
+    });
+    return proxy;
+  });
+};
+const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTag] === "AsyncFunction";
+const getMatcherState = (assertion, expect) => {
+  const obj = assertion._obj;
+  const isNot = util.flag(assertion, "negate");
+  const promise = util.flag(assertion, "promise") || "";
+  const jestUtils = {
+    ...matcherUtils,
+    iterableEquality,
+    subsetEquality
+  };
+  const matcherState = {
+    ...getState(expect),
+    isNot,
+    utils: jestUtils,
+    promise,
+    equals,
+    suppressedErrors: []
+  };
+  return {
+    state: matcherState,
+    isNot,
+    obj
+  };
+};
+class JestExtendError extends Error {
+  constructor(message, actual, expected) {
+    super(message);
+    this.actual = actual;
+    this.expected = expected;
+  }
+}
+function JestExtendPlugin(expect, matchers) {
+  return (c2, utils) => {
+    Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
+      function expectSyncWrapper(...args) {
+        const { state, isNot, obj } = getMatcherState(this, expect);
+        const { pass, message, actual, expected } = expectAssertion.call(state, obj, ...args);
+        if (pass && isNot || !pass && !isNot)
+          throw new JestExtendError(message(), actual, expected);
+      }
+      async function expectAsyncWrapper(...args) {
+        const { state, isNot, obj } = getMatcherState(this, expect);
+        const { pass, message, actual, expected } = await expectAssertion.call(state, obj, ...args);
+        if (pass && isNot || !pass && !isNot)
+          throw new JestExtendError(message(), actual, expected);
+      }
+      const expectAssertionWrapper = isAsyncFunction(expectAssertion) ? expectAsyncWrapper : expectSyncWrapper;
+      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, expectAssertionWrapper);
+      utils.addMethod(c2.Assertion.prototype, expectAssertionName, expectAssertionWrapper);
+      class CustomMatcher extends AsymmetricMatcher$1 {
+        constructor(inverse = false, ...sample) {
+          super(sample, inverse);
+        }
+        asymmetricMatch(other) {
+          const { pass } = expectAssertion.call(
+            this.getMatcherContext(expect),
+            other,
+            ...this.sample
+          );
+          return this.inverse ? !pass : pass;
+        }
+        toString() {
+          return `${this.inverse ? "not." : ""}${expectAssertionName}`;
+        }
+        getExpectedType() {
+          return "any";
+        }
+        toAsymmetricMatcher() {
+          return `${this.toString()}<${this.sample.map(String).join(", ")}>`;
+        }
+      }
+      Object.defineProperty(expect, expectAssertionName, {
+        configurable: true,
+        enumerable: true,
+        value: (...sample) => new CustomMatcher(false, ...sample),
+        writable: true
+      });
+      Object.defineProperty(expect.not, expectAssertionName, {
+        configurable: true,
+        enumerable: true,
+        value: (...sample) => new CustomMatcher(true, ...sample),
+        writable: true
+      });
+    });
+  };
+}
+const JestExtend = (chai, utils) => {
+  utils.addMethod(chai.expect, "extend", (expect, expects) => {
+    chai.use(JestExtendPlugin(expect, expects));
+  });
+};
+
+var naturalCompare$1 = {exports: {}};
+
+/*
+ * @version    1.4.0
+ * @date       2015-10-26
+ * @stability  3 - Stable
+ * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+ * @license    MIT License
+ */
+
+
+var naturalCompare = function(a, b) {
+	var i, codeA
+	, codeB = 1
+	, posA = 0
+	, posB = 0
+	, alphabet = String.alphabet;
+
+	function getCode(str, pos, code) {
+		if (code) {
+			for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+			return +str.slice(pos - 1, i)
+		}
+		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        // 0-9
+			: code < 65 ? code - 11
+			: code < 91 ? code + 11        // A-Z
+			: code < 97 ? code - 37
+			: code < 123 ? code + 5        // a-z
+			: code - 63
+	}
+
+
+	if ((a+="") != (b+="")) for (;codeB;) {
+		codeA = getCode(a, posA++);
+		codeB = getCode(b, posB++);
+
+		if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+			codeA = getCode(a, posA, posA);
+			codeB = getCode(b, posB, posA = i);
+			posB = i;
+		}
+
+		if (codeA != codeB) return (codeA < codeB) ? -1 : 1
+	}
+	return 0
+};
+
+try {
+	naturalCompare$1.exports = naturalCompare;
+} catch (e) {
+	String.naturalCompare = naturalCompare;
+}
+
+const serialize$1 = (val, config, indentation, depth, refs, printer) => {
+  const name = val.getMockName();
+  const nameString = name === "vi.fn()" ? "" : ` ${name}`;
+  let callsString = "";
+  if (val.mock.calls.length !== 0) {
+    const indentationNext = indentation + config.indent;
+    callsString = ` {${config.spacingOuter}${indentationNext}"calls": ${printer(val.mock.calls, config, indentationNext, depth, refs)}${config.min ? ", " : ","}${config.spacingOuter}${indentationNext}"results": ${printer(val.mock.results, config, indentationNext, depth, refs)}${config.min ? "" : ","}${config.spacingOuter}${indentation}}`;
+  }
+  return `[MockFunction${nameString}]${callsString}`;
+};
+const test$1 = (val) => val && !!val._isMockFunction;
+const plugin = { serialize: serialize$1, test: test$1 };
+
+const {
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent,
+  AsymmetricMatcher
+} = plugins_1;
+let PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher,
+  plugin
+];
+const addSerializer = (plugin) => {
+  PLUGINS = [plugin].concat(PLUGINS);
+};
+const getSerializers = () => PLUGINS;
+
+const SNAPSHOT_VERSION = "1";
+const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}`;
+const testNameToKey = (testName, count) => `${testName} ${count}`;
+const keyToTestName = (key) => {
+  if (!/ \d+$/.test(key))
+    throw new Error("Snapshot keys must end with a number.");
+  return key.replace(/ \d+$/, "");
+};
+const getSnapshotData = (snapshotPath, update) => {
+  const data = /* @__PURE__ */ Object.create(null);
+  let snapshotContents = "";
+  let dirty = false;
+  if (fs.existsSync(snapshotPath)) {
+    try {
+      snapshotContents = fs.readFileSync(snapshotPath, "utf8");
+      const populate = new Function("exports", snapshotContents);
+      populate(data);
+    } catch {
+    }
+  }
+  const isInvalid = snapshotContents;
+  if ((update === "all" || update === "new") && isInvalid)
+    dirty = true;
+  return { data, dirty };
+};
+const addExtraLineBreaks = (string) => string.includes("\n") ? `
+${string}
+` : string;
+const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
+const escapeRegex = true;
+const printFunctionName = false;
+function serialize(val, indent = 2, formatOverrides = {}) {
+  return normalizeNewlines(
+    format_1(val, {
+      escapeRegex,
+      indent,
+      plugins: getSerializers(),
+      printFunctionName,
+      ...formatOverrides
+    })
+  );
+}
+function escapeBacktickString(str) {
+  return str.replace(/`|\\|\${/g, "\\$&");
+}
+function printBacktickString(str) {
+  return `\`${escapeBacktickString(str)}\``;
+}
+function ensureDirectoryExists(filePath) {
+  try {
+    fs.mkdirSync(join(dirname(filePath)), { recursive: true });
+  } catch {
+  }
+}
+function normalizeNewlines(string) {
+  return string.replace(/\r\n|\r/g, "\n");
+}
+async function saveSnapshotFile(snapshotData, snapshotPath) {
+  var _a, _b;
+  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map(
+    (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`
+  );
+  const content = `${writeSnapshotVersion()}
+
+${snapshots.join("\n\n")}
+`;
+  const skipWriting = fs.existsSync(snapshotPath) && await ((_a = fs) == null ? void 0 : _a.promises.readFile(snapshotPath, "utf8")) === content;
+  if (skipWriting)
+    return;
+  ensureDirectoryExists(snapshotPath);
+  await ((_b = fs) == null ? void 0 : _b.promises.writeFile(
+    snapshotPath,
+    content,
+    "utf-8"
+  ));
+}
+function prepareExpected(expected) {
+  function findStartIndent() {
+    var _a, _b;
+    const matchObject = /^( +)}\s+$/m.exec(expected || "");
+    const objectIndent = (_a = matchObject == null ? void 0 : matchObject[1]) == null ? void 0 : _a.length;
+    if (objectIndent)
+      return objectIndent;
+    const matchText = /^\n( +)"/.exec(expected || "");
+    return ((_b = matchText == null ? void 0 : matchText[1]) == null ? void 0 : _b.length) || 0;
+  }
+  const startIndent = findStartIndent();
+  let expectedTrimmed = expected == null ? void 0 : expected.trim();
+  if (startIndent) {
+    expectedTrimmed = expectedTrimmed == null ? void 0 : expectedTrimmed.replace(new RegExp(`^${" ".repeat(startIndent)}`, "gm"), "").replace(/ +}$/, "}");
+  }
+  return expectedTrimmed;
+}
+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$1(targetElement)) {
+      mergedOutput[index] = deepMergeSnapshot(target[index], sourceElement);
+    } else {
+      mergedOutput[index] = sourceElement;
+    }
+  });
+  return mergedOutput;
+}
+function deepMergeSnapshot(target, source) {
+  if (isObject$1(target) && isObject$1(source)) {
+    const mergedOutput = { ...target };
+    Object.keys(source).forEach((key) => {
+      if (isObject$1(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 proxy;
-  });
-  utils.addMethod(
-    chai.expect,
-    "addSnapshotSerializer",
-    addSerializer
-  );
-};
-function toString(value) {
-  try {
-    return `${value}`;
-  } catch (_error) {
-    return "unknown";
+    return mergedOutput;
+  } else if (Array.isArray(target) && Array.isArray(source)) {
+    return deepMergeArray(target, source);
   }
+  return target;
 }
 
-class AsymmetricMatcher {
-  constructor(sample, inverse = false) {
-    this.sample = sample;
-    this.inverse = inverse;
-    this.$$typeof = Symbol.for("jest.asymmetricMatcher");
-  }
-  getMatcherContext(expect) {
-    return {
-      ...getState(expect || globalThis[GLOBAL_EXPECT]),
-      equals,
-      isNot: this.inverse,
-      utils: matcherUtils
-    };
+async function saveInlineSnapshots(snapshots) {
+  const MagicString = (await import('./chunk-magic-string.3a794426.js')).default;
+  const files = new Set(snapshots.map((i) => i.file));
+  await Promise.all(Array.from(files).map(async (file) => {
+    const snaps = snapshots.filter((i) => i.file === file);
+    const code = await promises.readFile(file, "utf8");
+    const s = new MagicString(code);
+    for (const snap of snaps) {
+      const index = positionToOffset(code, snap.line, snap.column);
+      replaceInlineSnap(code, s, index, snap.snapshot);
+    }
+    const transformed = s.toString();
+    if (transformed !== code)
+      await promises.writeFile(file, transformed, "utf-8");
+  }));
+}
+const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\S\s]*\*\/\s*|\/\/.*\s+)*\s*({)/m;
+function replaceObjectSnap(code, s, index, newSnap) {
+  code = code.slice(index);
+  const startMatch = startObjectRegex.exec(code);
+  if (!startMatch)
+    return false;
+  code = code.slice(startMatch.index);
+  const charIndex = getCallLastIndex(code);
+  if (charIndex === null)
+    return false;
+  s.appendLeft(index + startMatch.index + charIndex, `, ${prepareSnapString(newSnap, code, index)}`);
+  return true;
+}
+function prepareSnapString(snap, source, index) {
+  const lineNumber = offsetToLineNumber(source, index);
+  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 = isOneline ? "'" : "`";
+  if (isOneline)
+    return `'${lines.join("\n").replace(/'/g, "\\'")}'`;
+  else
+    return `${quote}
+${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\${/g, "\\${")}
+${indent}${quote}`;
+}
+const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\S\s]*\*\/\s*|\/\/.*\s+)*\s*[\w_$]*(['"`\)])/m;
+function replaceInlineSnap(code, s, index, newSnap) {
+  const startMatch = startRegex.exec(code.slice(index));
+  if (!startMatch)
+    return replaceObjectSnap(code, s, index, newSnap);
+  const quote = startMatch[1];
+  const startIndex = index + startMatch.index + startMatch[0].length;
+  const snapString = prepareSnapString(newSnap, code, index);
+  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;
 }
-class StringContaining extends AsymmetricMatcher {
-  constructor(sample, inverse = false) {
-    if (!isA("String", sample))
-      throw new Error("Expected is not a string");
-    super(sample, inverse);
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+  const match = inlineSnapshot.match(INDENTATION_REGEX);
+  if (!match || !match[1]) {
+    return inlineSnapshot;
   }
-  asymmetricMatch(other) {
-    const result = isA("String", other) && other.includes(this.sample);
-    return this.inverse ? !result : result;
+  const indentation = match[1];
+  const lines = inlineSnapshot.split(/\n/g);
+  if (lines.length <= 2) {
+    return inlineSnapshot;
   }
-  toString() {
-    return `String${this.inverse ? "Not" : ""}Containing`;
+  if (lines[0].trim() !== "" || lines[lines.length - 1].trim() !== "") {
+    return inlineSnapshot;
   }
-  getExpectedType() {
-    return "string";
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (lines[i] !== "") {
+      if (lines[i].indexOf(indentation) !== 0) {
+        return inlineSnapshot;
+      }
+      lines[i] = lines[i].substring(indentation.length);
+    }
   }
+  lines[lines.length - 1] = "";
+  inlineSnapshot = lines.join("\n");
+  return inlineSnapshot;
 }
-class Anything extends AsymmetricMatcher {
-  asymmetricMatch(other) {
-    return other != null;
+
+class SnapshotState {
+  constructor(testFilePath, snapshotPath, options) {
+    this.testFilePath = testFilePath;
+    this.snapshotPath = snapshotPath;
+    const { data, dirty } = getSnapshotData(
+      this.snapshotPath,
+      options.updateSnapshot
+    );
+    this._initialData = data;
+    this._snapshotData = data;
+    this._dirty = dirty;
+    this._inlineSnapshots = [];
+    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
+    this._counters = /* @__PURE__ */ new Map();
+    this.expand = options.expand || false;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this._updateSnapshot = options.updateSnapshot;
+    this.updated = 0;
+    this._snapshotFormat = {
+      printBasicPrototype: false,
+      ...options.snapshotFormat
+    };
   }
-  toString() {
-    return "Anything";
+  markSnapshotsAsCheckedForTest(testName) {
+    this._uncheckedKeys.forEach((uncheckedKey) => {
+      if (keyToTestName(uncheckedKey) === testName)
+        this._uncheckedKeys.delete(uncheckedKey);
+    });
   }
-  toAsymmetricMatcher() {
-    return "Anything";
+  _inferInlineSnapshotStack(stacks) {
+    const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
+    if (promiseIndex !== -1)
+      return stacks[promiseIndex + 3];
+    const stackIndex = stacks.findIndex((i) => i.method.includes("__VITEST_INLINE_SNAPSHOT__"));
+    return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
+  }
+  _addSnapshot(key, receivedSerialized, options) {
+    this._dirty = true;
+    if (options.isInline) {
+      const error = options.error || new Error("Unknown error");
+      const stacks = parseStacktrace(error, true);
+      stacks.forEach((i) => i.file = slash(i.file));
+      const stack = this._inferInlineSnapshotStack(stacks);
+      if (!stack) {
+        throw new Error(
+          `Vitest: Couldn't infer stack frame for inline snapshot.
+${JSON.stringify(stacks)}`
+        );
+      }
+      stack.column--;
+      this._inlineSnapshots.push({
+        snapshot: receivedSerialized,
+        ...stack
+      });
+    } else {
+      this._snapshotData[key] = receivedSerialized;
+    }
+  }
+  clear() {
+    this._snapshotData = this._initialData;
+    this._counters = /* @__PURE__ */ new Map();
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this.updated = 0;
+    this._dirty = false;
+  }
+  async save() {
+    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
+    const hasInlineSnapshots = this._inlineSnapshots.length;
+    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
+    const status = {
+      deleted: false,
+      saved: false
+    };
+    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
+      if (hasExternalSnapshots)
+        await saveSnapshotFile(this._snapshotData, this.snapshotPath);
+      if (hasInlineSnapshots)
+        await saveInlineSnapshots(this._inlineSnapshots);
+      status.saved = true;
+    } else if (!hasExternalSnapshots && fs.existsSync(this.snapshotPath)) {
+      if (this._updateSnapshot === "all")
+        fs.unlinkSync(this.snapshotPath);
+      status.deleted = true;
+    }
+    return status;
   }
-}
-class ObjectContaining extends AsymmetricMatcher {
-  constructor(sample, inverse = false) {
-    super(sample, inverse);
+  getUncheckedCount() {
+    return this._uncheckedKeys.size || 0;
   }
-  getPrototype(obj) {
-    if (Object.getPrototypeOf)
-      return Object.getPrototypeOf(obj);
-    if (obj.constructor.prototype === obj)
-      return null;
-    return obj.constructor.prototype;
+  getUncheckedKeys() {
+    return Array.from(this._uncheckedKeys);
   }
-  hasProperty(obj, property) {
-    if (!obj)
-      return false;
-    if (Object.prototype.hasOwnProperty.call(obj, property))
-      return true;
-    return this.hasProperty(this.getPrototype(obj), property);
+  removeUncheckedKeys() {
+    if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
+      this._dirty = true;
+      this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
+      this._uncheckedKeys.clear();
+    }
   }
-  asymmetricMatch(other) {
-    if (typeof this.sample !== "object") {
-      throw new TypeError(
-        `You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`
-      );
+  match({
+    testName,
+    received,
+    key,
+    inlineSnapshot,
+    isInline,
+    error
+  }) {
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+    const count = Number(this._counters.get(testName));
+    if (!key)
+      key = testNameToKey(testName, count);
+    if (!(isInline && this._snapshotData[key] !== void 0))
+      this._uncheckedKeys.delete(key);
+    const receivedSerialized = addExtraLineBreaks(serialize(received, void 0, this._snapshotFormat));
+    const expected = isInline ? inlineSnapshot : this._snapshotData[key];
+    const expectedTrimmed = prepareExpected(expected);
+    const pass = expectedTrimmed === prepareExpected(receivedSerialized);
+    const hasSnapshot = expected !== void 0;
+    const snapshotIsPersisted = isInline || fs.existsSync(this.snapshotPath);
+    if (pass && !isInline) {
+      this._snapshotData[key] = receivedSerialized;
     }
-    let result = true;
-    for (const property in this.sample) {
-      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property])) {
-        result = false;
-        break;
+    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+      if (this._updateSnapshot === "all") {
+        if (!pass) {
+          if (hasSnapshot)
+            this.updated++;
+          else
+            this.added++;
+          this._addSnapshot(key, receivedSerialized, { error, isInline });
+        } else {
+          this.matched++;
+        }
+      } else {
+        this._addSnapshot(key, receivedSerialized, { error, isInline });
+        this.added++;
+      }
+      return {
+        actual: "",
+        count,
+        expected: "",
+        key,
+        pass: true
+      };
+    } else {
+      if (!pass) {
+        this.unmatched++;
+        return {
+          actual: removeExtraLineBreaks(receivedSerialized),
+          count,
+          expected: expectedTrimmed !== void 0 ? removeExtraLineBreaks(expectedTrimmed) : void 0,
+          key,
+          pass: false
+        };
+      } else {
+        this.matched++;
+        return {
+          actual: "",
+          count,
+          expected: "",
+          key,
+          pass: true
+        };
       }
     }
-    return this.inverse ? !result : result;
-  }
-  toString() {
-    return `Object${this.inverse ? "Not" : ""}Containing`;
   }
-  getExpectedType() {
-    return "object";
+  async pack() {
+    const snapshot = {
+      filepath: this.testFilePath,
+      added: 0,
+      fileDeleted: false,
+      matched: 0,
+      unchecked: 0,
+      uncheckedKeys: [],
+      unmatched: 0,
+      updated: 0
+    };
+    const uncheckedCount = this.getUncheckedCount();
+    const uncheckedKeys = this.getUncheckedKeys();
+    if (uncheckedCount)
+      this.removeUncheckedKeys();
+    const status = await this.save();
+    snapshot.fileDeleted = status.deleted;
+    snapshot.added = this.added;
+    snapshot.matched = this.matched;
+    snapshot.unmatched = this.unmatched;
+    snapshot.updated = this.updated;
+    snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+    snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+    return snapshot;
   }
 }
-class ArrayContaining extends AsymmetricMatcher {
-  constructor(sample, inverse = false) {
-    super(sample, inverse);
-  }
-  asymmetricMatch(other) {
-    if (!Array.isArray(this.sample)) {
-      throw new TypeError(
-        `You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`
-      );
-    }
-    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every(
-      (item) => other.some((another) => equals(item, another))
-    );
-    return this.inverse ? !result : result;
-  }
-  toString() {
-    return `Array${this.inverse ? "Not" : ""}Containing`;
-  }
-  getExpectedType() {
-    return "array";
+
+class SnapshotClient {
+  constructor() {
+    this.snapshotStateMap = /* @__PURE__ */ new Map();
   }
-}
-class Any extends AsymmetricMatcher {
-  constructor(sample) {
-    if (typeof sample === "undefined") {
-      throw new TypeError(
-        "any() expects to be passed a constructor function. Please pass one or use anything() to match any object."
-      );
+  async setTest(test) {
+    var _a;
+    this.test = test;
+    if (((_a = this.snapshotState) == null ? void 0 : _a.testFilePath) !== this.test.file.filepath) {
+      this.saveCurrent();
+      const filePath = this.test.file.filepath;
+      if (!this.getSnapshotState(test)) {
+        this.snapshotStateMap.set(
+          filePath,
+          new SnapshotState(
+            filePath,
+            await rpc().resolveSnapshotPath(filePath),
+            getWorkerState().config.snapshotOptions
+          )
+        );
+      }
+      this.snapshotState = this.getSnapshotState(test);
     }
-    super(sample);
   }
-  fnNameFor(func) {
-    if (func.name)
-      return func.name;
-    const functionToString = Function.prototype.toString;
-    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
-    return matches ? matches[1] : "<anonymous>";
+  getSnapshotState(test) {
+    return this.snapshotStateMap.get(test.file.filepath);
   }
-  asymmetricMatch(other) {
-    if (this.sample === String)
-      return typeof other == "string" || other instanceof String;
-    if (this.sample === Number)
-      return typeof other == "number" || other instanceof Number;
-    if (this.sample === Function)
-      return typeof other == "function" || other instanceof Function;
-    if (this.sample === Boolean)
-      return typeof other == "boolean" || other instanceof Boolean;
-    if (this.sample === BigInt)
-      return typeof other == "bigint" || other instanceof BigInt;
-    if (this.sample === Symbol)
-      return typeof other == "symbol" || other instanceof Symbol;
-    if (this.sample === Object)
-      return typeof other == "object";
-    return other instanceof this.sample;
+  clearTest() {
+    this.test = void 0;
   }
-  toString() {
-    return "Any";
+  skipTestSnapshots(test) {
+    var _a;
+    (_a = this.snapshotState) == null ? void 0 : _a.markSnapshotsAsCheckedForTest(test.name);
   }
-  getExpectedType() {
-    if (this.sample === String)
-      return "string";
-    if (this.sample === Number)
-      return "number";
-    if (this.sample === Function)
-      return "function";
-    if (this.sample === Object)
-      return "object";
-    if (this.sample === Boolean)
-      return "boolean";
-    return this.fnNameFor(this.sample);
+  assert(options) {
+    const {
+      test = this.test,
+      message,
+      isInline = false,
+      properties,
+      inlineSnapshot,
+      error,
+      errorMessage
+    } = options;
+    let { received } = options;
+    if (!test)
+      throw new Error("Snapshot cannot be used outside of test");
+    if (typeof properties === "object") {
+      if (typeof received !== "object" || !received)
+        throw new Error("Received value must be an object when the matcher has properties");
+      try {
+        const pass2 = equals(received, properties, [iterableEquality, subsetEquality]);
+        if (!pass2)
+          expect(received).equals(properties);
+        else
+          received = deepMergeSnapshot(received, properties);
+      } catch (err) {
+        err.message = errorMessage || "Snapshot mismatched";
+        throw err;
+      }
+    }
+    const testName = [
+      ...getNames(test).slice(1),
+      ...message ? [message] : []
+    ].join(" > ");
+    const snapshotState = this.getSnapshotState(test);
+    const { actual, expected, key, pass } = snapshotState.match({
+      testName,
+      received,
+      isInline,
+      error,
+      inlineSnapshot
+    });
+    if (!pass) {
+      try {
+        expect(actual.trim()).equals(expected ? expected.trim() : "");
+      } catch (error2) {
+        error2.message = errorMessage || `Snapshot \`${key || "unknown"}\` mismatched`;
+        throw error2;
+      }
+    }
   }
-  toAsymmetricMatcher() {
-    return `Any<${this.fnNameFor(this.sample)}>`;
+  async saveCurrent() {
+    if (!this.snapshotState)
+      return;
+    const result = await this.snapshotState.pack();
+    await rpc().snapshotSaved(result);
+    this.snapshotState = void 0;
   }
-}
-class StringMatching extends AsymmetricMatcher {
-  constructor(sample, inverse = false) {
-    if (!isA("String", sample) && !isA("RegExp", sample))
-      throw new Error("Expected is not a String or a RegExp");
-    super(new RegExp(sample), inverse);
+  clear() {
+    this.snapshotStateMap.clear();
   }
-  asymmetricMatch(other) {
-    const result = isA("String", other) && this.sample.test(other);
-    return this.inverse ? !result : result;
+}
+
+let _client;
+function getSnapshotClient() {
+  if (!_client)
+    _client = new SnapshotClient();
+  return _client;
+}
+const getErrorMessage = (err) => {
+  if (err instanceof Error)
+    return err.message;
+  return err;
+};
+const getErrorString = (expected, promise) => {
+  if (typeof expected !== "function") {
+    if (!promise)
+      throw new Error(`expected must be a function, received ${typeof expected}`);
+    return getErrorMessage(expected);
   }
-  toString() {
-    return `String${this.inverse ? "Not" : ""}Matching`;
+  try {
+    expected();
+  } catch (e) {
+    return getErrorMessage(e);
   }
-  getExpectedType() {
-    return "string";
+  throw new Error("snapshot function didn't throw");
+};
+const SnapshotPlugin = (chai, utils) => {
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+    utils.addMethod(
+      chai.Assertion.prototype,
+      key,
+      function(properties, message) {
+        const expected = utils.flag(this, "object");
+        const test = utils.flag(this, "vitest-test");
+        if (typeof properties === "string" && typeof message === "undefined") {
+          message = properties;
+          properties = void 0;
+        }
+        const errorMessage = utils.flag(this, "message");
+        getSnapshotClient().assert({
+          received: expected,
+          test,
+          message,
+          isInline: false,
+          properties,
+          errorMessage
+        });
+      }
+    );
   }
-}
-const JestAsymmetricMatchers = (chai, utils) => {
-  utils.addMethod(
-    chai.expect,
-    "anything",
-    () => new Anything()
-  );
-  utils.addMethod(
-    chai.expect,
-    "any",
-    (expected) => new Any(expected)
-  );
   utils.addMethod(
-    chai.expect,
-    "stringContaining",
-    (expected) => new StringContaining(expected)
+    chai.Assertion.prototype,
+    "toMatchInlineSnapshot",
+    function __VITEST_INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+      const expected = utils.flag(this, "object");
+      const error = utils.flag(this, "error");
+      const test = utils.flag(this, "vitest-test");
+      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,
+        test,
+        message,
+        isInline: true,
+        properties,
+        inlineSnapshot,
+        error,
+        errorMessage
+      });
+    }
   );
   utils.addMethod(
-    chai.expect,
-    "objectContaining",
-    (expected) => new ObjectContaining(expected)
+    chai.Assertion.prototype,
+    "toThrowErrorMatchingSnapshot",
+    function(message) {
+      const expected = utils.flag(this, "object");
+      const test = utils.flag(this, "vitest-test");
+      const promise = utils.flag(this, "promise");
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: getErrorString(expected, promise),
+        test,
+        message,
+        errorMessage
+      });
+    }
   );
   utils.addMethod(
-    chai.expect,
-    "arrayContaining",
-    (expected) => new ArrayContaining(expected)
+    chai.Assertion.prototype,
+    "toThrowErrorMatchingInlineSnapshot",
+    function __VITEST_INLINE_SNAPSHOT__(inlineSnapshot, message) {
+      const expected = utils.flag(this, "object");
+      const error = utils.flag(this, "error");
+      const test = utils.flag(this, "vitest-test");
+      const promise = utils.flag(this, "promise");
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: getErrorString(expected, promise),
+        test,
+        message,
+        inlineSnapshot,
+        isInline: true,
+        error,
+        errorMessage
+      });
+    }
   );
   utils.addMethod(
     chai.expect,
-    "stringMatching",
-    (expected) => new StringMatching(expected)
+    "addSnapshotSerializer",
+    addSerializer
   );
-  chai.expect.not = {
-    stringContaining: (expected) => new StringContaining(expected, true),
-    objectContaining: (expected) => new ObjectContaining(expected, true),
-    arrayContaining: (expected) => new ArrayContaining(expected, true),
-    stringMatching: (expected) => new StringMatching(expected, true)
-  };
 };
 
-const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTag] === "AsyncFunction";
-const getMatcherState = (assertion, expect) => {
-  const obj = assertion._obj;
-  const isNot = util.flag(assertion, "negate");
-  const promise = util.flag(assertion, "promise") || "";
-  const jestUtils = {
-    ...matcherUtils,
-    iterableEquality,
-    subsetEquality
-  };
-  const matcherState = {
-    ...getState(expect),
-    isNot,
-    utils: jestUtils,
-    promise,
-    equals,
-    suppressedErrors: [],
-    snapshotState: getSnapshotClient().snapshotState
-  };
-  return {
-    state: matcherState,
-    isNot,
-    obj
-  };
-};
-class JestExtendError extends Error {
-  constructor(message, actual, expected) {
-    super(message);
-    this.actual = actual;
-    this.expected = expected;
-  }
-}
-function JestExtendPlugin(expect, matchers) {
-  return (c, utils) => {
-    Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
-      function expectSyncWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this, expect);
-        const { pass, message, actual, expected } = expectAssertion.call(state, obj, ...args);
-        if (pass && isNot || !pass && !isNot)
-          throw new JestExtendError(message(), actual, expected);
-      }
-      async function expectAsyncWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this, expect);
-        const { pass, message, actual, expected } = await expectAssertion.call(state, obj, ...args);
-        if (pass && isNot || !pass && !isNot)
-          throw new JestExtendError(message(), actual, expected);
-      }
-      const expectAssertionWrapper = isAsyncFunction(expectAssertion) ? expectAsyncWrapper : expectSyncWrapper;
-      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, expectAssertionWrapper);
-      utils.addMethod(c.Assertion.prototype, expectAssertionName, expectAssertionWrapper);
-      class CustomMatcher extends AsymmetricMatcher {
-        constructor(inverse = false, ...sample) {
-          super(sample, inverse);
-        }
-        asymmetricMatch(other) {
-          const { pass } = expectAssertion.call(
-            this.getMatcherContext(expect),
-            other,
-            ...this.sample
-          );
-          return this.inverse ? !pass : pass;
-        }
-        toString() {
-          return `${this.inverse ? "not." : ""}${expectAssertionName}`;
-        }
-        getExpectedType() {
-          return "any";
-        }
-        toAsymmetricMatcher() {
-          return `${this.toString()}<${this.sample.map(String).join(", ")}>`;
-        }
-      }
-      Object.defineProperty(expect, expectAssertionName, {
-        configurable: true,
-        enumerable: true,
-        value: (...sample) => new CustomMatcher(false, ...sample),
-        writable: true
-      });
-      Object.defineProperty(expect.not, expectAssertionName, {
-        configurable: true,
-        enumerable: true,
-        value: (...sample) => new CustomMatcher(true, ...sample),
-        writable: true
-      });
-    });
-  };
-}
-const JestExtend = (chai, utils) => {
-  utils.addMethod(chai.expect, "extend", (expect, expects) => {
-    chai.use(JestExtendPlugin(expect, expects));
-  });
-};
+var chai$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getSnapshotClient: getSnapshotClient,
+  SnapshotPlugin: SnapshotPlugin
+});
 
 chai$2.use(JestExtend);
 chai$2.use(JestChaiExpect);
@@ -2092,15 +2254,17 @@ function createExpect(test) {
   Object.assign(expect, chai$2.expect);
   expect.getState = () => getState(expect);
   expect.setState = (state) => setState(state, expect);
+  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
   setState({
+    ...globalState,
     assertionCalls: 0,
     isExpectingAssertions: false,
     isExpectingAssertionsError: null,
     expectedAssertionsNumber: null,
     expectedAssertionsNumberErrorGen: null,
     environment: getCurrentEnvironment(),
-    testPath: (_a = test == null ? void 0 : test.suite.file) == null ? void 0 : _a.filepath,
-    currentTestName: test ? getFullName(test) : void 0
+    testPath: test ? (_a = test.suite.file) == null ? void 0 : _a.filepath : globalState.testPath,
+    currentTestName: test ? getFullName(test) : globalState.currentTestName
   }, expect);
   expect.extend = (matchers) => chai$2.expect.extend(expect, matchers);
   function assertions(expected) {
@@ -2408,7 +2572,7 @@ function formatTitle(template, items, idx) {
   }
   const count = template.split("%").length - 1;
   let formatted = util$1.format(template, ...items.slice(0, count));
-  if (isObject(items[0])) {
+  if (isObject$1(items[0])) {
     formatted = formatted.replace(
       /\$([$\w_.]+)/g,
       (_, key) => util.objDisplay(objectAttr(items[0], key))
@@ -2428,4 +2592,4 @@ function formatTemplateString(cases, args) {
   return res;
 }
 
-export { GLOBAL_EXPECT as G, getDefaultHookTimeout as a, bench as b, createExpect as c, describe as d, globalExpect as e, clearCollectorContext as f, getCurrentSuite as g, defaultSuite as h, it as i, setHooks as j, getHooks as k, collectorContext as l, getBenchOptions as m, getFn as n, setState as o, getState as p, createSuiteHooks as q, chai$1 as r, suite as s, test as t, withTimeout as w };
+export { GLOBAL_EXPECT as G, getDefaultHookTimeout as a, bench as b, createExpect as c, describe as d, globalExpect as e, clearCollectorContext as f, getCurrentSuite as g, defaultSuite as h, it as i, setHooks as j, getHooks as k, collectorContext as l, getBenchOptions as m, getFn as n, setState as o, getSnapshotClient as p, getState as q, createSuiteHooks as r, suite as s, test as t, chai$1 as u, withTimeout as w };