@vitest/snapshot 3.1.0-beta.1 → 3.1.0

package/dist/index.js

@@ -577,221 +577,238 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     return index;
 }
 
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
 function notNullish(v) {
-  return v != null;
+	return v != null;
 }
 function isPrimitive(value) {
-  return value === null || typeof value !== "function" && typeof value !== "object";
+	return value === null || typeof value !== "function" && typeof value !== "object";
 }
 function isObject(item) {
-  return item != null && typeof item === "object" && !Array.isArray(item);
+	return item != null && typeof item === "object" && !Array.isArray(item);
 }
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
 function getCallLastIndex(code) {
-  let charIndex = -1;
-  let inString = null;
-  let startedBracers = 0;
-  let endedBracers = 0;
-  let beforeChar = null;
-  while (charIndex <= code.length) {
-    beforeChar = code[charIndex];
-    charIndex++;
-    const char = code[charIndex];
-    const isCharString = char === '"' || char === "'" || char === "`";
-    if (isCharString && beforeChar !== "\\") {
-      if (inString === char) {
-        inString = null;
-      } else if (!inString) {
-        inString = char;
-      }
-    }
-    if (!inString) {
-      if (char === "(") {
-        startedBracers++;
-      }
-      if (char === ")") {
-        endedBracers++;
-      }
-    }
-    if (startedBracers && endedBracers && startedBracers === endedBracers) {
-      return charIndex;
-    }
-  }
-  return null;
+	let charIndex = -1;
+	let inString = null;
+	let startedBracers = 0;
+	let endedBracers = 0;
+	let beforeChar = null;
+	while (charIndex <= code.length) {
+		beforeChar = code[charIndex];
+		charIndex++;
+		const char = code[charIndex];
+		const isCharString = char === "\"" || char === "'" || char === "`";
+		if (isCharString && beforeChar !== "\\") {
+			if (inString === char) {
+				inString = null;
+			} else if (!inString) {
+				inString = char;
+			}
+		}
+		if (!inString) {
+			if (char === "(") {
+				startedBracers++;
+			}
+			if (char === ")") {
+				endedBracers++;
+			}
+		}
+		if (startedBracers && endedBracers && startedBracers === endedBracers) {
+			return charIndex;
+		}
+	}
+	return null;
 }
 
 const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
 const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
 const stackIgnorePatterns = [
-  "node:internal",
-  /\/packages\/\w+\/dist\//,
-  /\/@vitest\/\w+\/dist\//,
-  "/vitest/dist/",
-  "/vitest/src/",
-  "/vite-node/dist/",
-  "/vite-node/src/",
-  "/node_modules/chai/",
-  "/node_modules/tinypool/",
-  "/node_modules/tinyspy/",
-  // browser related deps
-  "/deps/chunk-",
-  "/deps/@vitest",
-  "/deps/loupe",
-  "/deps/chai",
-  /node:\w+/,
-  /__vitest_test__/,
-  /__vitest_browser__/,
-  /\/deps\/vitest_/
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/vite-node/dist/",
+	"/vite-node/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinypool/",
+	"/node_modules/tinyspy/",
+	"/deps/chunk-",
+	"/deps/@vitest",
+	"/deps/loupe",
+	"/deps/chai",
+	/node:\w+/,
+	/__vitest_test__/,
+	/__vitest_browser__/,
+	/\/deps\/vitest_/
 ];
 function extractLocation(urlLike) {
-  if (!urlLike.includes(":")) {
-    return [urlLike];
-  }
-  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
-  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
-  if (!parts) {
-    return [urlLike];
-  }
-  let url = parts[1];
-  if (url.startsWith("async ")) {
-    url = url.slice(6);
-  }
-  if (url.startsWith("http:") || url.startsWith("https:")) {
-    const urlObj = new URL(url);
-    urlObj.searchParams.delete("import");
-    urlObj.searchParams.delete("browserv");
-    url = urlObj.pathname + urlObj.hash + urlObj.search;
-  }
-  if (url.startsWith("/@fs/")) {
-    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
-    url = url.slice(isWindows ? 5 : 4);
-  }
-  return [url, parts[2] || void 0, parts[3] || void 0];
+	if (!urlLike.includes(":")) {
+		return [urlLike];
+	}
+	const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+	const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) {
+		return [urlLike];
+	}
+	let url = parts[1];
+	if (url.startsWith("async ")) {
+		url = url.slice(6);
+	}
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = urlObj.pathname + urlObj.hash + urlObj.search;
+	}
+	if (url.startsWith("/@fs/")) {
+		const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+		url = url.slice(isWindows ? 5 : 4);
+	}
+	return [
+		url,
+		parts[2] || undefined,
+		parts[3] || undefined
+	];
 }
 function parseSingleFFOrSafariStack(raw) {
-  let line = raw.trim();
-  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
-    return null;
-  }
-  if (line.includes(" > eval")) {
-    line = line.replace(
-      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
-      ":$1"
-    );
-  }
-  if (!line.includes("@") && !line.includes(":")) {
-    return null;
-  }
-  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
-  const matches = line.match(functionNameRegex);
-  const functionName = matches && matches[1] ? matches[1] : void 0;
-  const [url, lineNumber, columnNumber] = extractLocation(
-    line.replace(functionNameRegex, "")
-  );
-  if (!url || !lineNumber || !columnNumber) {
-    return null;
-  }
-  return {
-    file: url,
-    method: functionName || "",
-    line: Number.parseInt(lineNumber),
-    column: Number.parseInt(columnNumber)
-  };
+	let line = raw.trim();
+	if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+		return null;
+	}
+	if (line.includes(" > eval")) {
+		line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+	}
+	if (!line.includes("@") && !line.includes(":")) {
+		return null;
+	}
+	const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
+	const matches = line.match(functionNameRegex);
+	const functionName = matches && matches[1] ? matches[1] : undefined;
+	const [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
+	if (!url || !lineNumber || !columnNumber) {
+		return null;
+	}
+	return {
+		file: url,
+		method: functionName || "",
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
 }
 function parseSingleV8Stack(raw) {
-  let line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line)) {
-    return null;
-  }
-  if (line.includes("(eval ")) {
-    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
-  }
-  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-  const location = sanitizedLine.match(/ (\(.+\)$)/);
-  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-  const [url, lineNumber, columnNumber] = extractLocation(
-    location ? location[1] : sanitizedLine
-  );
-  let method = location && sanitizedLine || "";
-  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
-  if (!file || !lineNumber || !columnNumber) {
-    return null;
-  }
-  if (method.startsWith("async ")) {
-    method = method.slice(6);
-  }
-  if (file.startsWith("file://")) {
-    file = file.slice(7);
-  }
-  file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve$2(file);
-  if (method) {
-    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
-  }
-  return {
-    method,
-    file,
-    line: Number.parseInt(lineNumber),
-    column: Number.parseInt(columnNumber)
-  };
+	let line = raw.trim();
+	if (!CHROME_IE_STACK_REGEXP.test(line)) {
+		return null;
+	}
+	if (line.includes("(eval ")) {
+		line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+	}
+	let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+	const location = sanitizedLine.match(/ (\(.+\)$)/);
+	sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+	const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+	let method = location && sanitizedLine || "";
+	let file = url && ["eval", "<anonymous>"].includes(url) ? undefined : url;
+	if (!file || !lineNumber || !columnNumber) {
+		return null;
+	}
+	if (method.startsWith("async ")) {
+		method = method.slice(6);
+	}
+	if (file.startsWith("file://")) {
+		file = file.slice(7);
+	}
+	file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve$2(file);
+	if (method) {
+		method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+	}
+	return {
+		method,
+		file,
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
 }
 function parseStacktrace(stack, options = {}) {
-  const { ignoreStackEntries = stackIgnorePatterns } = options;
-  const stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
-  return stacks.map((stack2) => {
-    var _a;
-    if (options.getUrlId) {
-      stack2.file = options.getUrlId(stack2.file);
-    }
-    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
-    if (!map || typeof map !== "object" || !map.version) {
-      return shouldFilter(ignoreStackEntries, stack2.file) ? null : stack2;
-    }
-    const traceMap = new TraceMap(map);
-    const { line, column, source, name } = originalPositionFor(traceMap, stack2);
-    let file = stack2.file;
-    if (source) {
-      const fileUrl = stack2.file.startsWith("file://") ? stack2.file : `file://${stack2.file}`;
-      const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
-      file = new URL(source, sourceRootUrl).pathname;
-    }
-    if (shouldFilter(ignoreStackEntries, file)) {
-      return null;
-    }
-    if (line != null && column != null) {
-      return {
-        line,
-        column,
-        file,
-        method: name || stack2.method
-      };
-    }
-    return stack2;
-  }).filter((s) => s != null);
+	const { ignoreStackEntries = stackIgnorePatterns } = options;
+	const stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+	return stacks.map((stack) => {
+		var _options$getSourceMap;
+		if (options.getUrlId) {
+			stack.file = options.getUrlId(stack.file);
+		}
+		const map = (_options$getSourceMap = options.getSourceMap) === null || _options$getSourceMap === void 0 ? void 0 : _options$getSourceMap.call(options, stack.file);
+		if (!map || typeof map !== "object" || !map.version) {
+			return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+		}
+		const traceMap = new TraceMap(map);
+		const { line, column, source, name } = originalPositionFor(traceMap, stack);
+		let file = stack.file;
+		if (source) {
+			const fileUrl = stack.file.startsWith("file://") ? stack.file : `file://${stack.file}`;
+			const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
+			file = new URL(source, sourceRootUrl).pathname;
+		}
+		if (shouldFilter(ignoreStackEntries, file)) {
+			return null;
+		}
+		if (line != null && column != null) {
+			return {
+				line,
+				column,
+				file,
+				method: name || stack.method
+			};
+		}
+		return stack;
+	}).filter((s) => s != null);
 }
 function shouldFilter(ignoreStackEntries, file) {
-  return ignoreStackEntries.some((p) => file.match(p));
+	return ignoreStackEntries.some((p) => file.match(p));
 }
 function parseFFOrSafariStackTrace(stack) {
-  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
 }
 function parseV8Stacktrace(stack) {
-  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+	return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
 }
 function parseErrorStacktrace(e, options = {}) {
-  if (!e || isPrimitive(e)) {
-    return [];
-  }
-  if (e.stacks) {
-    return e.stacks;
-  }
-  const stackStr = e.stack || e.stackStr || "";
-  let stackFrames = parseStacktrace(stackStr, options);
-  if (options.frameFilter) {
-    stackFrames = stackFrames.filter(
-      (f) => options.frameFilter(e, f) !== false
-    );
-  }
-  e.stacks = stackFrames;
-  return stackFrames;
+	if (!e || isPrimitive(e)) {
+		return [];
+	}
+	if (e.stacks) {
+		return e.stacks;
+	}
+	const stackStr = e.stack || e.stackStr || "";
+	let stackFrames = parseStacktrace(stackStr, options);
+	if (!stackFrames.length) {
+		const e_ = e;
+		if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) {
+			stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+		}
+		if (e_.sourceURL != null && e_.line != null && e_._column != null) {
+			stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+		}
+	}
+	if (options.frameFilter) {
+		stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+	}
+	e.stacks = stackFrames;
+	return stackFrames;
 }
 
 let getPromiseValue = () => 'Promise{…}';
