@cartanova/qgrid-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,662 @@
+import { format, plugins } from "../../../../../@vitest_pretty-format@4.1.2/node_modules/@vitest/pretty-format/dist/index.js";
+import { getCallLastIndex, isObject } from "../../../../../@vitest_utils@4.1.2/node_modules/@vitest/utils/dist/helpers.js";
+import { parseErrorStacktrace } from "../../../../../@vitest_utils@4.1.2/node_modules/@vitest/utils/dist/source-map.js";
+import { lineSplitRE, offsetToLineNumber, positionToOffset } from "../../../../../@vitest_utils@4.1.2/node_modules/@vitest/utils/dist/offset.js";
+//#region ../../node_modules/.pnpm/@vitest+snapshot@4.1.2/node_modules/@vitest/snapshot/dist/index.js
+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);
+		if (code == null) throw new Error(`cannot read ${file} when saving inline snapshot`);
+		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?.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.at(-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);
+	}));
+}
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+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[0] === "\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];
+		for (let i = 0; i < stacks.length; i++) {
+			const match = stacks[i].method.match(/__INLINE_SNAPSHOT_OFFSET_(\d+)__/);
+			if (match) return stacks[i + Number(match[1])] ?? null;
+		}
+		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?.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) {
+			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.processStackTrace?.(_stack) || _stack;
+			stack.column--;
+			const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
+			if (snapshotsWithSameStack.length > 0) {
+				this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
+				const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== receivedSerialized);
+				if (differentSnapshot) throw Object.assign(/* @__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 {
+				if (!(this.options.isEqual?.(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?.trim(), rawSnapshot ? expected : 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 ||= 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 };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+snapshot@4.1.2/node_modules/@vitest/snapshot/dist/index.js"],"sourcesContent":["import { parseErrorStacktrace } from '@vitest/utils/source-map';\nimport { getCallLastIndex, isObject } from '@vitest/utils/helpers';\nimport { positionToOffset, offsetToLineNumber, lineSplitRE } from '@vitest/utils/offset';\nimport { plugins, format } from '@vitest/pretty-format';\n\nasync function saveInlineSnapshots(environment, snapshots) {\n\tconst MagicString = (await import('magic-string')).default;\n\tconst files = new Set(snapshots.map((i) => i.file));\n\tawait Promise.all(Array.from(files).map(async (file) => {\n\t\tconst snaps = snapshots.filter((i) => i.file === file);\n\t\tconst code = await environment.readSnapshotFile(file);\n\t\tif (code == null) {\n\t\t\tthrow new Error(`cannot read ${file} when saving inline snapshot`);\n\t\t}\n\t\tconst s = new MagicString(code);\n\t\tfor (const snap of snaps) {\n\t\t\tconst index = positionToOffset(code, snap.line, snap.column);\n\t\t\treplaceInlineSnap(code, s, index, snap.snapshot);\n\t\t}\n\t\tconst transformed = s.toString();\n\t\tif (transformed !== code) {\n\t\t\tawait environment.saveSnapshotFile(file, transformed);\n\t\t}\n\t}));\n}\nconst startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\\s*\\(\\s*(?:\\/\\*[\\s\\S]*\\*\\/\\s*|\\/\\/.*(?:[\\n\\r\\u2028\\u2029]\\s*|[\\t\\v\\f \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000\\uFEFF]))*\\{/;\nfunction replaceObjectSnap(code, s, index, newSnap) {\n\tlet _code = code.slice(index);\n\tconst startMatch = startObjectRegex.exec(_code);\n\tif (!startMatch) {\n\t\treturn false;\n\t}\n\t_code = _code.slice(startMatch.index);\n\tlet callEnd = getCallLastIndex(_code);\n\tif (callEnd === null) {\n\t\treturn false;\n\t}\n\tcallEnd += index + startMatch.index;\n\tconst shapeStart = index + startMatch.index + startMatch[0].length;\n\tconst shapeEnd = getObjectShapeEndIndex(code, shapeStart);\n\tconst snap = `, ${prepareSnapString(newSnap, code, index)}`;\n\tif (shapeEnd === callEnd) {\n\t\t// toMatchInlineSnapshot({ foo: expect.any(String) })\n\t\ts.appendLeft(callEnd, snap);\n\t} else {\n\t\t// toMatchInlineSnapshot({ foo: expect.any(String) }, ``)\n\t\ts.overwrite(shapeEnd, callEnd, snap);\n\t}\n\treturn true;\n}\nfunction getObjectShapeEndIndex(code, index) {\n\tlet startBraces = 1;\n\tlet endBraces = 0;\n\twhile (startBraces !== endBraces && index < code.length) {\n\t\tconst s = code[index++];\n\t\tif (s === \"{\") {\n\t\t\tstartBraces++;\n\t\t} else if (s === \"}\") {\n\t\t\tendBraces++;\n\t\t}\n\t}\n\treturn index;\n}\nfunction prepareSnapString(snap, source, index) {\n\tconst lineNumber = offsetToLineNumber(source, index);\n\tconst line = source.split(lineSplitRE)[lineNumber - 1];\n\tconst indent = line.match(/^\\s*/)[0] || \"\";\n\tconst indentNext = indent.includes(\"\t\") ? `${indent}\\t` : `${indent}  `;\n\tconst lines = snap.trim().replace(/\\\\/g, \"\\\\\\\\\").split(/\\n/g);\n\tconst isOneline = lines.length <= 1;\n\tconst quote = \"`\";\n\tif (isOneline) {\n\t\treturn `${quote}${lines.join(\"\\n\").replace(/`/g, \"\\\\`\").replace(/\\$\\{/g, \"\\\\${\")}${quote}`;\n\t}\n\treturn `${quote}\\n${lines.map((i) => i ? indentNext + i : \"\").join(\"\\n\").replace(/`/g, \"\\\\`\").replace(/\\$\\{/g, \"\\\\${\")}\\n${indent}${quote}`;\n}\nconst toMatchInlineName = \"toMatchInlineSnapshot\";\nconst toThrowErrorMatchingInlineName = \"toThrowErrorMatchingInlineSnapshot\";\n// on webkit, the line number is at the end of the method, not at the start\nfunction getCodeStartingAtIndex(code, index) {\n\tconst indexInline = index - toMatchInlineName.length;\n\tif (code.slice(indexInline, index) === toMatchInlineName) {\n\t\treturn {\n\t\t\tcode: code.slice(indexInline),\n\t\t\tindex: indexInline\n\t\t};\n\t}\n\tconst indexThrowInline = index - toThrowErrorMatchingInlineName.length;\n\tif (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {\n\t\treturn {\n\t\t\tcode: code.slice(index - indexThrowInline),\n\t\t\tindex: index - indexThrowInline\n\t\t};\n\t}\n\treturn {\n\t\tcode: code.slice(index),\n\t\tindex\n\t};\n}\nconst 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$]*(['\"`)])/;\nfunction replaceInlineSnap(code, s, currentIndex, newSnap) {\n\tconst { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);\n\tconst startMatch = startRegex.exec(codeStartingAtIndex);\n\tconst firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);\n\tif (!startMatch || startMatch.index !== firstKeywordMatch?.index) {\n\t\treturn replaceObjectSnap(code, s, index, newSnap);\n\t}\n\tconst quote = startMatch[1];\n\tconst startIndex = index + startMatch.index + startMatch[0].length;\n\tconst snapString = prepareSnapString(newSnap, code, index);\n\tif (quote === \")\") {\n\t\ts.appendRight(startIndex - 1, snapString);\n\t\treturn true;\n\t}\n\tconst quoteEndRE = new RegExp(`(?:^|[^\\\\\\\\])${quote}`);\n\tconst endMatch = quoteEndRE.exec(code.slice(startIndex));\n\tif (!endMatch) {\n\t\treturn false;\n\t}\n\tconst endIndex = startIndex + endMatch.index + endMatch[0].length;\n\ts.overwrite(startIndex - 1, endIndex, snapString);\n\treturn true;\n}\nconst INDENTATION_REGEX = /^([^\\S\\n]*)\\S/m;\nfunction stripSnapshotIndentation(inlineSnapshot) {\n\t// Find indentation if exists.\n\tconst match = inlineSnapshot.match(INDENTATION_REGEX);\n\tif (!match || !match[1]) {\n\t\t// No indentation.\n\t\treturn inlineSnapshot;\n\t}\n\tconst indentation = match[1];\n\tconst lines = inlineSnapshot.split(/\\n/g);\n\tif (lines.length <= 2) {\n\t\t// Must be at least 3 lines.\n\t\treturn inlineSnapshot;\n\t}\n\tif (lines[0].trim() !== \"\" || lines.at(-1)?.trim() !== \"\") {\n\t\t// If not blank first and last lines, abort.\n\t\treturn inlineSnapshot;\n\t}\n\tfor (let i = 1; i < lines.length - 1; i++) {\n\t\tif (lines[i] !== \"\") {\n\t\t\tif (lines[i].indexOf(indentation) !== 0) {\n\t\t\t\t// All lines except first and last should either be blank or have the same\n\t\t\t\t// indent as the first line (or more). If this isn't the case we don't\n\t\t\t\t// want to touch the snapshot at all.\n\t\t\t\treturn inlineSnapshot;\n\t\t\t}\n\t\t\tlines[i] = lines[i].substring(indentation.length);\n\t\t}\n\t}\n\t// Last line is a special case because it won't have the same indent as others\n\t// but may still have been given some indent to line up.\n\tlines[lines.length - 1] = \"\";\n\t// Return inline snapshot, now at indent 0.\n\tinlineSnapshot = lines.join(\"\\n\");\n\treturn inlineSnapshot;\n}\n\nasync function saveRawSnapshots(environment, snapshots) {\n\tawait Promise.all(snapshots.map(async (snap) => {\n\t\tif (!snap.readonly) {\n\t\t\tawait environment.saveSnapshotFile(snap.file, snap.snapshot);\n\t\t}\n\t}));\n}\n\nfunction getDefaultExportFromCjs(x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, \"default\") ? x[\"default\"] : x;\n}\n\nvar naturalCompare$1 = {exports: {}};\n\nvar hasRequiredNaturalCompare;\n\nfunction requireNaturalCompare () {\n\tif (hasRequiredNaturalCompare) return naturalCompare$1.exports;\n\thasRequiredNaturalCompare = 1;\n\t/*\n\t * @version    1.4.0\n\t * @date       2015-10-26\n\t * @stability  3 - Stable\n\t * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)\n\t * @license    MIT License\n\t */\n\n\n\tvar naturalCompare = function(a, b) {\n\t\tvar i, codeA\n\t\t, codeB = 1\n\t\t, posA = 0\n\t\t, posB = 0\n\t\t, alphabet = String.alphabet;\n\n\t\tfunction getCode(str, pos, code) {\n\t\t\tif (code) {\n\t\t\t\tfor (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;\n\t\t\t\treturn +str.slice(pos - 1, i)\n\t\t\t}\n\t\t\tcode = alphabet && alphabet.indexOf(str.charAt(pos));\n\t\t\treturn code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code\n\t\t\t\t: code < 46 ? 65               // -\n\t\t\t\t: code < 48 ? code - 1\n\t\t\t\t: code < 58 ? code + 18        // 0-9\n\t\t\t\t: code < 65 ? code - 11\n\t\t\t\t: code < 91 ? code + 11        // A-Z\n\t\t\t\t: code < 97 ? code - 37\n\t\t\t\t: code < 123 ? code + 5        // a-z\n\t\t\t\t: code - 63\n\t\t}\n\n\n\t\tif ((a+=\"\") != (b+=\"\")) for (;codeB;) {\n\t\t\tcodeA = getCode(a, posA++);\n\t\t\tcodeB = getCode(b, posB++);\n\n\t\t\tif (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {\n\t\t\t\tcodeA = getCode(a, posA, posA);\n\t\t\t\tcodeB = getCode(b, posB, posA = i);\n\t\t\t\tposB = i;\n\t\t\t}\n\n\t\t\tif (codeA != codeB) return (codeA < codeB) ? -1 : 1\n\t\t}\n\t\treturn 0\n\t};\n\n\ttry {\n\t\tnaturalCompare$1.exports = naturalCompare;\n\t} catch (e) {\n\t\tString.naturalCompare = naturalCompare;\n\t}\n\treturn naturalCompare$1.exports;\n}\n\nvar naturalCompareExports = requireNaturalCompare();\nvar naturalCompare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareExports);\n\nconst serialize$1 = (val, config, indentation, depth, refs, printer) => {\n\t// Serialize a non-default name, even if config.printFunctionName is false.\n\tconst name = val.getMockName();\n\tconst nameString = name === \"vi.fn()\" ? \"\" : ` ${name}`;\n\tlet callsString = \"\";\n\tif (val.mock.calls.length !== 0) {\n\t\tconst indentationNext = indentation + config.indent;\n\t\tcallsString = ` {${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}}`;\n\t}\n\treturn `[MockFunction${nameString}]${callsString}`;\n};\nconst test = (val) => val && !!val._isMockFunction;\nconst plugin = {\n\tserialize: serialize$1,\n\ttest\n};\n\nconst { DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent, AsymmetricMatcher } = plugins;\nlet PLUGINS = [\n\tReactTestComponent,\n\tReactElement,\n\tDOMElement,\n\tDOMCollection,\n\tImmutable,\n\tAsymmetricMatcher,\n\tplugin\n];\nfunction addSerializer(plugin) {\n\tPLUGINS = [plugin].concat(PLUGINS);\n}\nfunction getSerializers() {\n\treturn PLUGINS;\n}\n\n// TODO: rewrite and clean up\nfunction testNameToKey(testName, count) {\n\treturn `${testName} ${count}`;\n}\nfunction keyToTestName(key) {\n\tif (!/ \\d+$/.test(key)) {\n\t\tthrow new Error(\"Snapshot keys must end with a number.\");\n\t}\n\treturn key.replace(/ \\d+$/, \"\");\n}\nfunction getSnapshotData(content, options) {\n\tconst update = options.updateSnapshot;\n\tconst data = Object.create(null);\n\tlet snapshotContents = \"\";\n\tlet dirty = false;\n\tif (content != null) {\n\t\ttry {\n\t\t\tsnapshotContents = content;\n\t\t\t// eslint-disable-next-line no-new-func\n\t\t\tconst populate = new Function(\"exports\", snapshotContents);\n\t\t\tpopulate(data);\n\t\t} catch {}\n\t}\n\t// const validationResult = validateSnapshotVersion(snapshotContents)\n\tconst isInvalid = snapshotContents;\n\t// if (update === 'none' && isInvalid)\n\t//   throw validationResult\n\tif ((update === \"all\" || update === \"new\") && isInvalid) {\n\t\tdirty = true;\n\t}\n\treturn {\n\t\tdata,\n\t\tdirty\n\t};\n}\n// Add extra line breaks at beginning and end of multiline snapshot\n// to make the content easier to read.\nfunction addExtraLineBreaks(string) {\n\treturn string.includes(\"\\n\") ? `\\n${string}\\n` : string;\n}\n// Remove extra line breaks at beginning and end of multiline snapshot.\n// Instead of trim, which can remove additional newlines or spaces\n// at beginning or end of the content from a custom serializer.\nfunction removeExtraLineBreaks(string) {\n\treturn string.length > 2 && string[0] === \"\\n\" && string.endsWith(\"\\n\") ? string.slice(1, -1) : string;\n}\n// export const removeLinesBeforeExternalMatcherTrap = (stack: string): string => {\n//   const lines = stack.split('\\n')\n//   for (let i = 0; i < lines.length; i += 1) {\n//     // It's a function name specified in `packages/expect/src/index.ts`\n//     // for external custom matchers.\n//     if (lines[i].includes('__EXTERNAL_MATCHER_TRAP__'))\n//       return lines.slice(i + 1).join('\\n')\n//   }\n//   return stack\n// }\nconst escapeRegex = true;\nconst printFunctionName = false;\nfunction serialize(val, indent = 2, formatOverrides = {}) {\n\treturn normalizeNewlines(format(val, {\n\t\tescapeRegex,\n\t\tindent,\n\t\tplugins: getSerializers(),\n\t\tprintFunctionName,\n\t\t...formatOverrides\n\t}));\n}\nfunction escapeBacktickString(str) {\n\treturn str.replace(/`|\\\\|\\$\\{/g, \"\\\\$&\");\n}\nfunction printBacktickString(str) {\n\treturn `\\`${escapeBacktickString(str)}\\``;\n}\nfunction normalizeNewlines(string) {\n\treturn string.replace(/\\r\\n|\\r/g, \"\\n\");\n}\nasync function saveSnapshotFile(environment, snapshotData, snapshotPath) {\n\tconst snapshots = Object.keys(snapshotData).sort(naturalCompare).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);\n\tconst content = `${environment.getHeader()}\\n\\n${snapshots.join(\"\\n\\n\")}\\n`;\n\tconst oldContent = await environment.readSnapshotFile(snapshotPath);\n\tconst skipWriting = oldContent != null && oldContent === content;\n\tif (skipWriting) {\n\t\treturn;\n\t}\n\tawait environment.saveSnapshotFile(snapshotPath, content);\n}\nfunction deepMergeArray(target = [], source = []) {\n\tconst mergedOutput = Array.from(target);\n\tsource.forEach((sourceElement, index) => {\n\t\tconst targetElement = mergedOutput[index];\n\t\tif (Array.isArray(target[index])) {\n\t\t\tmergedOutput[index] = deepMergeArray(target[index], sourceElement);\n\t\t} else if (isObject(targetElement)) {\n\t\t\tmergedOutput[index] = deepMergeSnapshot(target[index], sourceElement);\n\t\t} else {\n\t\t\t// Source does not exist in target or target is primitive and cannot be deep merged\n\t\t\tmergedOutput[index] = sourceElement;\n\t\t}\n\t});\n\treturn mergedOutput;\n}\n/**\n* Deep merge, but considers asymmetric matchers. Unlike base util's deep merge,\n* will merge any object-like instance.\n* Compatible with Jest's snapshot matcher. Should not be used outside of snapshot.\n*\n* @example\n* ```ts\n* toMatchSnapshot({\n*   name: expect.stringContaining('text')\n* })\n* ```\n*/\nfunction deepMergeSnapshot(target, source) {\n\tif (isObject(target) && isObject(source)) {\n\t\tconst mergedOutput = { ...target };\n\t\tObject.keys(source).forEach((key) => {\n\t\t\tif (isObject(source[key]) && !source[key].$$typeof) {\n\t\t\t\tif (!(key in target)) {\n\t\t\t\t\tObject.assign(mergedOutput, { [key]: source[key] });\n\t\t\t\t} else {\n\t\t\t\t\tmergedOutput[key] = deepMergeSnapshot(target[key], source[key]);\n\t\t\t\t}\n\t\t\t} else if (Array.isArray(source[key])) {\n\t\t\t\tmergedOutput[key] = deepMergeArray(target[key], source[key]);\n\t\t\t} else {\n\t\t\t\tObject.assign(mergedOutput, { [key]: source[key] });\n\t\t\t}\n\t\t});\n\t\treturn mergedOutput;\n\t} else if (Array.isArray(target) && Array.isArray(source)) {\n\t\treturn deepMergeArray(target, source);\n\t}\n\treturn target;\n}\nclass DefaultMap extends Map {\n\tconstructor(defaultFn, entries) {\n\t\tsuper(entries);\n\t\tthis.defaultFn = defaultFn;\n\t}\n\tget(key) {\n\t\tif (!this.has(key)) {\n\t\t\tthis.set(key, this.defaultFn(key));\n\t\t}\n\t\treturn super.get(key);\n\t}\n}\nclass CounterMap extends DefaultMap {\n\tconstructor() {\n\t\tsuper(() => 0);\n\t}\n\t// compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322\n\t// `valueOf` and `Snapshot.added` setter allows\n\t//   snapshotState.added = snapshotState.added + 1\n\t// to function as\n\t//   snapshotState.added.total_ = snapshotState.added.total() + 1\n\t_total;\n\tvalueOf() {\n\t\treturn this._total = this.total();\n\t}\n\tincrement(key) {\n\t\tif (typeof this._total !== \"undefined\") {\n\t\t\tthis._total++;\n\t\t}\n\t\tthis.set(key, this.get(key) + 1);\n\t}\n\ttotal() {\n\t\tif (typeof this._total !== \"undefined\") {\n\t\t\treturn this._total;\n\t\t}\n\t\tlet total = 0;\n\t\tfor (const x of this.values()) {\n\t\t\ttotal += x;\n\t\t}\n\t\treturn total;\n\t}\n}\n\nfunction isSameStackPosition(x, y) {\n\treturn x.file === y.file && x.column === y.column && x.line === y.line;\n}\nclass SnapshotState {\n\t_counters = new CounterMap();\n\t_dirty;\n\t_updateSnapshot;\n\t_snapshotData;\n\t_initialData;\n\t_inlineSnapshots;\n\t_inlineSnapshotStacks;\n\t_testIdToKeys = new DefaultMap(() => []);\n\t_rawSnapshots;\n\t_uncheckedKeys;\n\t_snapshotFormat;\n\t_environment;\n\t_fileExists;\n\texpand;\n\t// getter/setter for jest-image-snapshot compat\n\t// https://github.com/vitest-dev/vitest/issues/7322\n\t_added = new CounterMap();\n\t_matched = new CounterMap();\n\t_unmatched = new CounterMap();\n\t_updated = new CounterMap();\n\tget added() {\n\t\treturn this._added;\n\t}\n\tset added(value) {\n\t\tthis._added._total = value;\n\t}\n\tget matched() {\n\t\treturn this._matched;\n\t}\n\tset matched(value) {\n\t\tthis._matched._total = value;\n\t}\n\tget unmatched() {\n\t\treturn this._unmatched;\n\t}\n\tset unmatched(value) {\n\t\tthis._unmatched._total = value;\n\t}\n\tget updated() {\n\t\treturn this._updated;\n\t}\n\tset updated(value) {\n\t\tthis._updated._total = value;\n\t}\n\tconstructor(testFilePath, snapshotPath, snapshotContent, options) {\n\t\tthis.testFilePath = testFilePath;\n\t\tthis.snapshotPath = snapshotPath;\n\t\tconst { data, dirty } = getSnapshotData(snapshotContent, options);\n\t\tthis._fileExists = snapshotContent != null;\n\t\tthis._initialData = { ...data };\n\t\tthis._snapshotData = { ...data };\n\t\tthis._dirty = dirty;\n\t\tthis._inlineSnapshots = [];\n\t\tthis._inlineSnapshotStacks = [];\n\t\tthis._rawSnapshots = [];\n\t\tthis._uncheckedKeys = new Set(Object.keys(this._snapshotData));\n\t\tthis.expand = options.expand || false;\n\t\tthis._updateSnapshot = options.updateSnapshot;\n\t\tthis._snapshotFormat = {\n\t\t\tprintBasicPrototype: false,\n\t\t\tescapeString: false,\n\t\t\t...options.snapshotFormat\n\t\t};\n\t\tthis._environment = options.snapshotEnvironment;\n\t}\n\tstatic async create(testFilePath, options) {\n\t\tconst snapshotPath = await options.snapshotEnvironment.resolvePath(testFilePath);\n\t\tconst content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);\n\t\treturn new SnapshotState(testFilePath, snapshotPath, content, options);\n\t}\n\tget environment() {\n\t\treturn this._environment;\n\t}\n\tmarkSnapshotsAsCheckedForTest(testName) {\n\t\tthis._uncheckedKeys.forEach((uncheckedKey) => {\n\t\t\t// skip snapshots with following keys\n\t\t\t//   testName n\n\t\t\t//   testName > xxx n (this is for toMatchSnapshot(\"xxx\") API)\n\t\t\tif (/ \\d+$| > /.test(uncheckedKey.slice(testName.length))) {\n\t\t\t\tthis._uncheckedKeys.delete(uncheckedKey);\n\t\t\t}\n\t\t});\n\t}\n\tclearTest(testId) {\n\t\t// clear inline\n\t\tthis._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);\n\t\tthis._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);\n\t\t// clear file\n\t\tfor (const key of this._testIdToKeys.get(testId)) {\n\t\t\tconst name = keyToTestName(key);\n\t\t\tconst count = this._counters.get(name);\n\t\t\tif (count > 0) {\n\t\t\t\tif (key in this._snapshotData || key in this._initialData) {\n\t\t\t\t\tthis._snapshotData[key] = this._initialData[key];\n\t\t\t\t}\n\t\t\t\tthis._counters.set(name, count - 1);\n\t\t\t}\n\t\t}\n\t\tthis._testIdToKeys.delete(testId);\n\t\t// clear stats\n\t\tthis.added.delete(testId);\n\t\tthis.updated.delete(testId);\n\t\tthis.matched.delete(testId);\n\t\tthis.unmatched.delete(testId);\n\t}\n\t_inferInlineSnapshotStack(stacks) {\n\t\t// if called inside resolves/rejects, stacktrace is different\n\t\tconst promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));\n\t\tif (promiseIndex !== -1) {\n\t\t\treturn stacks[promiseIndex + 3];\n\t\t}\n\t\t// inline snapshot function can be named __INLINE_SNAPSHOT_OFFSET_<n>__\n\t\t// to specify a custom stack offset\n\t\tfor (let i = 0; i < stacks.length; i++) {\n\t\t\tconst match = stacks[i].method.match(/__INLINE_SNAPSHOT_OFFSET_(\\d+)__/);\n\t\t\tif (match) {\n\t\t\t\treturn stacks[i + Number(match[1])] ?? null;\n\t\t\t}\n\t\t}\n\t\t// inline snapshot function is called __INLINE_SNAPSHOT__\n\t\t// in integrations/snapshot/chai.ts\n\t\tconst stackIndex = stacks.findIndex((i) => i.method.includes(\"__INLINE_SNAPSHOT__\"));\n\t\treturn stackIndex !== -1 ? stacks[stackIndex + 2] : null;\n\t}\n\t_addSnapshot(key, receivedSerialized, options) {\n\t\tthis._dirty = true;\n\t\tif (options.stack) {\n\t\t\tthis._inlineSnapshots.push({\n\t\t\t\tsnapshot: receivedSerialized,\n\t\t\t\ttestId: options.testId,\n\t\t\t\t...options.stack\n\t\t\t});\n\t\t} else if (options.rawSnapshot) {\n\t\t\tthis._rawSnapshots.push({\n\t\t\t\t...options.rawSnapshot,\n\t\t\t\tsnapshot: receivedSerialized\n\t\t\t});\n\t\t} else {\n\t\t\tthis._snapshotData[key] = receivedSerialized;\n\t\t}\n\t}\n\tasync save() {\n\t\tconst hasExternalSnapshots = Object.keys(this._snapshotData).length;\n\t\tconst hasInlineSnapshots = this._inlineSnapshots.length;\n\t\tconst hasRawSnapshots = this._rawSnapshots.length;\n\t\tconst isEmpty = !hasExternalSnapshots && !hasInlineSnapshots && !hasRawSnapshots;\n\t\tconst status = {\n\t\t\tdeleted: false,\n\t\t\tsaved: false\n\t\t};\n\t\tif ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {\n\t\t\tif (hasExternalSnapshots) {\n\t\t\t\tawait saveSnapshotFile(this._environment, this._snapshotData, this.snapshotPath);\n\t\t\t\tthis._fileExists = true;\n\t\t\t}\n\t\t\tif (hasInlineSnapshots) {\n\t\t\t\tawait saveInlineSnapshots(this._environment, this._inlineSnapshots);\n\t\t\t}\n\t\t\tif (hasRawSnapshots) {\n\t\t\t\tawait saveRawSnapshots(this._environment, this._rawSnapshots);\n\t\t\t}\n\t\t\tstatus.saved = true;\n\t\t} else if (!hasExternalSnapshots && this._fileExists) {\n\t\t\tif (this._updateSnapshot === \"all\") {\n\t\t\t\tawait this._environment.removeSnapshotFile(this.snapshotPath);\n\t\t\t\tthis._fileExists = false;\n\t\t\t}\n\t\t\tstatus.deleted = true;\n\t\t}\n\t\treturn status;\n\t}\n\tgetUncheckedCount() {\n\t\treturn this._uncheckedKeys.size || 0;\n\t}\n\tgetUncheckedKeys() {\n\t\treturn Array.from(this._uncheckedKeys);\n\t}\n\tremoveUncheckedKeys() {\n\t\tif (this._updateSnapshot === \"all\" && this._uncheckedKeys.size) {\n\t\t\tthis._dirty = true;\n\t\t\tthis._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);\n\t\t\tthis._uncheckedKeys.clear();\n\t\t}\n\t}\n\tmatch({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }) {\n\t\t// this also increments counter for inline snapshots. maybe we shouldn't?\n\t\tthis._counters.increment(testName);\n\t\tconst count = this._counters.get(testName);\n\t\tif (!key) {\n\t\t\tkey = testNameToKey(testName, count);\n\t\t}\n\t\tthis._testIdToKeys.get(testId).push(key);\n\t\t// Do not mark the snapshot as \"checked\" if the snapshot is inline and\n\t\t// there's an external snapshot. This way the external snapshot can be\n\t\t// removed with `--updateSnapshot`.\n\t\tif (!(isInline && this._snapshotData[key] !== undefined)) {\n\t\t\tthis._uncheckedKeys.delete(key);\n\t\t}\n\t\tlet receivedSerialized = rawSnapshot && typeof received === \"string\" ? received : serialize(received, undefined, this._snapshotFormat);\n\t\tif (!rawSnapshot) {\n\t\t\treceivedSerialized = addExtraLineBreaks(receivedSerialized);\n\t\t}\n\t\tif (rawSnapshot) {\n\t\t\t// normalize EOL when snapshot contains CRLF but received is LF\n\t\t\tif (rawSnapshot.content && rawSnapshot.content.match(/\\r\\n/) && !receivedSerialized.match(/\\r\\n/)) {\n\t\t\t\trawSnapshot.content = normalizeNewlines(rawSnapshot.content);\n\t\t\t}\n\t\t}\n\t\tconst expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];\n\t\tconst expectedTrimmed = rawSnapshot ? expected : expected?.trim();\n\t\tconst pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : receivedSerialized.trim());\n\t\tconst hasSnapshot = expected !== undefined;\n\t\tconst snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;\n\t\tif (pass && !isInline && !rawSnapshot) {\n\t\t\t// Executing a snapshot file as JavaScript and writing the strings back\n\t\t\t// when other snapshots have changed loses the proper escaping for some\n\t\t\t// characters. Since we check every snapshot in every test, use the newly\n\t\t\t// generated formatted string.\n\t\t\t// Note that this is only relevant when a snapshot is added and the dirty\n\t\t\t// flag is set.\n\t\t\tthis._snapshotData[key] = receivedSerialized;\n\t\t}\n\t\t// find call site of toMatchInlineSnapshot\n\t\tlet stack;\n\t\tif (isInline) {\n\t\t\tconst stacks = parseErrorStacktrace(error || new Error(\"snapshot\"), { ignoreStackEntries: [] });\n\t\t\tconst _stack = this._inferInlineSnapshotStack(stacks);\n\t\t\tif (!_stack) {\n\t\t\t\tthrow new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\\n${JSON.stringify(stacks)}`);\n\t\t\t}\n\t\t\tstack = this.environment.processStackTrace?.(_stack) || _stack;\n\t\t\t// removing 1 column, because source map points to the wrong\n\t\t\t// location for js files, but `column-1` points to the same in both js/ts\n\t\t\t// https://github.com/vitejs/vite/issues/8657\n\t\t\tstack.column--;\n\t\t\t// reject multiple inline snapshots at the same location if snapshot is different\n\t\t\tconst snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));\n\t\t\tif (snapshotsWithSameStack.length > 0) {\n\t\t\t\t// ensure only one snapshot will be written at the same location\n\t\t\t\tthis._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));\n\t\t\t\tconst differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== receivedSerialized);\n\t\t\t\tif (differentSnapshot) {\n\t\t\t\t\tthrow Object.assign(new Error(\"toMatchInlineSnapshot with different snapshots cannot be called at the same location\"), {\n\t\t\t\t\t\tactual: receivedSerialized,\n\t\t\t\t\t\texpected: differentSnapshot.snapshot\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._inlineSnapshotStacks.push({\n\t\t\t\t...stack,\n\t\t\t\ttestId,\n\t\t\t\tsnapshot: receivedSerialized\n\t\t\t});\n\t\t}\n\t\t// These are the conditions on when to write snapshots:\n\t\t//  * There's no snapshot file in a non-CI environment.\n\t\t//  * There is a snapshot file and we decided to update the snapshot.\n\t\t//  * There is a snapshot file, but it doesn't have this snapshot.\n\t\t// These are the conditions on when not to write snapshots:\n\t\t//  * The update flag is set to 'none'.\n\t\t//  * There's no snapshot file or a file without this snapshot on a CI environment.\n\t\tif (hasSnapshot && this._updateSnapshot === \"all\" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === \"new\" || this._updateSnapshot === \"all\")) {\n\t\t\tif (this._updateSnapshot === \"all\") {\n\t\t\t\tif (!pass) {\n\t\t\t\t\tif (hasSnapshot) {\n\t\t\t\t\t\tthis.updated.increment(testId);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.added.increment(testId);\n\t\t\t\t\t}\n\t\t\t\t\tthis._addSnapshot(key, receivedSerialized, {\n\t\t\t\t\t\tstack,\n\t\t\t\t\t\ttestId,\n\t\t\t\t\t\trawSnapshot\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tthis.matched.increment(testId);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._addSnapshot(key, receivedSerialized, {\n\t\t\t\t\tstack,\n\t\t\t\t\ttestId,\n\t\t\t\t\trawSnapshot\n\t\t\t\t});\n\t\t\t\tthis.added.increment(testId);\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tactual: \"\",\n\t\t\t\tcount,\n\t\t\t\texpected: \"\",\n\t\t\t\tkey,\n\t\t\t\tpass: true\n\t\t\t};\n\t\t} else {\n\t\t\tif (!pass) {\n\t\t\t\tthis.unmatched.increment(testId);\n\t\t\t\treturn {\n\t\t\t\t\tactual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),\n\t\t\t\t\tcount,\n\t\t\t\t\texpected: expectedTrimmed !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,\n\t\t\t\t\tkey,\n\t\t\t\t\tpass: false\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\tthis.matched.increment(testId);\n\t\t\t\treturn {\n\t\t\t\t\tactual: \"\",\n\t\t\t\t\tcount,\n\t\t\t\t\texpected: \"\",\n\t\t\t\t\tkey,\n\t\t\t\t\tpass: true\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n\tasync pack() {\n\t\tconst snapshot = {\n\t\t\tfilepath: this.testFilePath,\n\t\t\tadded: 0,\n\t\t\tfileDeleted: false,\n\t\t\tmatched: 0,\n\t\t\tunchecked: 0,\n\t\t\tuncheckedKeys: [],\n\t\t\tunmatched: 0,\n\t\t\tupdated: 0\n\t\t};\n\t\tconst uncheckedCount = this.getUncheckedCount();\n\t\tconst uncheckedKeys = this.getUncheckedKeys();\n\t\tif (uncheckedCount) {\n\t\t\tthis.removeUncheckedKeys();\n\t\t}\n\t\tconst status = await this.save();\n\t\tsnapshot.fileDeleted = status.deleted;\n\t\tsnapshot.added = this.added.total();\n\t\tsnapshot.matched = this.matched.total();\n\t\tsnapshot.unmatched = this.unmatched.total();\n\t\tsnapshot.updated = this.updated.total();\n\t\tsnapshot.unchecked = !status.deleted ? uncheckedCount : 0;\n\t\tsnapshot.uncheckedKeys = Array.from(uncheckedKeys);\n\t\treturn snapshot;\n\t}\n}\n\nfunction createMismatchError(message, expand, actual, expected) {\n\tconst error = new Error(message);\n\tObject.defineProperty(error, \"actual\", {\n\t\tvalue: actual,\n\t\tenumerable: true,\n\t\tconfigurable: true,\n\t\twritable: true\n\t});\n\tObject.defineProperty(error, \"expected\", {\n\t\tvalue: expected,\n\t\tenumerable: true,\n\t\tconfigurable: true,\n\t\twritable: true\n\t});\n\tObject.defineProperty(error, \"diffOptions\", { value: { expand } });\n\treturn error;\n}\nclass SnapshotClient {\n\tsnapshotStateMap = new Map();\n\tconstructor(options = {}) {\n\t\tthis.options = options;\n\t}\n\tasync setup(filepath, options) {\n\t\tif (this.snapshotStateMap.has(filepath)) {\n\t\t\treturn;\n\t\t}\n\t\tthis.snapshotStateMap.set(filepath, await SnapshotState.create(filepath, options));\n\t}\n\tasync finish(filepath) {\n\t\tconst state = this.getSnapshotState(filepath);\n\t\tconst result = await state.pack();\n\t\tthis.snapshotStateMap.delete(filepath);\n\t\treturn result;\n\t}\n\tskipTest(filepath, testName) {\n\t\tconst state = this.getSnapshotState(filepath);\n\t\tstate.markSnapshotsAsCheckedForTest(testName);\n\t}\n\tclearTest(filepath, testId) {\n\t\tconst state = this.getSnapshotState(filepath);\n\t\tstate.clearTest(testId);\n\t}\n\tgetSnapshotState(filepath) {\n\t\tconst state = this.snapshotStateMap.get(filepath);\n\t\tif (!state) {\n\t\t\tthrow new Error(`The snapshot state for '${filepath}' is not found. Did you call 'SnapshotClient.setup()'?`);\n\t\t}\n\t\treturn state;\n\t}\n\tassert(options) {\n\t\tconst { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot } = options;\n\t\tlet { received } = options;\n\t\tif (!filepath) {\n\t\t\tthrow new Error(\"Snapshot cannot be used outside of test\");\n\t\t}\n\t\tconst snapshotState = this.getSnapshotState(filepath);\n\t\tif (typeof properties === \"object\") {\n\t\t\tif (typeof received !== \"object\" || !received) {\n\t\t\t\tthrow new Error(\"Received value must be an object when the matcher has properties\");\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst pass = this.options.isEqual?.(received, properties) ?? false;\n\t\t\t\t// const pass = equals(received, properties, [iterableEquality, subsetEquality])\n\t\t\t\tif (!pass) {\n\t\t\t\t\tthrow createMismatchError(\"Snapshot properties mismatched\", snapshotState.expand, received, properties);\n\t\t\t\t} else {\n\t\t\t\t\treceived = deepMergeSnapshot(received, properties);\n\t\t\t\t}\n\t\t\t} catch (err) {\n\t\t\t\terr.message = errorMessage || \"Snapshot mismatched\";\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\t\tconst testName = [name, ...message ? [message] : []].join(\" > \");\n\t\tconst { actual, expected, key, pass } = snapshotState.match({\n\t\t\ttestId,\n\t\t\ttestName,\n\t\t\treceived,\n\t\t\tisInline,\n\t\t\terror,\n\t\t\tinlineSnapshot,\n\t\t\trawSnapshot\n\t\t});\n\t\tif (!pass) {\n\t\t\tthrow createMismatchError(`Snapshot \\`${key || \"unknown\"}\\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual?.trim(), rawSnapshot ? expected : expected?.trim());\n\t\t}\n\t}\n\tasync assertRaw(options) {\n\t\tif (!options.rawSnapshot) {\n\t\t\tthrow new Error(\"Raw snapshot is required\");\n\t\t}\n\t\tconst { filepath, rawSnapshot } = options;\n\t\tif (rawSnapshot.content == null) {\n\t\t\tif (!filepath) {\n\t\t\t\tthrow new Error(\"Snapshot cannot be used outside of test\");\n\t\t\t}\n\t\t\tconst snapshotState = this.getSnapshotState(filepath);\n\t\t\t// save the filepath, so it don't lose even if the await make it out-of-context\n\t\t\toptions.filepath ||= filepath;\n\t\t\t// resolve and read the raw snapshot file\n\t\t\trawSnapshot.file = await snapshotState.environment.resolveRawPath(filepath, rawSnapshot.file);\n\t\t\trawSnapshot.content = await snapshotState.environment.readSnapshotFile(rawSnapshot.file) ?? undefined;\n\t\t}\n\t\treturn this.assert(options);\n\t}\n\tclear() {\n\t\tthis.snapshotStateMap.clear();\n\t}\n}\n\nexport { SnapshotClient, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };\n"],"x_google_ignoreList":[0],"mappings":"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"}