@directus/api 34.0.1 → 35.0.0

package/dist/node_modules/.pnpm/@vitest_snapshot@3.2.4/node_modules/@vitest/snapshot/dist/index.js

@@ -0,0 +1,2082 @@
+import { format, plugins } from "../../../../../@vitest_pretty-format@3.2.4/node_modules/@vitest/pretty-format/dist/index.js";
+import { resolve } from "../../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.js";
+import "../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+
+//#region ../node_modules/.pnpm/@vitest+snapshot@3.2.4/node_modules/@vitest/snapshot/dist/index.js
+const comma = ",".charCodeAt(0);
+const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = new Uint8Array(64);
+const charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		const c = reader.next();
+		integer = charToInt[c];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) {
+		value = -2147483648 | -value;
+	}
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else {
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn
+					];
+				}
+			} else {
+				seg = [genColumn];
+			}
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a$1, b) {
+	return a$1[0] - b[0];
+}
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var UrlType;
+(function(UrlType$1) {
+	UrlType$1[UrlType$1["Empty"] = 1] = "Empty";
+	UrlType$1[UrlType$1["Hash"] = 2] = "Hash";
+	UrlType$1[UrlType$1["Query"] = 3] = "Query";
+	UrlType$1[UrlType$1["RelativePath"] = 4] = "RelativePath";
+	UrlType$1[UrlType$1["AbsolutePath"] = 5] = "AbsolutePath";
+	UrlType$1[UrlType$1["SchemeRelative"] = 6] = "SchemeRelative";
+	UrlType$1[UrlType$1["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: UrlType.Absolute
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url$1 = parseAbsoluteUrl("http:" + input);
+		url$1.scheme = "";
+		url$1.type = UrlType.SchemeRelative;
+		return url$1;
+	}
+	if (isAbsolutePath(input)) {
+		const url$1 = parseAbsoluteUrl("http://foo.com" + input);
+		url$1.scheme = "";
+		url$1.host = "";
+		url$1.type = UrlType.AbsolutePath;
+		return url$1;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? UrlType.Query : input.startsWith("#") ? UrlType.Hash : UrlType.RelativePath : UrlType.Empty;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") {
+		url.path = base.path;
+	} else {
+		url.path = stripPathFilename(base.path) + url.path;
+	}
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= UrlType.RelativePath;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) {
+				pieces[pointer++] = piece;
+			}
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) {
+		path += "/" + pieces[i];
+	}
+	if (!path || addTrailingSlash && !path.endsWith("/..")) {
+		path += "/";
+	}
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve$1(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== UrlType.Absolute) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case UrlType.Empty: url.hash = baseUrl.hash;
+			case UrlType.Hash: url.query = baseUrl.query;
+			case UrlType.Query:
+			case UrlType.RelativePath: mergePaths(url, baseUrl);
+			case UrlType.AbsolutePath:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case UrlType.SchemeRelative: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case UrlType.Hash:
+		case UrlType.Query: return queryHash;
+		case UrlType.RelativePath: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) {
+				return "./" + path + queryHash;
+			}
+			return path + queryHash;
+		}
+		case UrlType.AbsolutePath: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+function resolve$2(input, base) {
+	if (base && !base.endsWith("/")) base += "/";
+	return resolve$1(input, base);
+}
+/**
+* Removes everything after the last "/", but leaves the slash.
+*/
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+		mappings[i] = sortSegments(mappings[i], owned);
+	}
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) {
+		if (!isSorted(mappings[i])) return i;
+	}
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) {
+		if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+			return false;
+		}
+	}
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a$1, b) {
+	return a$1[COLUMN] - b[COLUMN];
+}
+let found = false;
+/**
+* A binary search implementation that returns the index if a match is found.
+* If no match is found, then the left-index (the index associated with the item that comes just
+* before the desired index) is returned. To maintain proper sort order, a splice would happen at
+* the next index:
+*
+* ```js
+* const array = [1, 3];
+* const needle = 2;
+* const index = binarySearch(array, needle, (item, needle) => item - needle);
+*
+* assert.equal(index, 0);
+* array.splice(index + 1, 0, needle);
+* assert.deepEqual(array, [1, 2, 3]);
+* ```
+*/
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) {
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) {
+		if (haystack[i][COLUMN] !== needle) break;
+	}
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) {
+		if (haystack[i][COLUMN] !== needle) break;
+	}
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+/**
+* This overly complicated beast is just to record the last tested line/column and the resulting
+* index, allowing us to skip a few tests if mappings are monotonically increasing.
+*/
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) {
+			low = lastIndex === -1 ? 0 : lastIndex;
+		} else {
+			high = lastIndex;
+		}
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = isString ? JSON.parse(map) : map;
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+		const from = resolve$2(sourceRoot || "", stripFilename(mapUrl));
+		this.resolvedSources = sources.map((s) => resolve$2(s || "", from));
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = undefined;
+		} else {
+			this._encoded = undefined;
+			this._decoded = maybeSort(mappings, isString);
+		}
+		this._decodedMemo = memoizedState();
+		this._bySources = undefined;
+		this._bySourceMemos = undefined;
+	}
+};
+/**
+* Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+* with public access modifiers.
+*/
+function cast(map) {
+	return map;
+}
+/**
+* Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+*/
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+/**
+* A higher-level API to find the source/line/column associated with a generated line/column
+* (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+* `source-map` library.
+*/
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) {
+		index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	} else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+/**
+* 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;
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function isObject(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;
+}
+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/",
+	"/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] || 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] : 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) ? 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(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((stack$1) => {
+		var _options$getSourceMap;
+		if (options.getUrlId) {
+			stack$1.file = options.getUrlId(stack$1.file);
+		}
+		const map = (_options$getSourceMap = options.getSourceMap) === null || _options$getSourceMap === void 0 ? void 0 : _options$getSourceMap.call(options, stack$1.file);
+		if (!map || typeof map !== "object" || !map.version) {
+			return shouldFilter(ignoreStackEntries, stack$1.file) ? null : stack$1;
+		}
+		const traceMap = new TraceMap(map);
+		const { line, column, source, name } = originalPositionFor(traceMap, stack$1);
+		let file = stack$1.file;
+		if (source) {
+			const fileUrl = stack$1.file.startsWith("file://") ? stack$1.file : `file://${stack$1.file}`;
+			const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
+			file = new URL(source, sourceRootUrl).pathname;
+			if (file.match(/\/\w:\//)) {
+				file = file.slice(1);
+			}
+		}
+		if (shouldFilter(ignoreStackEntries, file)) {
+			return null;
+		}
+		if (line != null && column != null) {
+			return {
+				line,
+				column,
+				file,
+				method: name || stack$1.method
+			};
+		}
+		return stack$1;
+	}).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+	return ignoreStackEntries.some((p$1) => file.match(p$1));
+}
+function parseFFOrSafariStackTrace(stack) {
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+	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 || "";
+	let stackFrames = typeof stackStr === "string" ? 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$1) => options.frameFilter(e, f$1) !== false);
+	}
+	e.stacks = stackFrames;
+	return stackFrames;
+}
+let getPromiseValue = () => "Promise{…}";
+try {
+	const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+	if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+		getPromiseValue = (value, options) => {
+			const [state, innerValue] = getPromiseDetails(value);
+			if (state === kPending) {
+				return "Promise{<pending>}";
+			}
+			return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+		};
+	}
+} catch (notNode) {}
+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;
+}
+var jsTokens_1;
+var hasRequiredJsTokens;
+function requireJsTokens() {
+	if (hasRequiredJsTokens) return jsTokens_1;
+	hasRequiredJsTokens = 1;
+	var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy;
+	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy;
+	StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y;
+	NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+	Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+	WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy;
+	LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+	MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y;
+	SingleLineComment = /\/\/.*/y;
+	JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+	JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
+	JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y;
+	JSXText = /[^<>{}]+/y;
+	TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+	TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+	KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+	KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+	Newline = RegExp(LineTerminatorSequence.source);
+	jsTokens_1 = function* (input, { jsx = false } = {}) {
+		var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+		({length} = input);
+		lastIndex = 0;
+		lastSignificantToken = "";
+		stack = [{ tag: "JS" }];
+		braces = [];
+		parenNesting = 0;
+		postfixIncDec = false;
+		while (lastIndex < length) {
+			mode = stack[stack.length - 1];
+			switch (mode.tag) {
+				case "JS":
+				case "JSNonExpressionParen":
+				case "InterpolationInTemplate":
+				case "InterpolationInJSX":
+					if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+						RegularExpressionLiteral.lastIndex = lastIndex;
+						if (match = RegularExpressionLiteral.exec(input)) {
+							lastIndex = RegularExpressionLiteral.lastIndex;
+							lastSignificantToken = match[0];
+							postfixIncDec = true;
+							yield {
+								type: "RegularExpressionLiteral",
+								value: match[0],
+								closed: match[1] !== void 0 && match[1] !== "\\"
+							};
+							continue;
+						}
+					}
+					Punctuator.lastIndex = lastIndex;
+					if (match = Punctuator.exec(input)) {
+						punctuator = match[0];
+						nextLastIndex = Punctuator.lastIndex;
+						nextLastSignificantToken = punctuator;
+						switch (punctuator) {
+							case "(":
+								if (lastSignificantToken === "?NonExpressionParenKeyword") {
+									stack.push({
+										tag: "JSNonExpressionParen",
+										nesting: parenNesting
+									});
+								}
+								parenNesting++;
+								postfixIncDec = false;
+								break;
+							case ")":
+								parenNesting--;
+								postfixIncDec = true;
+								if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+									stack.pop();
+									nextLastSignificantToken = "?NonExpressionParenEnd";
+									postfixIncDec = false;
+								}
+								break;
+							case "{":
+								Punctuator.lastIndex = 0;
+								isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+								braces.push(isExpression);
+								postfixIncDec = false;
+								break;
+							case "}":
+								switch (mode.tag) {
+									case "InterpolationInTemplate":
+										if (braces.length === mode.nesting) {
+											Template.lastIndex = lastIndex;
+											match = Template.exec(input);
+											lastIndex = Template.lastIndex;
+											lastSignificantToken = match[0];
+											if (match[1] === "${") {
+												lastSignificantToken = "?InterpolationInTemplate";
+												postfixIncDec = false;
+												yield {
+													type: "TemplateMiddle",
+													value: match[0]
+												};
+											} else {
+												stack.pop();
+												postfixIncDec = true;
+												yield {
+													type: "TemplateTail",
+													value: match[0],
+													closed: match[1] === "`"
+												};
+											}
+											continue;
+										}
+										break;
+									case "InterpolationInJSX": if (braces.length === mode.nesting) {
+										stack.pop();
+										lastIndex += 1;
+										lastSignificantToken = "}";
+										yield {
+											type: "JSXPunctuator",
+											value: "}"
+										};
+										continue;
+									}
+								}
+								postfixIncDec = braces.pop();
+								nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+								break;
+							case "]":
+								postfixIncDec = true;
+								break;
+							case "++":
+							case "--":
+								nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+								break;
+							case "<":
+								if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+									stack.push({ tag: "JSXTag" });
+									lastIndex += 1;
+									lastSignificantToken = "<";
+									yield {
+										type: "JSXPunctuator",
+										value: punctuator
+									};
+									continue;
+								}
+								postfixIncDec = false;
+								break;
+							default: postfixIncDec = false;
+						}
+						lastIndex = nextLastIndex;
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "Punctuator",
+							value: punctuator
+						};
+						continue;
+					}
+					Identifier.lastIndex = lastIndex;
+					if (match = Identifier.exec(input)) {
+						lastIndex = Identifier.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "for":
+							case "if":
+							case "while":
+							case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+								nextLastSignificantToken = "?NonExpressionParenKeyword";
+							}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+						yield {
+							type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+							value: match[0]
+						};
+						continue;
+					}
+					StringLiteral.lastIndex = lastIndex;
+					if (match = StringLiteral.exec(input)) {
+						lastIndex = StringLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "StringLiteral",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					NumericLiteral.lastIndex = lastIndex;
+					if (match = NumericLiteral.exec(input)) {
+						lastIndex = NumericLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "NumericLiteral",
+							value: match[0]
+						};
+						continue;
+					}
+					Template.lastIndex = lastIndex;
+					if (match = Template.exec(input)) {
+						lastIndex = Template.lastIndex;
+						lastSignificantToken = match[0];
+						if (match[1] === "${") {
+							lastSignificantToken = "?InterpolationInTemplate";
+							stack.push({
+								tag: "InterpolationInTemplate",
+								nesting: braces.length
+							});
+							postfixIncDec = false;
+							yield {
+								type: "TemplateHead",
+								value: match[0]
+							};
+						} else {
+							postfixIncDec = true;
+							yield {
+								type: "NoSubstitutionTemplate",
+								value: match[0],
+								closed: match[1] === "`"
+							};
+						}
+						continue;
+					}
+					break;
+				case "JSXTag":
+				case "JSXTagEnd":
+					JSXPunctuator.lastIndex = lastIndex;
+					if (match = JSXPunctuator.exec(input)) {
+						lastIndex = JSXPunctuator.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "<":
+								stack.push({ tag: "JSXTag" });
+								break;
+							case ">":
+								stack.pop();
+								if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+									nextLastSignificantToken = "?JSX";
+									postfixIncDec = true;
+								} else {
+									stack.push({ tag: "JSXChildren" });
+								}
+								break;
+							case "{":
+								stack.push({
+									tag: "InterpolationInJSX",
+									nesting: braces.length
+								});
+								nextLastSignificantToken = "?InterpolationInJSX";
+								postfixIncDec = false;
+								break;
+							case "/": if (lastSignificantToken === "<") {
+								stack.pop();
+								if (stack[stack.length - 1].tag === "JSXChildren") {
+									stack.pop();
+								}
+								stack.push({ tag: "JSXTagEnd" });
+							}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "JSXPunctuator",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXIdentifier.lastIndex = lastIndex;
+					if (match = JSXIdentifier.exec(input)) {
+						lastIndex = JSXIdentifier.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXIdentifier",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXString.lastIndex = lastIndex;
+					if (match = JSXString.exec(input)) {
+						lastIndex = JSXString.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXString",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					break;
+				case "JSXChildren":
+					JSXText.lastIndex = lastIndex;
+					if (match = JSXText.exec(input)) {
+						lastIndex = JSXText.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXText",
+							value: match[0]
+						};
+						continue;
+					}
+					switch (input[lastIndex]) {
+						case "<":
+							stack.push({ tag: "JSXTag" });
+							lastIndex++;
+							lastSignificantToken = "<";
+							yield {
+								type: "JSXPunctuator",
+								value: "<"
+							};
+							continue;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							lastIndex++;
+							lastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							yield {
+								type: "JSXPunctuator",
+								value: "{"
+							};
+							continue;
+					}
+			}
+			WhiteSpace.lastIndex = lastIndex;
+			if (match = WhiteSpace.exec(input)) {
+				lastIndex = WhiteSpace.lastIndex;
+				yield {
+					type: "WhiteSpace",
+					value: match[0]
+				};
+				continue;
+			}
+			LineTerminatorSequence.lastIndex = lastIndex;
+			if (match = LineTerminatorSequence.exec(input)) {
+				lastIndex = LineTerminatorSequence.lastIndex;
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+					lastSignificantToken = "?NoLineTerminatorHere";
+				}
+				yield {
+					type: "LineTerminatorSequence",
+					value: match[0]
+				};
+				continue;
+			}
+			MultiLineComment.lastIndex = lastIndex;
+			if (match = MultiLineComment.exec(input)) {
+				lastIndex = MultiLineComment.lastIndex;
+				if (Newline.test(match[0])) {
+					postfixIncDec = false;
+					if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+						lastSignificantToken = "?NoLineTerminatorHere";
+					}
+				}
+				yield {
+					type: "MultiLineComment",
+					value: match[0],
+					closed: match[1] !== void 0
+				};
+				continue;
+			}
+			SingleLineComment.lastIndex = lastIndex;
+			if (match = SingleLineComment.exec(input)) {
+				lastIndex = SingleLineComment.lastIndex;
+				postfixIncDec = false;
+				yield {
+					type: "SingleLineComment",
+					value: match[0]
+				};
+				continue;
+			}
+			firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+			lastIndex += firstCodePoint.length;
+			lastSignificantToken = firstCodePoint;
+			postfixIncDec = false;
+			yield {
+				type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+				value: firstCodePoint
+			};
+		}
+		return void 0;
+	};
+	return jsTokens_1;
+}
+requireJsTokens();
+var reservedWords = {
+	keyword: [
+		"break",
+		"case",
+		"catch",
+		"continue",
+		"debugger",
+		"default",
+		"do",
+		"else",
+		"finally",
+		"for",
+		"function",
+		"if",
+		"return",
+		"switch",
+		"throw",
+		"try",
+		"var",
+		"const",
+		"while",
+		"with",
+		"new",
+		"this",
+		"super",
+		"class",
+		"extends",
+		"export",
+		"import",
+		"null",
+		"true",
+		"false",
+		"in",
+		"instanceof",
+		"typeof",
+		"void",
+		"delete"
+	],
+	strict: [
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield"
+	]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
+var f = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+}, h = Object.entries(f);
+function a(n) {
+	return String(n);
+}
+a.open = "";
+a.close = "";
+function C(n = false) {
+	let e = typeof process != "undefined" ? process : void 0, i = (e == null ? void 0 : e.env) || {}, g = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window != "undefined" && !!window.chrome;
+}
+function p(n = false) {
+	let e = C(n), i = (r, t, c, o) => {
+		let l = "", s = 0;
+		do
+			l += r.substring(s, o) + c, s = o + t.length, o = r.indexOf(t, s);
+		while (~o);
+		return l + r.substring(s);
+	}, g = (r, t, c = r) => {
+		let o = (l) => {
+			let s = String(l), b = s.indexOf(t, r.length);
+			return ~b ? r + i(s, t, c, b) + t : r + s + t;
+		};
+		return o.open = r, o.close = t, o;
+	}, u = { isColorSupported: e }, d = (r) => `\x1B[${r}m`;
+	for (let [r, t] of h) u[r] = e ? g(d(t[0]), d(t[1]), t[2]) : a;
+	return u;
+}
+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;
+}
+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;
+}
+async function saveInlineSnapshots(environment, snapshots) {
+	const MagicString = (await import("../../../../../magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.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 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;
+}
+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;
+}
+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}\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 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 || 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;
+}
+async function saveRawSnapshots(environment, snapshots) {
+	await Promise.all(snapshots.map(async (snap) => {
+		if (!snap.readonly) {
+			await environment.saveSnapshotFile(snap.file, snap.snapshot);
+		}
+	}));
+}
+var naturalCompare$1 = { exports: {} };
+var hasRequiredNaturalCompare;
+function requireNaturalCompare() {
+	if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
+	hasRequiredNaturalCompare = 1;
+	/*
+	* @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$2 = function(a$1, 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 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
+		}
+		if ((a$1 += "") != (b += "")) for (; codeB;) {
+			codeA = getCode(a$1, posA++);
+			codeB = getCode(b, posB++);
+			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+				codeA = getCode(a$1, 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$2;
+	} catch (e) {
+		String.naturalCompare = naturalCompare$2;
+	}
+	return naturalCompare$1.exports;
+}
+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 test = (val) => val && !!val._isMockFunction;
+const plugin = {
+	serialize: serialize$1,
+	test
+};
+const { DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent, AsymmetricMatcher } = plugins;
+let PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher,
+	plugin
+];
+function addSerializer(plugin$1) {
+	PLUGINS = [plugin$1].concat(PLUGINS);
+}
+function getSerializers() {
+	return PLUGINS;
+}
+function testNameToKey(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+$/, "");
+}
+function getSnapshotData(content, options) {
+	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") ? `\n${string}\n` : string;
+}
+function removeExtraLineBreaks(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
+	}));
+}
+function escapeBacktickString(str) {
+	return str.replace(/`|\\|\$\{/g, "\\$&");
+}
+function printBacktickString(str) {
+	return `\`${escapeBacktickString(str)}\``;
+}
+function normalizeNewlines(string) {
+	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()}\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;
+}
+/**
+* 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;
+}
+var DefaultMap = class 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);
+	}
+};
+var CounterMap = class extends DefaultMap {
+	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;
+}
+var SnapshotState = class SnapshotState {
+	_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;
+}
+var SnapshotClient = class {
+	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$1 = ((_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$1) {
+					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();
+	}
+};
+
+//#endregion
+export { SnapshotClient, addSerializer, stripSnapshotIndentation };