@farming-labs/theme 0.0.26 → 0.0.28

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

@@ -1,1821 +0,0 @@
-import { format, plugins } from "../../../../../@vitest_pretty-format@3.2.4/node_modules/@vitest/pretty-format/dist/index.mjs";
-import { resolve as resolve$2 } from "../../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs";
-
-//#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 < 64; 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 {
-		integer = charToInt[reader.next()];
-		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, b) {
-	return a[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) {
-	UrlType[UrlType["Empty"] = 1] = "Empty";
-	UrlType[UrlType["Hash"] = 2] = "Hash";
-	UrlType[UrlType["Query"] = 3] = "Query";
-	UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-	UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-	UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-	UrlType[UrlType["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 = parseAbsoluteUrl("http:" + input);
-		url.scheme = "";
-		url.type = UrlType.SchemeRelative;
-		return url;
-	}
-	if (isAbsolutePath(input)) {
-		const url = parseAbsoluteUrl("http://foo.com" + input);
-		url.scheme = "";
-		url.host = "";
-		url.type = UrlType.AbsolutePath;
-		return url;
-	}
-	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(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, b) {
-	return a[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 || void 0;
-		const from = resolve(sourceRoot || "", stripFilename(mapUrl));
-		this.resolvedSources = sources.map((s) => resolve(s || "", from));
-		const { mappings } = parsed;
-		if (typeof mappings === "string") {
-			this._encoded = mappings;
-			this._decoded = void 0;
-		} else {
-			this._encoded = void 0;
-			this._decoded = maybeSort(mappings, isString);
-		}
-		this._decodedMemo = memoizedState();
-		this._bySources = void 0;
-		this._bySourceMemos = void 0;
-	}
-};
-/**
-* 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];
-		if ((char === "\"" || char === "'" || char === "`") && 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 parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.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
-	];
-}
-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)
-	};
-}
-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)
-	};
-}
-function parseStacktrace(stack, options = {}) {
-	const { ignoreStackEntries = stackIgnorePatterns } = options;
-	return (!CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack)).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 { line, column, source, name } = originalPositionFor(new TraceMap(map), 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 (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.method
-		};
-		return stack;
-	}).filter((s) => s != null);
-}
-function shouldFilter(ignoreStackEntries, file) {
-	return ignoreStackEntries.some((p) => file.match(p));
-}
-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) => options.frameFilter(e, f) !== false);
-	e.stacks = stackFrames;
-	return stackFrames;
-}
-try {
-	const { getPromiseDetails, kPending, kRejected } = process.binding("util");
-	if (Array.isArray(getPromiseDetails(Promise.resolve()))) {}
-} 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 = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
-	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 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 h = Object.entries({
-	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]
-});
-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.mjs")).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) replaceInlineSnap(code, s, positionToOffset(code, snap.line, snap.column), 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 shapeEnd = getObjectShapeEndIndex(code, index + startMatch.index + startMatch[0].length);
-	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 indent = source.split(lineSplitRE)[lineNumber - 1].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 - 21;
-	if (code.slice(indexInline, index) === toMatchInlineName) return {
-		code: code.slice(indexInline),
-		index: indexInline
-	};
-	const indexThrowInline = index - 34;
-	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 endMatch = new RegExp(`(?:^|[^\\\\])${quote}`).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 = function(a, b) {
-		var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
-		function getCode(str, pos, code) {
-			if (code) {
-				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
-				return +str.slice(pos - 1, i);
-			}
-			code = alphabet && alphabet.indexOf(str.charAt(pos));
-			return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
-		}
-		if ((a += "") != (b += "")) for (; codeB;) {
-			codeA = getCode(a, posA++);
-			codeB = getCode(b, posB++);
-			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
-				codeA = getCode(a, posA, posA);
-				codeB = getCode(b, posB, posA = i);
-				posB = i;
-			}
-			if (codeA != codeB) return codeA < codeB ? -1 : 1;
-		}
-		return 0;
-	};
-	try {
-		naturalCompare$1.exports = naturalCompare;
-	} catch (e) {
-		String.naturalCompare = naturalCompare;
-	}
-	return naturalCompare$1.exports;
-}
-var naturalCompare = /* @__PURE__ */ getDefaultExportFromCjs(requireNaturalCompare());
-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) {
-	PLUGINS = [plugin].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;
-		new Function("exports", snapshotContents)(data);
-	} catch {}
-	if ((update === "all" || update === "new") && snapshotContents) 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);
-	if (oldContent != null && oldContent === content) 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);
-		return new SnapshotState(testFilePath, snapshotPath, await options.snapshotEnvironment.readSnapshotFile(snapshotPath), 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] !== 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 : expected === null || expected === void 0 ? void 0 : expected.trim();
-		const pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : receivedSerialized.trim());
-		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) {
-			var _this$environment$pro, _this$environment;
-			const stacks = parseErrorStacktrace(error || /* @__PURE__ */ 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(/* @__PURE__ */ 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;
-	}
-};
-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 = /* @__PURE__ */ 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 result = await this.getSnapshotState(filepath).pack();
-		this.snapshotStateMap.delete(filepath);
-		return result;
-	}
-	skipTest(filepath, testName) {
-		this.getSnapshotState(filepath).markSnapshotsAsCheckedForTest(testName);
-	}
-	clearTest(filepath, testId) {
-		this.getSnapshotState(filepath).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;
-				if (!(((_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)) 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) ?? void 0;
-		}
-		return this.assert(options);
-	}
-	clear() {
-		this.snapshotStateMap.clear();
-	}
-};
-
-//#endregion
-export { SnapshotClient, addSerializer, stripSnapshotIndentation };