@@ -828,14 +845,7 @@ catch (noNodeInspect) {
     nodeInspect = false;
 }
 
-const {
-  AsymmetricMatcher: AsymmetricMatcher$1,
-  DOMCollection: DOMCollection$1,
-  DOMElement: DOMElement$1,
-  Immutable: Immutable$1,
-  ReactElement: ReactElement$1,
-  ReactTestComponent: ReactTestComponent$1
-} = plugins;
+const { AsymmetricMatcher: AsymmetricMatcher$1, DOMCollection: DOMCollection$1, DOMElement: DOMElement$1, Immutable: Immutable$1, ReactElement: ReactElement$1, ReactTestComponent: ReactTestComponent$1 } = plugins;
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -1374,190 +1384,180 @@ p();
 
 const lineSplitRE = /\r?\n/;
 function positionToOffset(source, lineNumber, columnNumber) {
-  const lines = source.split(lineSplitRE);
-  const nl = /\r\n/.test(source) ? 2 : 1;
-  let start = 0;
-  if (lineNumber > lines.length) {
-    return source.length;
-  }
-  for (let i = 0; i < lineNumber - 1; i++) {
-    start += lines[i].length + nl;
-  }
-  return start + columnNumber;
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let start = 0;
+	if (lineNumber > lines.length) {
+		return source.length;
+	}
+	for (let i = 0; i < lineNumber - 1; i++) {
+		start += lines[i].length + nl;
+	}
+	return start + columnNumber;
 }
 function offsetToLineNumber(source, offset) {
-  if (offset > source.length) {
-    throw new Error(
-      `offset is longer than source length! offset ${offset} > length ${source.length}`
-    );
-  }
-  const lines = source.split(lineSplitRE);
-  const nl = /\r\n/.test(source) ? 2 : 1;
-  let counted = 0;
-  let line = 0;
-  for (; line < lines.length; line++) {
-    const lineLength = lines[line].length + nl;
-    if (counted + lineLength >= offset) {
-      break;
-    }
-    counted += lineLength;
-  }
-  return line + 1;
+	if (offset > source.length) {
+		throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+	}
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let counted = 0;
+	let line = 0;
+	for (; line < lines.length; line++) {
+		const lineLength = lines[line].length + nl;
+		if (counted + lineLength >= offset) {
+			break;
+		}
+		counted += lineLength;
+	}
+	return line + 1;
 }
 
 async function saveInlineSnapshots(environment, snapshots) {
-  const MagicString = (await import('magic-string')).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 environment.readSnapshotFile(file);
-      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 environment.saveSnapshotFile(file, transformed);
-      }
-    })
-  );
+	const MagicString = (await import('magic-string')).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 environment.readSnapshotFile(file);
+		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 environment.saveSnapshotFile(file, transformed);
+		}
+	}));
 }
 const 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, index, newSnap) {
-  let _code = code.slice(index);
-  const startMatch = startObjectRegex.exec(_code);
-  if (!startMatch) {
-    return false;
-  }
-  _code = _code.slice(startMatch.index);
-  let callEnd = getCallLastIndex(_code);
-  if (callEnd === null) {
-    return false;
-  }
-  callEnd += index + startMatch.index;
-  const shapeStart = index + startMatch.index + startMatch[0].length;
-  const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
-  const snap = `, ${prepareSnapString(newSnap, code, index)}`;
-  if (shapeEnd === callEnd) {
-    s.appendLeft(callEnd, snap);
-  } else {
-    s.overwrite(shapeEnd, callEnd, snap);
-  }
-  return true;
+	let _code = code.slice(index);
+	const startMatch = startObjectRegex.exec(_code);
+	if (!startMatch) {
+		return false;
+	}
+	_code = _code.slice(startMatch.index);
+	let callEnd = getCallLastIndex(_code);
+	if (callEnd === null) {
+		return false;
+	}
+	callEnd += index + startMatch.index;
+	const shapeStart = index + startMatch.index + startMatch[0].length;
+	const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+	const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+	if (shapeEnd === callEnd) {
+		s.appendLeft(callEnd, snap);
+	} else {
+		s.overwrite(shapeEnd, callEnd, snap);
+	}
+	return true;
 }
 function getObjectShapeEndIndex(code, index) {
-  let startBraces = 1;
-  let endBraces = 0;
-  while (startBraces !== endBraces && index < code.length) {
-    const s = code[index++];
-    if (s === "{") {
-      startBraces++;
-    } else if (s === "}") {
-      endBraces++;
-    }
-  }
-  return index;
+	let startBraces = 1;
+	let endBraces = 0;
+	while (startBraces !== endBraces && index < code.length) {
+		const s = code[index++];
+		if (s === "{") {
+			startBraces++;
+		} else if (s === "}") {
+			endBraces++;
+		}
+	}
+	return index;
 }
 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 = "`";
