@directus/api 34.0.1 → 35.0.0

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

@@ -0,0 +1,890 @@
+import { isPrimitive, notNullish } from "./helpers.js";
+
+//#region ../node_modules/.pnpm/@vitest+utils@3.2.4/node_modules/@vitest/utils/dist/source-map.js
+const comma = ",".charCodeAt(0);
+const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = new Uint8Array(64);
+const 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 {
+		const c = reader.next();
+		integer = charToInt[c];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) {
+		value = -2147483648 | -value;
+	}
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else {
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn
+					];
+				}
+			} else {
+				seg = [genColumn];
+			}
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var UrlType;
+(function(UrlType$1) {
+	UrlType$1[UrlType$1["Empty"] = 1] = "Empty";
+	UrlType$1[UrlType$1["Hash"] = 2] = "Hash";
+	UrlType$1[UrlType$1["Query"] = 3] = "Query";
+	UrlType$1[UrlType$1["RelativePath"] = 4] = "RelativePath";
+	UrlType$1[UrlType$1["AbsolutePath"] = 5] = "AbsolutePath";
+	UrlType$1[UrlType$1["SchemeRelative"] = 6] = "SchemeRelative";
+	UrlType$1[UrlType$1["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: UrlType.Absolute
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url$1 = parseAbsoluteUrl("http:" + input);
+		url$1.scheme = "";
+		url$1.type = UrlType.SchemeRelative;
+		return url$1;
+	}
+	if (isAbsolutePath(input)) {
+		const url$1 = parseAbsoluteUrl("http://foo.com" + input);
+		url$1.scheme = "";
+		url$1.host = "";
+		url$1.type = UrlType.AbsolutePath;
+		return url$1;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? UrlType.Query : input.startsWith("#") ? UrlType.Hash : UrlType.RelativePath : UrlType.Empty;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") {
+		url.path = base.path;
+	} else {
+		url.path = stripPathFilename(base.path) + url.path;
+	}
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= UrlType.RelativePath;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) {
+				pieces[pointer++] = piece;
+			}
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) {
+		path += "/" + pieces[i];
+	}
+	if (!path || addTrailingSlash && !path.endsWith("/..")) {
+		path += "/";
+	}
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve$2(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== UrlType.Absolute) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case UrlType.Empty: url.hash = baseUrl.hash;
+			case UrlType.Hash: url.query = baseUrl.query;
+			case UrlType.Query:
+			case UrlType.RelativePath: mergePaths(url, baseUrl);
+			case UrlType.AbsolutePath:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case UrlType.SchemeRelative: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case UrlType.Hash:
+		case UrlType.Query: return queryHash;
+		case UrlType.RelativePath: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) {
+				return "./" + path + queryHash;
+			}
+			return path + queryHash;
+		}
+		case UrlType.AbsolutePath: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+function resolve$1(input, base) {
+	if (base && !base.endsWith("/")) base += "/";
+	return resolve$2(input, base);
+}
+/**
+* Removes everything after the last "/", but leaves the slash.
+*/
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+const REV_GENERATED_LINE = 1;
+const REV_GENERATED_COLUMN = 2;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+		mappings[i] = sortSegments(mappings[i], owned);
+	}
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) {
+		if (!isSorted(mappings[i])) return i;
+	}
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) {
+		if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+			return false;
+		}
+	}
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN] - b[COLUMN];
+}
+let found = false;
+/**
+* A binary search implementation that returns the index if a match is found.
+* If no match is found, then the left-index (the index associated with the item that comes just
+* before the desired index) is returned. To maintain proper sort order, a splice would happen at
+* the next index:
+*
+* ```js
+* const array = [1, 3];
+* const needle = 2;
+* const index = binarySearch(array, needle, (item, needle) => item - needle);
+*
+* assert.equal(index, 0);
+* array.splice(index + 1, 0, needle);
+* assert.deepEqual(array, [1, 2, 3]);
+* ```
+*/
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) {
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) {
+		if (haystack[i][COLUMN] !== needle) break;
+	}
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) {
+		if (haystack[i][COLUMN] !== needle) break;
+	}
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+/**
+* This overly complicated beast is just to record the last tested line/column and the resulting
+* index, allowing us to skip a few tests if mappings are monotonically increasing.
+*/
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) {
+			low = lastIndex === -1 ? 0 : lastIndex;
+		} else {
+			high = lastIndex;
+		}
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function buildBySources(decoded, memos) {
+	const sources = memos.map(buildNullArray);
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		for (let j = 0; j < line.length; j++) {
+			const seg = line[j];
+			if (seg.length === 1) continue;
+			const sourceIndex = seg[SOURCES_INDEX];
+			const sourceLine = seg[SOURCE_LINE];
+			const sourceColumn = seg[SOURCE_COLUMN];
+			const originalSource = sources[sourceIndex];
+			const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
+			const memo = memos[sourceIndex];
+			let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+			memo.lastIndex = ++index;
+			insert(originalLine, index, [
+				sourceColumn,
+				i,
+				seg[COLUMN]
+			]);
+		}
+	}
+	return sources;
+}
+function insert(array, index, value) {
+	for (let i = array.length; i > index; i--) {
+		array[i] = array[i - 1];
+	}
+	array[index] = value;
+}
+function buildNullArray() {
+	return { __proto__: null };
+}
+const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = isString ? JSON.parse(map) : map;
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+		const from = resolve$1(sourceRoot || "", stripFilename(mapUrl));
+		this.resolvedSources = sources.map((s) => resolve$1(s || "", from));
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = undefined;
+		} else {
+			this._encoded = undefined;
+			this._decoded = maybeSort(mappings, isString);
+		}
+		this._decodedMemo = memoizedState();
+		this._bySources = undefined;
+		this._bySourceMemos = undefined;
+	}
+};
+/**
+* Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+* with public access modifiers.
+*/
+function cast(map) {
+	return map;
+}
+/**
+* Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+*/
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+/**
+* A higher-level API to find the source/line/column associated with a generated line/column
+* (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+* `source-map` library.
+*/
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+/**
+* Finds the generated line/column position of the provided source/line/column source position.
+*/
+function generatedPositionFor(map, needle) {
+	const { source, line, column, bias } = needle;
+	return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+/**
+* Iterates each mapping in generated position order.
+*/
+function eachMapping(map, cb) {
+	const decoded = decodedMappings(map);
+	const { names, resolvedSources } = map;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		for (let j = 0; j < line.length; j++) {
+			const seg = line[j];
+			const generatedLine = i + 1;
+			const generatedColumn = seg[0];
+			let source = null;
+			let originalLine = null;
+			let originalColumn = null;
+			let name = null;
+			if (seg.length !== 1) {
+				source = resolvedSources[seg[1]];
+				originalLine = seg[2] + 1;
+				originalColumn = seg[3];
+			}
+			if (seg.length === 5) name = names[seg[4]];
+			cb({
+				generatedLine,
+				generatedColumn,
+				source,
+				originalLine,
+				originalColumn,
+				name
+			});
+		}
+	}
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function GMapping(line, column) {
+	return {
+		line,
+		column
+	};
+}
+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;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+	var _a;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const { sources, resolvedSources } = map;
+	let sourceIndex = sources.indexOf(source);
+	if (sourceIndex === -1) sourceIndex = resolvedSources.indexOf(source);
+	if (sourceIndex === -1) return all ? [] : GMapping(null, null);
+	const generated = (_a = cast(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), cast(map)._bySourceMemos = sources.map(memoizedState)));
+	const segments = generated[sourceIndex][line];
+	if (segments == null) return all ? [] : GMapping(null, null);
+	const memo = cast(map)._bySourceMemos[sourceIndex];
+	const index = traceSegmentInternal(segments, memo, line, column, bias);
+	if (index === -1) return GMapping(null, null);
+	const segment = segments[index];
+	return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) {
+		return input;
+	}
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") {
+		return process.cwd().replace(/\\/g, "/");
+	}
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) {
+			continue;
+		}
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+		return `/${resolvedPath}`;
+	}
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) {
+			char = path[index];
+		} else if (char === "/") {
+			break;
+		} else {
+			char = "/";
+		}
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) {
+					res += `/${path.slice(lastSlash + 1, index)}`;
+				} else {
+					res = path.slice(lastSlash + 1, index);
+				}
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) {
+			++dots;
+		} else {
+			dots = -1;
+		}
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/vite-node/dist/",
+	"/vite-node/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinypool/",
+	"/node_modules/tinyspy/",
+	"/deps/chunk-",
+	"/deps/@vitest",
+	"/deps/loupe",
+	"/deps/chai",
+	/node:\w+/,
+	/__vitest_test__/,
+	/__vitest_browser__/,
+	/\/deps\/vitest_/
+];
+function extractLocation(urlLike) {
+	if (!urlLike.includes(":")) {
+		return [urlLike];
+	}
+	const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+	const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) {
+		return [urlLike];
+	}
+	let url = parts[1];
+	if (url.startsWith("async ")) {
+		url = url.slice(6);
+	}
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = urlObj.pathname + urlObj.hash + urlObj.search;
+	}
+	if (url.startsWith("/@fs/")) {
+		const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+		url = url.slice(isWindows ? 5 : 4);
+	}
+	return [
+		url,
+		parts[2] || undefined,
+		parts[3] || undefined
+	];
+}
+function parseSingleFFOrSafariStack(raw) {
+	let line = raw.trim();
+	if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+		return null;
+	}
+	if (line.includes(" > eval")) {
+		line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+	}
+	if (!line.includes("@") && !line.includes(":")) {
+		return null;
+	}
+	const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
+	const matches = line.match(functionNameRegex);
+	const functionName = matches && matches[1] ? matches[1] : undefined;
+	const [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
+	if (!url || !lineNumber || !columnNumber) {
+		return null;
+	}
+	return {
+		file: url,
+		method: functionName || "",
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function 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) ? undefined : 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(/__vite_ssr_import_\d+__\./g, "");
+	}
+	return {
+		method,
+		file,
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function createStackString(stacks) {
+	return stacks.map((stack) => {
+		const line = `${stack.file}:${stack.line}:${stack.column}`;
+		if (stack.method) {
+			return `    at ${stack.method}(${line})`;
+		}
+		return `    at ${line}`;
+	}).join("\n");
+}
+function parseStacktrace(stack, options = {}) {
+	const { ignoreStackEntries = stackIgnorePatterns } = options;
+	const stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+	return stacks.map((stack$1) => {
+		var _options$getSourceMap;
+		if (options.getUrlId) {
+			stack$1.file = options.getUrlId(stack$1.file);
+		}
+		const map = (_options$getSourceMap = options.getSourceMap) === null || _options$getSourceMap === void 0 ? void 0 : _options$getSourceMap.call(options, stack$1.file);
+		if (!map || typeof map !== "object" || !map.version) {
+			return shouldFilter(ignoreStackEntries, stack$1.file) ? null : stack$1;
+		}
+		const traceMap = new TraceMap(map);
+		const { line, column, source, name } = originalPositionFor(traceMap, stack$1);
+		let file = stack$1.file;
+		if (source) {
+			const fileUrl = stack$1.file.startsWith("file://") ? stack$1.file : `file://${stack$1.file}`;
+			const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
+			file = new URL(source, sourceRootUrl).pathname;
+			if (file.match(/\/\w:\//)) {
+				file = file.slice(1);
+			}
+		}
+		if (shouldFilter(ignoreStackEntries, file)) {
+			return null;
+		}
+		if (line != null && column != null) {
+			return {
+				line,
+				column,
+				file,
+				method: name || stack$1.method
+			};
+		}
+		return stack$1;
+	}).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+	return ignoreStackEntries.some((p) => file.match(p));
+}
+function parseFFOrSafariStackTrace(stack) {
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+	return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+function parseErrorStacktrace(e, options = {}) {
+	if (!e || isPrimitive(e)) {
+		return [];
+	}
+	if (e.stacks) {
+		return e.stacks;
+	}
+	const stackStr = e.stack || "";
+	let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
+	if (!stackFrames.length) {
+		const e_ = e;
+		if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) {
+			stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+		}
+		if (e_.sourceURL != null && e_.line != null && e_._column != null) {
+			stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+		}
+	}
+	if (options.frameFilter) {
+		stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+	}
+	e.stacks = stackFrames;
+	return stackFrames;
+}
+
+//#endregion
+export { parseSingleStack };