@antdv-next/x-sdk 0.0.1 → 0.0.2

package/dist/node_modules/vitest/dist/@vitest/utils/helpers.js

@@ -0,0 +1,179 @@
+//#region ../../node_modules/vitest/dist/@vitest/utils/helpers.js
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
+function createSimpleStackTrace(options) {
+	const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+	const limit = Error.stackTraceLimit;
+	const prepareStackTrace = Error.prepareStackTrace;
+	Error.stackTraceLimit = stackTraceLimit;
+	Error.prepareStackTrace = (e) => e.stack;
+	const stackTrace = new Error(message).stack || "";
+	Error.prepareStackTrace = prepareStackTrace;
+	Error.stackTraceLimit = limit;
+	return stackTrace;
+}
+function notNullish(v) {
+	return v != null;
+}
+function assertTypes(value, name, types) {
+	const receivedType = typeof value;
+	if (!types.includes(receivedType)) throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function filterOutComments(s) {
+	const result = [];
+	let commentState = "none";
+	for (let i = 0; i < s.length; ++i) if (commentState === "singleline") {
+		if (s[i] === "\n") commentState = "none";
+	} else if (commentState === "multiline") {
+		if (s[i - 1] === "*" && s[i] === "/") commentState = "none";
+	} else if (commentState === "none") if (s[i] === "/" && s[i + 1] === "/") commentState = "singleline";
+	else if (s[i] === "/" && s[i + 1] === "*") {
+		commentState = "multiline";
+		i += 2;
+	} else result.push(s[i]);
+	return result.join("");
+}
+function toArray(array) {
+	if (array === null || array === void 0) array = [];
+	if (Array.isArray(array)) return array;
+	return [array];
+}
+function isObject(item) {
+	return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+	return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+	return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+	const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+	Object.getOwnPropertyNames(obj).forEach(collect);
+	Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+	const ownProps = /* @__PURE__ */ new Set();
+	if (isFinalObj(obj)) return [];
+	collectOwnProperties(obj, ownProps);
+	return Array.from(ownProps);
+}
+var defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+	return clone(val, /* @__PURE__ */ new WeakMap(), options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+	let k, out;
+	if (seen.has(val)) return seen.get(val);
+	if (Array.isArray(val)) {
+		out = Array.from({ length: k = val.length });
+		seen.set(val, out);
+		while (k--) out[k] = clone(val[k], seen, options);
+		return out;
+	}
+	if (Object.prototype.toString.call(val) === "[object Object]") {
+		out = Object.create(Object.getPrototypeOf(val));
+		seen.set(val, out);
+		const props = getOwnProperties(val);
+		for (const k of props) {
+			const descriptor = Object.getOwnPropertyDescriptor(val, k);
+			if (!descriptor) continue;
+			const cloned = clone(val[k], seen, options);
+			if (options.forceWritable) Object.defineProperty(out, k, {
+				enumerable: descriptor.enumerable,
+				configurable: true,
+				writable: true,
+				value: cloned
+			});
+			else if ("get" in descriptor) Object.defineProperty(out, k, {
+				...descriptor,
+				get() {
+					return cloned;
+				}
+			});
+			else Object.defineProperty(out, k, {
+				...descriptor,
+				value: cloned
+			});
+		}
+		return out;
+	}
+	return val;
+}
+function noop() {}
+function objectAttr(source, path, defaultValue = void 0) {
+	const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+	let result = source;
+	for (const p of paths) {
+		result = new Object(result)[p];
+		if (result === void 0) return defaultValue;
+	}
+	return result;
+}
+function createDefer() {
+	let resolve = null;
+	let reject = null;
+	const p = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	p.resolve = resolve;
+	p.reject = reject;
+	return p;
+}
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
+function getCallLastIndex(code) {
+	let charIndex = -1;
+	let inString = null;
+	let startedBracers = 0;
+	let endedBracers = 0;
+	let beforeChar = null;
+	while (charIndex <= code.length) {
+		beforeChar = code[charIndex];
+		charIndex++;
+		const char = code[charIndex];
+		if ((char === "\"" || char === "'" || char === "`") && beforeChar !== "\\") {
+			if (inString === char) inString = null;
+			else if (!inString) inString = char;
+		}
+		if (!inString) {
+			if (char === "(") startedBracers++;
+			if (char === ")") endedBracers++;
+		}
+		if (startedBracers && endedBracers && startedBracers === endedBracers) return charIndex;
+	}
+	return null;
+}
+function isNegativeNaN(val) {
+	if (!Number.isNaN(val)) return false;
+	const f64 = new Float64Array(1);
+	f64[0] = val;
+	return new Uint32Array(f64.buffer)[1] >>> 31 === 1;
+}
+function ordinal(i) {
+	const j = i % 10;
+	const k = i % 100;
+	if (j === 1 && k !== 11) return `${i}st`;
+	if (j === 2 && k !== 12) return `${i}nd`;
+	if (j === 3 && k !== 13) return `${i}rd`;
+	return `${i}th`;
+}
+function unique(array) {
+	return Array.from(new Set(array));
+}
+//#endregion
+export { assertTypes, createDefer, createSimpleStackTrace, deepClone, filterOutComments, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, ordinal, toArray, unique };

package/dist/node_modules/vitest/dist/@vitest/utils/offset.js

@@ -0,0 +1,25 @@
+//#region ../../node_modules/vitest/dist/@vitest/utils/offset.js
+var lineSplitRE = /\r?\n/;
+function positionToOffset(source, lineNumber, columnNumber) {
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let start = 0;
+	if (lineNumber > lines.length) return source.length;
+	for (let i = 0; i < lineNumber - 1; i++) start += lines[i].length + nl;
+	return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+	if (offset > source.length) throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let counted = 0;
+	let line = 0;
+	for (; line < lines.length; line++) {
+		const lineLength = lines[line].length + nl;
+		if (counted + lineLength >= offset) break;
+		counted += lineLength;
+	}
+	return line + 1;
+}
+//#endregion
+export { lineSplitRE, offsetToLineNumber, positionToOffset };

package/dist/node_modules/vitest/dist/@vitest/utils/serialize.js

@@ -0,0 +1,75 @@
+//#region ../../node_modules/vitest/dist/@vitest/utils/serialize.js
+var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+	return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+var OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+	if (err instanceof Error) return `<unserializable>: ${err.message}`;
+	if (typeof err === "string") return `<unserializable>: ${err}`;
+	return "<unserializable>";
+}
+function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
+	if (!val || typeof val === "string") return val;
+	if (val instanceof Error && "toJSON" in val && typeof val.toJSON === "function") {
+		const jsonValue = val.toJSON();
+		if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
+			if (typeof val.message === "string") safe(() => jsonValue.message ??= normalizeErrorMessage(val.message));
+			if (typeof val.stack === "string") safe(() => jsonValue.stack ??= val.stack);
+			if (typeof val.name === "string") safe(() => jsonValue.name ??= val.name);
+			if (val.cause != null) safe(() => jsonValue.cause ??= serializeValue(val.cause, seen));
+		}
+		return serializeValue(jsonValue, seen);
+	}
+	if (typeof val === "function") return `Function<${val.name || "anonymous"}>`;
+	if (typeof val === "symbol") return val.toString();
+	if (typeof val !== "object") return val;
+	if (typeof Buffer !== "undefined" && val instanceof Buffer) return `<Buffer(${val.length}) ...>`;
+	if (typeof Uint8Array !== "undefined" && val instanceof Uint8Array) return `<Uint8Array(${val.length}) ...>`;
+	if (isImmutable(val)) return serializeValue(val.toJSON(), seen);
+	if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") return "Promise";
+	if (typeof Element !== "undefined" && val instanceof Element) return val.tagName;
+	if (typeof val.toJSON === "function") return serializeValue(val.toJSON(), seen);
+	if (seen.has(val)) return seen.get(val);
+	if (Array.isArray(val)) {
+		const clone = new Array(val.length);
+		seen.set(val, clone);
+		val.forEach((e, i) => {
+			try {
+				clone[i] = serializeValue(e, seen);
+			} catch (err) {
+				clone[i] = getUnserializableMessage(err);
+			}
+		});
+		return clone;
+	} else {
+		const clone = Object.create(null);
+		seen.set(val, clone);
+		let obj = val;
+		while (obj && obj !== OBJECT_PROTO) {
+			Object.getOwnPropertyNames(obj).forEach((key) => {
+				if (key in clone) return;
+				try {
+					clone[key] = serializeValue(val[key], seen);
+				} catch (err) {
+					delete clone[key];
+					clone[key] = getUnserializableMessage(err);
+				}
+			});
+			obj = Object.getPrototypeOf(obj);
+		}
+		if (val instanceof Error) safe(() => clone.message = normalizeErrorMessage(val.message));
+		return clone;
+	}
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {}
+}
+function normalizeErrorMessage(message) {
+	return message.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/getByTestId('__vitest_\d+__')/g, "page");
+}
+//#endregion
+export { serializeValue };