-  if (isOneline) {
-    return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
-  }
-  return `${quote}
-${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
-${indent}${quote}`;
+	const lineNumber = offsetToLineNumber(source, index);
+	const line = source.split(lineSplitRE)[lineNumber - 1];
+	const indent = line.match(/^\s*/)[0] || "";
+	const indentNext = indent.includes("	") ? `${indent}\t` : `${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}\n${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\\${")}\n${indent}${quote}`;
 }
 const toMatchInlineName = "toMatchInlineSnapshot";
 const toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
 function getCodeStartingAtIndex(code, index) {
-  const indexInline = index - toMatchInlineName.length;
-  if (code.slice(indexInline, index) === toMatchInlineName) {
-    return {
-      code: code.slice(indexInline),
-      index: indexInline
-    };
-  }
-  const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
-  if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
-    return {
-      code: code.slice(index - indexThrowInline),
-      index: index - indexThrowInline
-    };
-  }
-  return {
-    code: code.slice(index),
-    index
-  };
+	const indexInline = index - toMatchInlineName.length;
+	if (code.slice(indexInline, index) === toMatchInlineName) {
+		return {
+			code: code.slice(indexInline),
+			index: indexInline
+		};
+	}
+	const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
+	if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
+		return {
+			code: code.slice(index - indexThrowInline),
+			index: index - indexThrowInline
+		};
+	}
+	return {
+		code: code.slice(index),
+		index
+	};
 }
 const 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 } = getCodeStartingAtIndex(code, currentIndex);
