@antdv-next/x-sdk 0.0.2 → 0.0.4

package/dist/node_modules/{vitest/dist/@vitest/snapshot → .pnpm/@vitest_snapshot@4.1.10/node_modules/@vitest/snapshot/dist}/index.js

@@ -1,114 +1,8 @@
-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/vitest/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);
-	}));
-}
+import { format, plugins } from "../../../../../@vitest_pretty-format@4.1.10/node_modules/@vitest/pretty-format/dist/index.js";
+import { getCallLastIndex, isObject } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js";
+import { parseErrorStacktrace } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/source-map.js";
+import { lineSplitRE, offsetToLineNumber, positionToOffset } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/offset.js";
+//#region ../../node_modules/.pnpm/@vitest+snapshot@4.1.10/node_modules/@vitest/snapshot/dist/index.js
 function getDefaultExportFromCjs(x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -153,7 +47,7 @@ function requireNaturalCompare() {
 	}
 	return naturalCompare$1.exports;
 }
-var naturalCompare = /* @__PURE__ */ getDefaultExportFromCjs(requireNaturalCompare());
+var naturalCompare = /*@__PURE__*/ getDefaultExportFromCjs(requireNaturalCompare());
 var serialize$1 = (val, config, indentation, depth, refs, printer) => {
 	const name = val.getMockName();
 	const nameString = name === "vi.fn()" ? "" : ` ${name}`;
@@ -304,6 +198,127 @@ var CounterMap = class extends DefaultMap {
 		return total;
 	}
 };