package/dist/node_modules/vitest/dist/@vitest/utils/source-map.js

@@ -0,0 +1,371 @@
+import { isPrimitive, notNullish } from "./helpers.js";
+import { resolve } from "./chunk-pathe.M-eThtNZ.js";
+//#region ../../node_modules/vitest/dist/@vitest/utils/source-map.js
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[0] - b[0];
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+var CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+var SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+var stackIgnorePatterns = [
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinyspy/",
+	"/vite/dist/node/module-runner",
+	"/rolldown-vite/dist/node/module-runner",
+	"/deps/chunk-",
+	"/deps/@vitest",
+	"/deps/loupe",
+	"/deps/chai",
+	"/browser-playwright/dist/locators.js",
+	"/browser-webdriverio/dist/locators.js",
+	"/browser-preview/dist/locators.js",
+	/node:\w+/,
+	/__vitest_test__/,
+	/__vitest_browser__/,
+	"/@id/__x00__vitest/browser",
+	/\/deps\/vitest_/
+];
+var NOW_LENGTH = Date.now().toString().length;
+var REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
+function extractLocation(urlLike) {
+	if (!urlLike.includes(":")) return [urlLike];
+	const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) return [urlLike];
+	let url = parts[1];
+	if (url.startsWith("async ")) url = url.slice(6);
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = urlObj.pathname + urlObj.hash + urlObj.search;
+	}
+	if (url.startsWith("/@fs/")) {
+		const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+		url = url.slice(isWindows ? 5 : 4);
+	}
+	if (url.includes("vitest=")) url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+	return [
+		url,
+		parts[2] || void 0,
+		parts[3] || void 0
+	];
+}
+function parseSingleFFOrSafariStack(raw) {
+	let line = raw.trim();
+	if (SAFARI_NATIVE_CODE_REGEXP.test(line)) return null;
+	if (line.includes(" > eval")) line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+	if (!line.includes("@")) return null;
+	let atIndex = -1;
+	let locationPart = "";
+	let functionName;
+	for (let i = 0; i < line.length; i++) if (line[i] === "@") {
+		const candidateLocation = line.slice(i + 1);
+		if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+			atIndex = i;
+			locationPart = candidateLocation;
+			functionName = i > 0 ? line.slice(0, i) : void 0;
+			break;
+		}
+	}
+	if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) return null;
+	const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+	if (!url || !lineNumber || !columnNumber) return null;
+	return {
+		file: url,
+		method: functionName || "",
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function parseSingleStack(raw) {
+	const line = raw.trim();
+	if (!CHROME_IE_STACK_REGEXP.test(line)) return parseSingleFFOrSafariStack(line);
+	return parseSingleV8Stack(line);
+}
+function parseSingleV8Stack(raw) {
+	let line = raw.trim();
+	if (!CHROME_IE_STACK_REGEXP.test(line)) return null;
+	if (line.includes("(eval ")) line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+	let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+	const location = sanitizedLine.match(/ (\(.+\)$)/);
+	sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+	const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+	let method = location && sanitizedLine || "";
+	let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+	if (!file || !lineNumber || !columnNumber) return null;
+	if (method.startsWith("async ")) method = method.slice(6);
+	if (file.startsWith("file://")) file = file.slice(7);
+	file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
+	if (method) method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+	return {
+		method,
+		file,
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function parseStacktrace(stack, options = {}) {
+	const { ignoreStackEntries = stackIgnorePatterns } = options;
+	let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+	const helperIndex = stacks.findLastIndex((s) => s.method === "__VITEST_HELPER__" || s.method === "async*__VITEST_HELPER__");
+	if (helperIndex >= 0) stacks = stacks.slice(helperIndex + 1);
+	return stacks.map((stack) => {
+		if (options.getUrlId) stack.file = options.getUrlId(stack.file);
+		const map = options.getSourceMap?.(stack.file);
+		if (!map || typeof map !== "object" || !map.version) return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+		const position = getOriginalPosition(new DecodedMap(map, stack.file), stack);
+		if (!position) return stack;
+		const { line, column, source, name } = position;
+		let file = source || stack.file;
+		if (file.match(/\/\w:\//)) file = file.slice(1);
+		if (shouldFilter(ignoreStackEntries, file)) return null;
+		if (line != null && column != null) return {
+			line,
+			column,
+			file,
+			method: name || stack.method
+		};
+		return stack;
+	}).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+	return ignoreStackEntries.some((p) => file.match(p));
+}
+function parseFFOrSafariStackTrace(stack) {
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+	return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+function parseErrorStacktrace(e, options = {}) {
+	if (!e || isPrimitive(e)) return [];
+	if ("stacks" in e && e.stacks) return e.stacks;
+	const stackStr = e.stack || "";
+	let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
+	if (!stackFrames.length) {
+		const e_ = e;
+		if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+		if (e_.sourceURL != null && e_.line != null && e_._column != null) stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+	}
+	if (options.frameFilter) stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+	e.stacks = stackFrames;
+	return stackFrames;
+}
+var DecodedMap = class {
+	_encoded;
+	_decoded;
+	_decodedMemo;
+	url;
+	version;
+	names = [];
+	resolvedSources;
+	constructor(map, from) {
+		this.map = map;
+		const { mappings, names, sources } = map;
+		this.version = map.version;
+		this.names = names || [];
+		this._encoded = mappings || "";
+		this._decodedMemo = memoizedState();
+		this.url = from;
+		this.resolvedSources = (sources || []).map((s) => resolve(from, "..", s || ""));
+	}
+};
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function getOriginalPosition(map, needle) {
+	const result = originalPositionFor(map, needle);
+	if (result.column == null) return null;
+	return result;
+}
+//#endregion
+export { parseErrorStacktrace, parseSingleStack };

package/dist/node_modules/vitest/dist/@vitest/utils/timers.js

@@ -0,0 +1,35 @@
+//#region ../../node_modules/vitest/dist/@vitest/utils/timers.js
+var SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+	const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+	const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
+	return {
+		nextTick: safeNextTick,
+		setTimeout: safeSetTimeout,
+		setInterval: safeSetInterval,
+		clearInterval: safeClearInterval,
+		clearTimeout: safeClearTimeout,
+		setImmediate: safeSetImmediate,
+		clearImmediate: safeClearImmediate,
+		queueMicrotask: safeQueueMicrotask
+	};
+}
+/**
+* Returns a promise that resolves after the specified duration.
+*
+* @param timeout - Delay in milliseconds
+* @param scheduler - Timer function to use, defaults to `setTimeout`. Useful for mocked timers.
+*
+* @example
+* await delay(100)
+*
+* @example
+* // With mocked timers
+* const { setTimeout } = getSafeTimers()
+* await delay(100, setTimeout)
+*/
+function delay(timeout, scheduler = setTimeout) {
+	return new Promise((resolve) => scheduler(resolve, timeout));
+}
+//#endregion
+export { delay, getSafeTimers };

package/dist/node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js

@@ -0,0 +1,4 @@
+//#region ../../node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+//#endregion
+export { commonjsGlobal };