-  const startMatch = startRegex.exec(codeStartingAtIndex);
-  const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(
-    codeStartingAtIndex
-  );
-  if (!startMatch || startMatch.index !== (firstKeywordMatch == null ? void 0 : firstKeywordMatch.index)) {
-    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 { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);
+	const startMatch = startRegex.exec(codeStartingAtIndex);
+	const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);
+	if (!startMatch || startMatch.index !== (firstKeywordMatch === null || firstKeywordMatch === void 0 ? void 0 : firstKeywordMatch.index)) {
+		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;
-  }
-  const indentation = match[1];
-  const lines = inlineSnapshot.split(/\n/g);
-  if (lines.length <= 2) {
-    return inlineSnapshot;
-  }
-  if (lines[0].trim() !== "" || lines[lines.length - 1].trim() !== "") {
-    return inlineSnapshot;
-  }
-  for (let i = 1; i < lines.length - 1; i++) {
-    if (lines[i] !== "") {
-      if (lines[i].indexOf(indentation) !== 0) {
-        return inlineSnapshot;
-      }
-      lines[i] = lines[i].substring(indentation.length);
-    }
-  }
-  lines[lines.length - 1] = "";
-  inlineSnapshot = lines.join("\n");
-  return 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[lines.length - 1].trim() !== "") {
+		return inlineSnapshot;
+	}
+	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;
 }
 
 async function saveRawSnapshots(environment, snapshots) {
-  await Promise.all(
-    snapshots.map(async (snap) => {
-      if (!snap.readonly) {
-        await environment.saveSnapshotFile(snap.file, snap.snapshot);
-      }
-    })
-  );
+	await Promise.all(snapshots.map(async (snap) => {
+		if (!snap.readonly) {
+			await environment.saveSnapshotFile(snap.file, snap.snapshot);
+		}
+	}));
 }
 
 var naturalCompare$1 = {exports: {}};
@@ -1628,699 +1628,600 @@ var naturalCompareExports = requireNaturalCompare();
 var naturalCompare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareExports);
 
 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 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 = (val) => val && !!val._isMockFunction;
-const plugin = { serialize: serialize$1, test };
+const plugin = {
+	serialize: serialize$1,
+	test
+};
 