+/* @__NO_SIDE_EFFECTS__ */
+function memo(fn) {
+	const cache = /* @__PURE__ */ new Map();
+	return (arg) => {
+		if (!cache.has(arg)) cache.set(arg, fn(arg));
+		return cache.get(arg);
+	};
+}
+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, snap.assertionName);
+		const transformed = s.toString();
+		if (transformed !== code) await environment.saveSnapshotFile(file, transformed);
+	}));
+}
+var defaultStartObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var buildStartObjectRegex = /* @__PURE__ */ memo((assertionName) => {
+	const replaced = defaultStartObjectRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceObjectSnap(code, s, index, newSnap, assertionName) {
+	let _code = code.slice(index);
+	const startMatch = (assertionName ? buildStartObjectRegex(assertionName) : defaultStartObjectRegex).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 defaultMethodNames = ["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"];
+function getCodeStartingAtIndex(code, index, methodNames) {
+	for (const name of methodNames) {
+		const adjusted = index - name.length;
+		if (adjusted >= 0 && code.slice(adjusted, index) === name) return {
+			code: code.slice(adjusted),
+			index: adjusted
+		};
+	}
+	return {
+		code: code.slice(index),
+		index
+	};
+}
+var defaultStartRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
+var buildStartRegex = /* @__PURE__ */ memo((assertionName) => {
+	const replaced = defaultStartRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceInlineSnap(code, s, currentIndex, newSnap, assertionName) {
+	const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex, assertionName ? [assertionName] : defaultMethodNames);
+	const startMatch = (assertionName ? buildStartRegex(assertionName) : defaultStartRegex).exec(codeStartingAtIndex);
+	const firstKeywordMatch = (assertionName ? new RegExp(escapeRegExp(assertionName)) : /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/).exec(codeStartingAtIndex);
+	if (!startMatch || startMatch.index !== firstKeywordMatch?.index) return replaceObjectSnap(code, s, index, newSnap, assertionName);
+	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 isSameStackPosition(x, y) {
 	return x.file === y.file && x.column === y.column && x.line === y.line;
 }
@@ -367,13 +382,18 @@ var SnapshotState = class SnapshotState {
 		this._snapshotFormat = {
 			printBasicPrototype: false,
 			escapeString: false,
+			maxOutputLength: 2 ** 27,
 			...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);
+		const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
+		return new SnapshotState(testFilePath, snapshotPath, content, options);
+	}
+	get snapshotUpdateState() {
+		return this._updateSnapshot;
 	}
 	get environment() {
 		return this._environment;
@@ -403,19 +423,24 @@ var SnapshotState = class SnapshotState {
 	_inferInlineSnapshotStack(stacks) {
 		const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
 		if (promiseIndex !== -1) return stacks[promiseIndex + 3];
+		const pollChainIndex = stacks.findIndex((i) => i.method.match(/__VITEST_POLL_CHAIN__/));
+		if (pollChainIndex !== -1) return stacks[pollChainIndex + 1];
 		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 customMatcherIndex = stacks.findIndex((i) => i.method.includes("__VITEST_EXTEND_ASSERTION__"));
+		if (customMatcherIndex !== -1) return stacks[customMatcherIndex + 3] ?? 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({
+			...options.stack,
 			snapshot: receivedSerialized,
 			testId: options.testId,
-			...options.stack
+			assertionName: options.assertionName
 		});
 		else if (options.rawSnapshot) this._rawSnapshots.push({
 			...options.rawSnapshot,
@@ -423,6 +448,90 @@ var SnapshotState = class SnapshotState {
 		});
 		else this._snapshotData[key] = receivedSerialized;
 	}
+	_resolveKey(testId, testName, key) {
+		this._counters.increment(testName);
+		const count = this._counters.get(testName);
+		if (!key) key = testNameToKey(testName, count);
+		this._testIdToKeys.get(testId).push(key);
+		return {
+			key,
+			count
+		};
+	}
+	_resolveInlineStack(options) {
+		const { testId, snapshot, assertionName, error } = options;
+		const stacks = parseErrorStacktrace(error, { ignoreStackEntries: [] });
+		const _stack = this._inferInlineSnapshotStack(stacks);
+		if (!_stack) {
+			const message = stacks.map((s) => `  ${s.file}:${s.line}:${s.column}${s.method ? ` (${s.method})` : ""}`).join("\n");
+			throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\n${message}`);
+		}
+		const 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 !== snapshot);
+			if (differentSnapshot) throw Object.assign(/* @__PURE__ */ new Error(`${assertionName} with different snapshots cannot be called at the same location`), {
+				actual: snapshot,
+				expected: differentSnapshot.snapshot
+			});
+		}
+		this._inlineSnapshotStacks.push({
+			...stack,
+			testId,
+			snapshot
+		});
+		return stack;
+	}
+	_reconcile(opts) {
+		if (opts.hasSnapshot && this._updateSnapshot === "all" || (!opts.hasSnapshot || !opts.snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+			if (this._updateSnapshot === "all") if (!opts.pass) {
+				if (opts.hasSnapshot) this.updated.increment(opts.testId);
+				else this.added.increment(opts.testId);
+				this._addSnapshot(opts.key, opts.addValue, {
+					stack: opts.stack,
+					testId: opts.testId,
+					rawSnapshot: opts.rawSnapshot,
+					assertionName: opts.assertionName
+				});
+			} else this.matched.increment(opts.testId);
+			else {
+				this._addSnapshot(opts.key, opts.addValue, {
+					stack: opts.stack,
+					testId: opts.testId,
+					rawSnapshot: opts.rawSnapshot,
+					assertionName: opts.assertionName
+				});
+				this.added.increment(opts.testId);
+			}
+			return {
+				actual: "",
+				count: opts.count,
+				expected: "",
+				key: opts.key,
+				pass: true
+			};
+		} else if (!opts.pass) {
+			this.unmatched.increment(opts.testId);
+			return {
+				actual: opts.actualDisplay,
+				count: opts.count,
+				expected: opts.expectedDisplay,
+				key: opts.key,
+				pass: false
+			};
+		} else {
+			this.matched.increment(opts.testId);
+			return {
+				actual: "",
+				count: opts.count,
+				expected: "",
+				key: opts.key,
+				pass: true
+			};
+		}
+	}
 	async save() {
 		const hasExternalSnapshots = Object.keys(this._snapshotData).length;
 		const hasInlineSnapshots = this._inlineSnapshots.length;
@@ -462,11 +571,24 @@ var SnapshotState = class SnapshotState {
 			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);
+	probeExpectedSnapshot(options) {
+		const count = this._counters.get(options.testName) + 1;
+		const key = testNameToKey(options.testName, count);
+		return {
+			key,
+			count,
+			data: options?.isInline ? options.inlineSnapshot : this._snapshotData[key],
+			markAsChecked: () => {
+				this._counters.increment(options.testName);
+				this._testIdToKeys.get(options.testId).push(key);
+				this._uncheckedKeys.delete(key);
+			}
+		};
+	}
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }) {
+		const resolved = this._resolveKey(testId, testName, key);
+		key = resolved.key;
+		const count = resolved.count;
 		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);
@@ -479,72 +601,49 @@ var SnapshotState = class SnapshotState {
 		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
-			};
-		}
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: receivedSerialized,
+			assertionName: assertionName || "toMatchInlineSnapshot",
+			error: error || /* @__PURE__ */ new Error("snapshot")
+		}) : void 0;
+		return this._reconcile({
+			testId,
+			key,
+			count,
+			pass,
+			hasSnapshot,
+			snapshotIsPersisted: !!snapshotIsPersisted,
+			addValue: receivedSerialized,
+			actualDisplay: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
+			expectedDisplay: expectedTrimmed !== void 0 ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : void 0,
+			stack,
+			rawSnapshot,
+			assertionName
+		});
+	}
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }) {
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: received,
+			assertionName,
+			error: error || /* @__PURE__ */ new Error("STACK_TRACE_ERROR")
+		}) : void 0;
+		const actualResolved = matchResult?.resolved ?? received;
+		const expectedResolved = matchResult?.expected ?? expectedSnapshot.data;
+		return this._reconcile({
+			testId,
+			key: expectedSnapshot.key,
+			count: expectedSnapshot.count,
+			pass: matchResult?.pass ?? false,
+			hasSnapshot: !!expectedSnapshot.data,
+			snapshotIsPersisted: isInline ? true : this._fileExists,
+			addValue: actualResolved,
+			actualDisplay: removeExtraLineBreaks(actualResolved),
+			expectedDisplay: expectedResolved !== void 0 ? removeExtraLineBreaks(expectedResolved) : void 0,
+			stack,
+			assertionName
+		});
 	}
 	async pack() {
 		const snapshot = {
@@ -613,22 +712,41 @@ var SnapshotClient = class {
 		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;
+	match(options) {
+		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot, assertionName } = options;
 		let { received } = options;
 		if (!filepath) throw new Error("Snapshot cannot be used outside of test");
 		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
 		if (typeof properties === "object") {
-			if (typeof received !== "object" || !received) throw new Error("Received value must be an object when the matcher has properties");
+			if (typeof received !== "object" || !received) {
+				expectedSnapshot.markAsChecked();
+				throw new Error("Received value must be an object when the matcher has properties");
+			}
+			let propertiesPass;
 			try {
-				if (!(this.options.isEqual?.(received, properties) ?? false)) throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, received, properties);
-				else received = deepMergeSnapshot(received, properties);
+				propertiesPass = this.options.isEqual?.(received, properties) ?? false;
 			} catch (err) {
-				err.message = errorMessage || "Snapshot mismatched";
+				expectedSnapshot.markAsChecked();
 				throw err;
 			}
+			if (!propertiesPass) {
+				expectedSnapshot.markAsChecked();
+				return {
+					pass: false,
+					message: () => errorMessage || "Snapshot properties mismatched",
+					actual: received,
+					expected: properties
+				};
+			}
+			received = deepMergeSnapshot(received, properties);
 		}
-		const testName = [name, ...message ? [message] : []].join(" > ");
 		const { actual, expected, key, pass } = snapshotState.match({
 			testId,
 			testName,
@@ -636,9 +754,97 @@ var SnapshotClient = class {
 			isInline,
 			error,
 			inlineSnapshot,
-			rawSnapshot
+			rawSnapshot,
+			assertionName
 		});
-		if (!pass) throw createMismatchError(`Snapshot \`${key || "unknown"}\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual?.trim(), rawSnapshot ? expected : expected?.trim());
+		return {
+			pass,
+			message: () => `Snapshot \`${key || "unknown"}\` mismatched`,
+			actual: rawSnapshot ? actual : actual?.trim(),
+			expected: rawSnapshot ? expected : expected?.trim()
+		};
+	}
+	assert(options) {
+		const result = this.match(options);
+		if (!result.pass) {
+			const snapshotState = this.getSnapshotState(options.filepath);
+			throw createMismatchError(result.message(), snapshotState.expand, result.actual, result.expected);
+		}
+	}
+	matchDomain(options) {
+		const { received, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error } = options;
+		if (!filepath) throw new Error("Snapshot cannot be used outside of test");
+		const captured = adapter.capture(received);
+		const rendered = adapter.render(captured);
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		expectedSnapshot.markAsChecked();
+		const matchResult = expectedSnapshot.data ? adapter.match(captured, adapter.parseExpected(expectedSnapshot.data)) : void 0;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
+	}
+	async pollMatchDomain(options) {
+		const { poll, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error, timeout = 1e3, interval = 50 } = options;
+		if (!filepath) throw new Error("Snapshot cannot be used outside of test");
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		const reference = expectedSnapshot.data && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : void 0;
+		const stableResult = await getStableSnapshot({
+			adapter,
+			poll,
+			interval,
+			timedOut: timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : void 0,
+			match: reference ? (captured) => adapter.match(captured, reference).pass : void 0
+		});
+		expectedSnapshot.markAsChecked();
+		if (!stableResult?.rendered) {
+			if (stableResult?.lastPollError) throw stableResult.lastPollError;
+			return {
+				pass: false,
+				message: () => `poll() did not produce a stable snapshot within the timeout`
+			};
+		}
+		const matchResult = expectedSnapshot.data ? adapter.match(stableResult.captured, adapter.parseExpected(expectedSnapshot.data)) : void 0;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: stableResult.rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
 	}
 	async assertRaw(options) {
 		if (!options.rawSnapshot) throw new Error("Raw snapshot is required");
@@ -656,5 +862,59 @@ var SnapshotClient = class {
 		this.snapshotStateMap.clear();
 	}
 };
+/**
+* Polls repeatedly until the value reaches a stable state.
+*
+* Compares consecutive rendered outputs from the current session —
+* when two consecutive polls produce the same rendered string,
+* the value is considered stable.
+*
+* Every `await` (poll call, interval delay) races against `timedOut`
+* so that hanging polls and delays are interrupted.
+*/
+async function getStableSnapshot({ adapter, poll, interval, timedOut, match }) {
+	let lastRendered;
+	let lastPollError;
+	let lastStable;
+	while (true) {
+		try {
+			const pollResult = await raceWith(Promise.resolve(poll()), timedOut);
+			if (!pollResult.ok) break;
+			const captured = adapter.capture(pollResult.value);
+			const rendered = adapter.render(captured);
+			if (lastRendered !== void 0 && rendered === lastRendered) {
+				lastStable = {
+					captured,
+					rendered
+				};
+				if (!match || match(captured)) break;
+			} else {
+				lastRendered = rendered;
+				lastStable = void 0;
+			}
+		} catch (pollError) {
+			lastRendered = void 0;
+			lastStable = void 0;
+			lastPollError = pollError;
+		}
+		if (!(await raceWith(new Promise((r) => setTimeout(r, interval)), timedOut)).ok) break;
+	}
+	return {
+		...lastStable,
+		lastPollError
+	};
+}
+/** Type-safe `Promise.race` — tells you which promise won. */
+function raceWith(promise, other) {
+	const left = promise.then((value) => ({
+		ok: true,
+		value
+	}));
+	if (!other) return left;
+	return Promise.race([left, other.then((value) => ({
+		ok: false,
+		value
+	}))]);
+}
 //#endregion
-export { SnapshotClient, addSerializer, stripSnapshotIndentation };
+export { SnapshotClient, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };