@antdv-next/x-sdk 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/snapshot/index.js

@@ -0,0 +1,661 @@
+import { format, plugins } from "../pretty-format/index.js";
+import { getCallLastIndex, isObject } from "../utils/helpers.js";
+import { parseErrorStacktrace } from "../utils/source-map.js";
+import { lineSplitRE, offsetToLineNumber, positionToOffset } from "../utils/offset.js";
+//#region ../../node_modules/.pnpm/@voidzero-dev+vite-plus-test@0.1.14_@types+node@24.12.0_@voidzero-dev+vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/snapshot/index.js
+async function saveInlineSnapshots(environment, snapshots) {
+	const MagicString = (await import("../../vendor/magic-string.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);
+	}));
+}
+var 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}`;
+}
+var toMatchInlineName = "toMatchInlineSnapshot";
+var 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
+	};
+}
+var 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;
+}
+var 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());
+var 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}`;
+};
+var test = (val) => val && !!val._isMockFunction;
+var plugin = {
+	serialize: serialize$1,
+	test
+};
+var { DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent, AsymmetricMatcher } = plugins;
+var 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;
+}
+var escapeRegex = true;
+var 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);
+		const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
+		return new SnapshotState(testFilePath, snapshotPath, content, options);
+	}
+	get environment() {
+		return this._environment;
+	}
+	markSnapshotsAsCheckedForTest(testName) {
+		this._uncheckedKeys.forEach((uncheckedKey) => {
+			if (/ \d+$| > /.test(uncheckedKey.slice(testName.length))) this._uncheckedKeys.delete(uncheckedKey);
+		});
+	}
+	clearTest(testId) {
+		this._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);
+		this._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);
+		for (const key of this._testIdToKeys.get(testId)) {
+			const name = keyToTestName(key);
+			const count = this._counters.get(name);
+			if (count > 0) {
+				if (key in this._snapshotData || key in this._initialData) this._snapshotData[key] = this._initialData[key];
+				this._counters.set(name, count - 1);
+			}
+		}
+		this._testIdToKeys.delete(testId);
+		this.added.delete(testId);
+		this.updated.delete(testId);
+		this.matched.delete(testId);
+		this.unmatched.delete(testId);
+	}
+	_inferInlineSnapshotStack(stacks) {
+		const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
+		if (promiseIndex !== -1) return stacks[promiseIndex + 3];
+		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, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };