@directus/api 35.0.2 → 35.1.0

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

@@ -1,890 +0,0 @@
-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 };