-const {
-  DOMCollection,
-  DOMElement,
-  Immutable,
-  ReactElement,
-  ReactTestComponent,
-  AsymmetricMatcher
-} = plugins;
+const { DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent, AsymmetricMatcher } = plugins;
 let PLUGINS = [
-  ReactTestComponent,
-  ReactElement,
-  DOMElement,
-  DOMCollection,
-  Immutable,
-  AsymmetricMatcher,
-  plugin
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher,
+	plugin
 ];
 function addSerializer(plugin) {
-  PLUGINS = [plugin].concat(PLUGINS);
+	PLUGINS = [plugin].concat(PLUGINS);
 }
 function getSerializers() {
-  return PLUGINS;
+	return PLUGINS;
 }
 
 function testNameToKey(testName, count) {
-  return `${testName} ${count}`;
+	return `${testName} ${count}`;
 }
 function keyToTestName(key) {
-  if (!/ \d+$/.test(key)) {
-    throw new Error("Snapshot keys must end with a number.");
-  }
-  return key.replace(/ \d+$/, "");
+	if (!/ \d+$/.test(key)) {
+		throw new Error("Snapshot keys must end with a number.");
+	}
+	return key.replace(/ \d+$/, "");
 }
 function getSnapshotData(content, options) {
-  const update = options.updateSnapshot;
-  const data = /* @__PURE__ */ Object.create(null);
-  let snapshotContents = "";
-  let dirty = false;
-  if (content != null) {
-    try {
-      snapshotContents = content;
-      const populate = new Function("exports", snapshotContents);
-      populate(data);
-    } catch {
-    }
-  }
-  const isInvalid = snapshotContents;
-  if ((update === "all" || update === "new") && isInvalid) {
-    dirty = true;
-  }
-  return { data, dirty };
+	const update = options.updateSnapshot;
+	const data = Object.create(null);
+	let snapshotContents = "";
+	let dirty = false;
+	if (content != null) {
+		try {
+			snapshotContents = content;
+			const populate = new Function("exports", snapshotContents);
+			populate(data);
+		} catch {}
+	}
+	const isInvalid = snapshotContents;
+	if ((update === "all" || update === "new") && isInvalid) {
+		dirty = true;
+	}
+	return {
+		data,
+		dirty
+	};
 }
 function addExtraLineBreaks(string) {
-  return string.includes("\n") ? `
-${string}
-` : string;
+	return string.includes("\n") ? `\n${string}\n` : string;
 }
 function removeExtraLineBreaks(string) {
-  return string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
+	return 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(val, {
-      escapeRegex,
-      indent,
-      plugins: getSerializers(),
-      printFunctionName,
-      ...formatOverrides
-    })
-  );
+	return normalizeNewlines(format(val, {
+		escapeRegex,
+		indent,
+		plugins: getSerializers(),
+		printFunctionName,
+		...formatOverrides
+	}));
 }
 function escapeBacktickString(str) {
-  return str.replace(/`|\\|\$\{/g, "\\$&");
+	return str.replace(/`|\\|\$\{/g, "\\$&");
 }
 function printBacktickString(str) {
-  return `\`${escapeBacktickString(str)}\``;
+	return `\`${escapeBacktickString(str)}\``;
 }
 function normalizeNewlines(string) {
-  return string.replace(/\r\n|\r/g, "\n");
+	return string.replace(/\r\n|\r/g, "\n");
 }
 async function saveSnapshotFile(environment, snapshotData, snapshotPath) {
-  const snapshots = Object.keys(snapshotData).sort(naturalCompare).map(
-    (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(
-      normalizeNewlines(snapshotData[key])
-    )};`
-  );
-  const content = `${environment.getHeader()}
-
-${snapshots.join("\n\n")}
-`;
-  const oldContent = await environment.readSnapshotFile(snapshotPath);
-  const skipWriting = oldContent != null && oldContent === content;
-  if (skipWriting) {
-    return;
-  }
-  await environment.saveSnapshotFile(snapshotPath, content);
-}
-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;
+	const snapshots = Object.keys(snapshotData).sort(naturalCompare).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
+	const content = `${environment.getHeader()}\n\n${snapshots.join("\n\n")}\n`;
+	const oldContent = await environment.readSnapshotFile(snapshotPath);
+	const skipWriting = oldContent != null && oldContent === content;
+	if (skipWriting) {
+		return;
+	}
+	await environment.saveSnapshotFile(snapshotPath, content);
 }
 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;
+	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;
 }
+/**
+* Deep merge, but considers asymmetric matchers. Unlike base util's deep merge,
+* will merge any object-like instance.
+* Compatible with Jest's snapshot matcher. Should not be used outside of snapshot.
+*
+* @example
+* ```ts
+* toMatchSnapshot({
+*   name: expect.stringContaining('text')
+* })
+* ```
+*/
 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;
+	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;
 }
 class DefaultMap extends Map {
-  constructor(defaultFn, entries) {
-    super(entries);
-    this.defaultFn = defaultFn;
-  }
-  get(key) {
-    if (!this.has(key)) {
-      this.set(key, this.defaultFn(key));
-    }
-    return super.get(key);
-  }
+	constructor(defaultFn, entries) {
+		super(entries);
+		this.defaultFn = defaultFn;
+	}
+	get(key) {
+		if (!this.has(key)) {
+			this.set(key, this.defaultFn(key));
+		}
+		return super.get(key);
+	}
 }
 class CounterMap extends DefaultMap {
-  constructor() {
-    super(() => 0);
-  }
-  // compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322
-  // `valueOf` and `Snapshot.added` setter allows
-  //   snapshotState.added = snapshotState.added + 1
-  // to function as
-  //   snapshotState.added.total_ = snapshotState.added.total() + 1
-  _total;
-  valueOf() {
-    return this._total = this.total();
-  }
-  increment(key) {
-    if (typeof this._total !== "undefined") {
-      this._total++;
-    }
-    this.set(key, this.get(key) + 1);
-  }
-  total() {
-    if (typeof this._total !== "undefined") {
-      return this._total;
-    }
-    let total = 0;
-    for (const x of this.values()) {
-      total += x;
-    }
-    return total;
-  }
+	constructor() {
+		super(() => 0);
+	}
+	_total;
+	valueOf() {
+		return this._total = this.total();
+	}
+	increment(key) {
+		if (typeof this._total !== "undefined") {
+			this._total++;
+		}
+		this.set(key, this.get(key) + 1);
+	}
+	total() {
+		if (typeof this._total !== "undefined") {
+			return this._total;
+		}
+		let total = 0;
+		for (const x of this.values()) {
+			total += x;
+		}
+		return total;
+	}
 }
 
 function isSameStackPosition(x, y) {
-  return x.file === y.file && x.column === y.column && x.line === y.line;
+	return x.file === y.file && x.column === y.column && x.line === y.line;
 }
 class SnapshotState {
-  constructor(testFilePath, snapshotPath, snapshotContent, options) {
-    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;
-  }
-  _counters = new CounterMap();
-  _dirty;
-  _updateSnapshot;
-  _snapshotData;
-  _initialData;
-  _inlineSnapshots;
-  _inlineSnapshotStacks;
-  _testIdToKeys = new DefaultMap(() => []);
-  _rawSnapshots;
-  _uncheckedKeys;
-  _snapshotFormat;
-  _environment;
-  _fileExists;
-  expand;
-  // getter/setter for jest-image-snapshot compat
-  // https://github.com/vitest-dev/vitest/issues/7322
-  _added = new CounterMap();
-  _matched = new CounterMap();
-  _unmatched = new CounterMap();
-  _updated = new CounterMap();
-  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) {
-    this._unmatched._total = value;
-  }
-  get updated() {
-    return this._updated;
-  }
-  set updated(value) {
-    this._updated._total = value;
-  }
-  static async create(testFilePath, options) {
-    const snapshotPath = await options.snapshotEnvironment.resolvePath(
-      testFilePath
-    );
-    const content = await options.snapshotEnvironment.readSnapshotFile(
-      snapshotPath
-    );
-    return new SnapshotState(testFilePath, snapshotPath, content, options);
-  }
-  get environment() {
-    return this._environment;
-  }
-  markSnapshotsAsCheckedForTest(testName) {
-    this._uncheckedKeys.forEach((uncheckedKey) => {
-      if (/ \d+$| > /.test(uncheckedKey.slice(testName.length))) {
-        this._uncheckedKeys.delete(uncheckedKey);
-      }
-    });
-  }
-  clearTest(testId) {
-    this._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);
-    this._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);
-    for (const key of this._testIdToKeys.get(testId)) {
-      const name = keyToTestName(key);
-      const count = this._counters.get(name);
-      if (count > 0) {
-        if (key in this._snapshotData || key in this._initialData) {
-          this._snapshotData[key] = this._initialData[key];
-        }
-        this._counters.set(name, count - 1);
-      }
-    }
-    this._testIdToKeys.delete(testId);
-    this.added.delete(testId);
-    this.updated.delete(testId);
-    this.matched.delete(testId);
-    this.unmatched.delete(testId);
-  }
-  _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("__INLINE_SNAPSHOT__")
-    );
-    return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
-  }
-  _addSnapshot(key, receivedSerialized, options) {
-    this._dirty = true;
-    if (options.stack) {
-      this._inlineSnapshots.push({
-        snapshot: receivedSerialized,
-        testId: options.testId,
-        ...options.stack
-      });
-    } else if (options.rawSnapshot) {
-      this._rawSnapshots.push({
-        ...options.rawSnapshot,
-        snapshot: receivedSerialized
-      });
-    } else {
-      this._snapshotData[key] = receivedSerialized;
-    }
-  }
-  async save() {
-    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
-    const hasInlineSnapshots = this._inlineSnapshots.length;
-    const hasRawSnapshots = this._rawSnapshots.length;
-    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots && !hasRawSnapshots;
-    const status = {
-      deleted: false,
-      saved: false
-    };
-    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
-      if (hasExternalSnapshots) {
-        await saveSnapshotFile(
-          this._environment,
-          this._snapshotData,
-          this.snapshotPath
-        );
-        this._fileExists = true;
-      }
-      if (hasInlineSnapshots) {
-        await saveInlineSnapshots(this._environment, this._inlineSnapshots);
-      }
-      if (hasRawSnapshots) {
-        await saveRawSnapshots(this._environment, this._rawSnapshots);
-      }
-      status.saved = true;
-    } else if (!hasExternalSnapshots && this._fileExists) {
-      if (this._updateSnapshot === "all") {
-        await this._environment.removeSnapshotFile(this.snapshotPath);
-        this._fileExists = false;
-      }
-      status.deleted = true;
-    }
-    return status;
-  }
-  getUncheckedCount() {
-    return this._uncheckedKeys.size || 0;
-  }
-  getUncheckedKeys() {
-    return Array.from(this._uncheckedKeys);
-  }
-  removeUncheckedKeys() {
-    if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
-      this._dirty = true;
-      this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
-      this._uncheckedKeys.clear();
-    }
-  }
-  match({
-    testId,
-    testName,
-    received,
-    key,
-    inlineSnapshot,
-    isInline,
-    error,
-    rawSnapshot
-  }) {
-    var _a, _b;
-    this._counters.increment(testName);
-    const count = this._counters.get(testName);
-    if (!key) {
-      key = testNameToKey(testName, count);
-    }
-    this._testIdToKeys.get(testId).push(key);
-    if (!(isInline && this._snapshotData[key] !== void 0)) {
-      this._uncheckedKeys.delete(key);
-    }
-    let receivedSerialized = rawSnapshot && typeof received === "string" ? received : serialize(received, void 0, this._snapshotFormat);
-    if (!rawSnapshot) {
-      receivedSerialized = addExtraLineBreaks(receivedSerialized);
-    }
-    if (rawSnapshot) {
-      if (rawSnapshot.content && rawSnapshot.content.match(/\r\n/) && !receivedSerialized.match(/\r\n/)) {
-        rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
-      }
-    }
-    const expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];
-    const expectedTrimmed = rawSnapshot ? expected : prepareExpected(expected);
-    const pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : prepareExpected(receivedSerialized));
-    const hasSnapshot = expected !== void 0;
-    const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;
-    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 = ((_b = (_a = this.environment).processStackTrace) == null ? void 0 : _b.call(_a, _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
-        };
-      }
-    }
-  }
-  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.total();
-    snapshot.matched = this.matched.total();
-    snapshot.unmatched = this.unmatched.total();
-    snapshot.updated = this.updated.total();
-    snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
-    snapshot.uncheckedKeys = Array.from(uncheckedKeys);
-    return snapshot;
-  }
+	_counters = new CounterMap();
+	_dirty;
+	_updateSnapshot;
+	_snapshotData;
+	_initialData;
+	_inlineSnapshots;
+	_inlineSnapshotStacks;
+	_testIdToKeys = new DefaultMap(() => []);
+	_rawSnapshots;
+	_uncheckedKeys;
+	_snapshotFormat;
+	_environment;
+	_fileExists;
+	expand;
+	_added = new CounterMap();
+	_matched = new CounterMap();
+	_unmatched = new CounterMap();
+	_updated = new CounterMap();
+	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) {
+		this._unmatched._total = value;
+	}
+	get updated() {
+		return this._updated;
+	}
+	set updated(value) {
+		this._updated._total = value;
+	}
+	constructor(testFilePath, snapshotPath, snapshotContent, options) {
+		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;
+	}
+	static async create(testFilePath, options) {
+		const snapshotPath = await options.snapshotEnvironment.resolvePath(testFilePath);
+		const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
+		return new SnapshotState(testFilePath, snapshotPath, content, options);
+	}
+	get environment() {
+		return this._environment;
+	}
+	markSnapshotsAsCheckedForTest(testName) {
+		this._uncheckedKeys.forEach((uncheckedKey) => {
+			if (/ \d+$| > /.test(uncheckedKey.slice(testName.length))) {
+				this._uncheckedKeys.delete(uncheckedKey);
+			}
+		});
+	}
+	clearTest(testId) {
+		this._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);
+		this._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);
+		for (const key of this._testIdToKeys.get(testId)) {
+			const name = keyToTestName(key);
+			const count = this._counters.get(name);
+			if (count > 0) {
+				if (key in this._snapshotData || key in this._initialData) {
+					this._snapshotData[key] = this._initialData[key];
+				}
+				this._counters.set(name, count - 1);
+			}
+		}
+		this._testIdToKeys.delete(testId);
+		this.added.delete(testId);
+		this.updated.delete(testId);
+		this.matched.delete(testId);
+		this.unmatched.delete(testId);
+	}
+	_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("__INLINE_SNAPSHOT__"));
+		return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
+	}
+	_addSnapshot(key, receivedSerialized, options) {
+		this._dirty = true;
+		if (options.stack) {
+			this._inlineSnapshots.push({
+				snapshot: receivedSerialized,
+				testId: options.testId,
+				...options.stack
+			});
+		} else if (options.rawSnapshot) {
+			this._rawSnapshots.push({
+				...options.rawSnapshot,
+				snapshot: receivedSerialized
+			});
+		} else {
+			this._snapshotData[key] = receivedSerialized;
+		}
+	}
+	async save() {
+		const hasExternalSnapshots = Object.keys(this._snapshotData).length;
+		const hasInlineSnapshots = this._inlineSnapshots.length;
+		const hasRawSnapshots = this._rawSnapshots.length;
+		const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots && !hasRawSnapshots;
+		const status = {
+			deleted: false,
+			saved: false
+		};
+		if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
+			if (hasExternalSnapshots) {
+				await saveSnapshotFile(this._environment, this._snapshotData, this.snapshotPath);
+				this._fileExists = true;
+			}
+			if (hasInlineSnapshots) {
+				await saveInlineSnapshots(this._environment, this._inlineSnapshots);
+			}
+			if (hasRawSnapshots) {
+				await saveRawSnapshots(this._environment, this._rawSnapshots);
+			}
+			status.saved = true;
+		} else if (!hasExternalSnapshots && this._fileExists) {
+			if (this._updateSnapshot === "all") {
+				await this._environment.removeSnapshotFile(this.snapshotPath);
+				this._fileExists = false;
+			}
+			status.deleted = true;
+		}
+		return status;
+	}
+	getUncheckedCount() {
+		return this._uncheckedKeys.size || 0;
+	}
+	getUncheckedKeys() {
+		return Array.from(this._uncheckedKeys);
+	}
+	removeUncheckedKeys() {
+		if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
+			this._dirty = true;
+			this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
+			this._uncheckedKeys.clear();
+		}
+	}
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }) {
+		this._counters.increment(testName);
+		const count = this._counters.get(testName);
+		if (!key) {
+			key = testNameToKey(testName, count);
+		}
+		this._testIdToKeys.get(testId).push(key);
+		if (!(isInline && this._snapshotData[key] !== undefined)) {
+			this._uncheckedKeys.delete(key);
+		}
+		let receivedSerialized = rawSnapshot && typeof received === "string" ? received : serialize(received, undefined, this._snapshotFormat);
+		if (!rawSnapshot) {
+			receivedSerialized = addExtraLineBreaks(receivedSerialized);
+		}
+		if (rawSnapshot) {
+			if (rawSnapshot.content && rawSnapshot.content.match(/\r\n/) && !receivedSerialized.match(/\r\n/)) {
+				rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
+			}
+		}
+		const expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];
+		const expectedTrimmed = rawSnapshot ? expected : expected === null || expected === void 0 ? void 0 : expected.trim();
+		const pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : receivedSerialized.trim());
+		const hasSnapshot = expected !== undefined;
+		const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;
+		if (pass && !isInline && !rawSnapshot) {
+			this._snapshotData[key] = receivedSerialized;
+		}
+		let stack;
+		if (isInline) {
+			var _this$environment$pro, _this$environment;
+			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.\n${JSON.stringify(stacks)}`);
+			}
+			stack = ((_this$environment$pro = (_this$environment = this.environment).processStackTrace) === null || _this$environment$pro === void 0 ? void 0 : _this$environment$pro.call(_this$environment, _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 !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,
+					key,
+					pass: false
+				};
+			} else {
+				this.matched.increment(testId);
+				return {
+					actual: "",
+					count,
+					expected: "",
+					key,
+					pass: true
+				};
+			}
+		}
+	}
+	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.total();
+		snapshot.matched = this.matched.total();
+		snapshot.unmatched = this.unmatched.total();
+		snapshot.updated = this.updated.total();
+		snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+		snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+		return snapshot;
+	}
 }
 
 function createMismatchError(message, expand, actual, expected) {
-  const error = new Error(message);
-  Object.defineProperty(error, "actual", {
-    value: actual,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  Object.defineProperty(error, "expected", {
-    value: expected,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  Object.defineProperty(error, "diffOptions", { value: { expand } });
-  return error;
+	const error = new Error(message);
+	Object.defineProperty(error, "actual", {
+		value: actual,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	Object.defineProperty(error, "expected", {
+		value: expected,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	Object.defineProperty(error, "diffOptions", { value: { expand } });
+	return error;
 }
 class SnapshotClient {
-  constructor(options = {}) {
-    this.options = options;
-  }
-  snapshotStateMap = /* @__PURE__ */ new Map();
-  async setup(filepath, options) {
-    if (this.snapshotStateMap.has(filepath)) {
-      return;
-    }
-    this.snapshotStateMap.set(
-      filepath,
-      await SnapshotState.create(filepath, options)
-    );
-  }
-  async finish(filepath) {
-    const state = this.getSnapshotState(filepath);
-    const result = await state.pack();
-    this.snapshotStateMap.delete(filepath);
-    return result;
-  }
-  skipTest(filepath, testName) {
-    const state = this.getSnapshotState(filepath);
-    state.markSnapshotsAsCheckedForTest(testName);
-  }
-  clearTest(filepath, testId) {
-    const state = this.getSnapshotState(filepath);
-    state.clearTest(testId);
-  }
-  getSnapshotState(filepath) {
-    const state = this.snapshotStateMap.get(filepath);
-    if (!state) {
-      throw new Error(
-        `The snapshot state for '${filepath}' is not found. Did you call 'SnapshotClient.setup()'?`
-      );
-    }
-    return state;
-  }
-  assert(options) {
-    var _a, _b;
-    const {
-      filepath,
-      name,
-      testId = name,
-      message,
-      isInline = false,
-      properties,
-      inlineSnapshot,
-      error,
-      errorMessage,
-      rawSnapshot
-    } = options;
-    let { received } = options;
-    if (!filepath) {
-      throw new Error("Snapshot cannot be used outside of test");
-    }
-    const snapshotState = this.getSnapshotState(filepath);
-    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 = ((_b = (_a = this.options).isEqual) == null ? void 0 : _b.call(_a, received, properties)) ?? false;
-        if (!pass2) {
-          throw createMismatchError(
-            "Snapshot properties mismatched",
-            snapshotState.expand,
-            received,
-            properties
-          );
-        } else {
-          received = deepMergeSnapshot(received, properties);
-        }
-      } catch (err) {
-        err.message = errorMessage || "Snapshot mismatched";
-        throw err;
-      }
-    }
-    const testName = [name, ...message ? [message] : []].join(" > ");
-    const { actual, expected, key, pass } = snapshotState.match({
-      testId,
-      testName,
-      received,
-      isInline,
-      error,
-      inlineSnapshot,
-      rawSnapshot
-    });
-    if (!pass) {
-      throw createMismatchError(
-        `Snapshot \`${key || "unknown"}\` mismatched`,
-        snapshotState.expand,
-        rawSnapshot ? actual : actual == null ? void 0 : actual.trim(),
-        rawSnapshot ? expected : expected == null ? void 0 : expected.trim()
-      );
-    }
-  }
-  async assertRaw(options) {
-    if (!options.rawSnapshot) {
-      throw new Error("Raw snapshot is required");
-    }
-    const { filepath, rawSnapshot } = options;
-    if (rawSnapshot.content == null) {
-      if (!filepath) {
-        throw new Error("Snapshot cannot be used outside of test");
-      }
-      const snapshotState = this.getSnapshotState(filepath);
-      options.filepath || (options.filepath = filepath);
-      rawSnapshot.file = await snapshotState.environment.resolveRawPath(
-        filepath,
-        rawSnapshot.file
-      );
-      rawSnapshot.content = await snapshotState.environment.readSnapshotFile(rawSnapshot.file) ?? void 0;
-    }
-    return this.assert(options);
-  }
-  clear() {
-    this.snapshotStateMap.clear();
-  }
+	snapshotStateMap = new Map();
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async setup(filepath, options) {
+		if (this.snapshotStateMap.has(filepath)) {
+			return;
+		}
+		this.snapshotStateMap.set(filepath, await SnapshotState.create(filepath, options));
+	}
+	async finish(filepath) {
+		const state = this.getSnapshotState(filepath);
+		const result = await state.pack();
+		this.snapshotStateMap.delete(filepath);
+		return result;
+	}
+	skipTest(filepath, testName) {
+		const state = this.getSnapshotState(filepath);
+		state.markSnapshotsAsCheckedForTest(testName);
+	}
+	clearTest(filepath, testId) {
+		const state = this.getSnapshotState(filepath);
+		state.clearTest(testId);
+	}
+	getSnapshotState(filepath) {
+		const state = this.snapshotStateMap.get(filepath);
+		if (!state) {
+			throw new Error(`The snapshot state for '${filepath}' is not found. Did you call 'SnapshotClient.setup()'?`);
+		}
+		return state;
+	}
+	assert(options) {
+		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot } = options;
+		let { received } = options;
+		if (!filepath) {
+			throw new Error("Snapshot cannot be used outside of test");
+		}
+		const snapshotState = this.getSnapshotState(filepath);
+		if (typeof properties === "object") {
+			if (typeof received !== "object" || !received) {
+				throw new Error("Received value must be an object when the matcher has properties");
+			}
+			try {
+				var _this$options$isEqual, _this$options;
+				const pass = ((_this$options$isEqual = (_this$options = this.options).isEqual) === null || _this$options$isEqual === void 0 ? void 0 : _this$options$isEqual.call(_this$options, received, properties)) ?? false;
+				if (!pass) {
+					throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, received, properties);
+				} else {
+					received = deepMergeSnapshot(received, properties);
+				}
+			} catch (err) {
+				err.message = errorMessage || "Snapshot mismatched";
+				throw err;
+			}
+		}
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const { actual, expected, key, pass } = snapshotState.match({
+			testId,
+			testName,
+			received,
+			isInline,
+			error,
+			inlineSnapshot,
+			rawSnapshot
+		});
+		if (!pass) {
+			throw createMismatchError(`Snapshot \`${key || "unknown"}\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual === null || actual === void 0 ? void 0 : actual.trim(), rawSnapshot ? expected : expected === null || expected === void 0 ? void 0 : expected.trim());
+		}
+	}
+	async assertRaw(options) {
+		if (!options.rawSnapshot) {
+			throw new Error("Raw snapshot is required");
+		}
+		const { filepath, rawSnapshot } = options;
+		if (rawSnapshot.content == null) {
+			if (!filepath) {
+				throw new Error("Snapshot cannot be used outside of test");
+			}
+			const snapshotState = this.getSnapshotState(filepath);
+			options.filepath || (options.filepath = filepath);
+			rawSnapshot.file = await snapshotState.environment.resolveRawPath(filepath, rawSnapshot.file);
+			rawSnapshot.content = await snapshotState.environment.readSnapshotFile(rawSnapshot.file) ?? undefined;
+		}
+		return this.assert(options);
+	}
+	clear() {
+		this.snapshotStateMap.clear();
+	}
 }
 
 export { SnapshotClient, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };