@vitest/utils 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/source-map.js

@@ -1,788 +1,216 @@
 import { isPrimitive, notNullish } from './helpers.js';
+import { r as resolve } from './chunk-pathe.M-eThtNZ.js';
+import './constants.js';
 
-const comma = ','.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
+// src/vlq.ts
+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;
+  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;
+  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;
-}
-class StringReader {
-    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;
-    }
+  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;
+  }
+};
 
+// src/sourcemap-codec.ts
 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];
-}
-
-// Matches the scheme of a URL, eg "http://"
-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) {
-    UrlType[UrlType["Empty"] = 1] = "Empty";
-    UrlType[UrlType["Hash"] = 2] = "Hash";
-    UrlType[UrlType["Query"] = 3] = "Query";
-    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-    UrlType[UrlType["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 = parseAbsoluteUrl('http:' + input);
-        url.scheme = '';
-        url.type = UrlType.SchemeRelative;
-        return url;
-    }
-    if (isAbsolutePath(input)) {
-        const url = parseAbsoluteUrl('http://foo.com' + input);
-        url.scheme = '';
-        url.host = '';
-        url.type = UrlType.AbsolutePath;
-        return url;
-    }
-    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 a path ends with a parent directory "..", then it's a relative path with excess parent
-    // paths. It's not a file, so we can't strip it.
-    if (path.endsWith('/..'))
-        return path;
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-function mergePaths(url, base) {
-    normalizePath(base, base.type);
-    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
-    // path).
-    if (url.path === '/') {
-        url.path = base.path;
-    }
-    else {
-        // Resolution happens relative to the base path's directory, not the file.
-        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('/');
-    // We need to preserve the first piece always, so that we output a leading slash. The item at
-    // pieces[0] is an empty string.
-    let pointer = 1;
-    // Positive is the number of real directories we've output, used for popping a parent directory.
-    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
-    let positive = 0;
-    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
-    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
-    // real directory, we won't need to append, unless the other conditions happen again.
-    let addTrailingSlash = false;
-    for (let i = 1; i < pieces.length; i++) {
-        const piece = pieces[i];
-        // An empty directory, could be a trailing slash, or just a double "//" in the path.
-        if (!piece) {
-            addTrailingSlash = true;
-            continue;
-        }
-        // If we encounter a real directory, then we don't need to append anymore.
-        addTrailingSlash = false;
-        // A current directory, which we can always drop.
-        if (piece === '.')
-            continue;
-        // A parent directory, we need to see if there are any real directories we can pop. Else, we
-        // have an excess of parents, and we'll need to keep the "..".
-        if (piece === '..') {
-            if (positive) {
-                addTrailingSlash = true;
-                positive--;
-                pointer--;
-            }
-            else if (rel) {
-                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
-                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
-                pieces[pointer++] = piece;
-            }
-            continue;
-        }
-        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
-        // any popped or dropped directories.
-        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;
-            // fall through
-            case UrlType.Hash:
-                url.query = baseUrl.query;
-            // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
-                mergePaths(url, baseUrl);
-            // fall through
-            case UrlType.AbsolutePath:
-                // The host, user, and port are joined, you can't copy one without the others.
-                url.user = baseUrl.user;
-                url.host = baseUrl.host;
-                url.port = baseUrl.port;
-            // fall through
-            case UrlType.SchemeRelative:
-                // The input doesn't have a schema at least, so we need to copy at least that over.
-                url.scheme = baseUrl.scheme;
-        }
-        if (baseType > inputType)
-            inputType = baseType;
-    }
-    normalizePath(url, inputType);
-    const queryHash = url.query + url.hash;
-    switch (inputType) {
-        // This is impossible, because of the empty checks at the start of the function.
-        // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
-            return queryHash;
-        case UrlType.RelativePath: {
-            // The first char is always a "/", and we need it to be relative.
-            const path = url.path.slice(1);
-            if (!path)
-                return queryHash || '.';
-            if (isRelative(base || input) && !isRelative(path)) {
-                // If base started with a leading ".", or there is no base and input started with a ".",
-                // then we need to ensure that the relative path starts with a ".". We don't know if
-                // relative starts with a "..", though, so check before prepending.
-                return './' + path + queryHash;
-            }
-            return path + queryHash;
+  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];
         }
-        case UrlType.AbsolutePath:
-            return url.path + queryHash;
-        default:
-            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+      } 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 resolve$1(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$2(input, base);
+function sort(line) {
+  line.sort(sortComparator);
 }
-
-/**
- * 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);
+function sortComparator(a, b) {
+  return a[0] - b[0];
 }
 
-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;
+// src/trace-mapping.ts
 
-function maybeSort(mappings, owned) {
-    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-    if (unsortedIndex === mappings.length)
-        return mappings;
-    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-    // not, we do not want to modify the consumer's input array.
-    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];
-}
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
 
-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]);
- * ```
- */
+// src/binary-search.ts
+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;
-        }
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
     }
-    found = false;
-    return low - 1;
+    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;
+  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,
-    };
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
 }
-/**
- * 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) {
-            // lastIndex may be -1 if the previous needle was not found.
-            low = lastIndex === -1 ? 0 : lastIndex;
-        }
-        else {
-            high = lastIndex;
-        }
+  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;
     }
-    state.lastKey = key;
-    state.lastNeedle = needle;
-    return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}
-
-// Rebuilds the original source files, with mappings that are ordered by source line/column instead
-// of generated line/column.
-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];
-            // The binary search either found a match, or it found the left-index just before where the
-            // segment should go. Either way, we want to insert after that. And there may be multiple
-            // generated segments associated with an original location, so there may need to move several
-            // indexes before we find where we need to insert.
-            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];
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
     }
-    array[index] = value;
-}
-// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
-// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
-// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
-// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
-// order when iterating with for-in.
-function buildNullArray() {
-    return { __proto__: null };
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
 }
 
-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;
-class TraceMap {
-    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.
- */
+// src/trace-mapping.ts
+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;
+  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)));
+  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);
-    // It's common for parent source maps to have pointers to lines that have no
-    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-    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,
-            });
-        }
-    }
+  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 GMapping(line, column) {
-    return { line, column };
+  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;
-}
-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]);
+  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;
 }
 
-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 = [
@@ -796,6 +224,8 @@ const stackIgnorePatterns = [
 	"/node_modules/chai/",
 	"/node_modules/tinypool/",
 	"/node_modules/tinyspy/",
+	"/vite/dist/node/module-runner",
+	"/rolldown-vite/dist/node/module-runner",
 	"/deps/chunk-",
 	"/deps/@vitest",
 	"/deps/loupe",
@@ -843,14 +273,35 @@ function parseSingleFFOrSafariStack(raw) {
 	if (line.includes(" > eval")) {
 		line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
 	}
-	if (!line.includes("@") && !line.includes(":")) {
+	// Early return for lines that don't look like Firefox/Safari stack traces
+	// Firefox/Safari stack traces must contain '@' and should have location info after it
+	if (!line.includes("@")) {
 		return null;
 	}
-	// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/optimal-quantifier-concatenation
-	const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
-	const matches = line.match(functionNameRegex);
-	const functionName = matches && matches[1] ? matches[1] : undefined;
-	const [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
+	// Find the correct @ that separates function name from location
+	// For cases like '@https://@fs/path' or 'functionName@https://@fs/path'
+	// we need to find the first @ that precedes a valid location (containing :)
+	let atIndex = -1;
+	let locationPart = "";
+	let functionName;
+	// Try each @ from left to right to find the one that gives us a valid location
+	for (let i = 0; i < line.length; i++) {
+		if (line[i] === "@") {
+			const candidateLocation = line.slice(i + 1);
+			// Minimum length 3 for valid location: 1 for filename + 1 for colon + 1 for line number (e.g., "a:1")
+			if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+				atIndex = i;
+				locationPart = candidateLocation;
+				functionName = i > 0 ? line.slice(0, i) : undefined;
+				break;
+			}
+		}
+	}
+	// Validate we found a valid location with minimum length (filename:line format)
+	if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
+		return null;
+	}
+	const [url, lineNumber, columnNumber] = extractLocation(locationPart);
 	if (!url || !lineNumber || !columnNumber) {
 		return null;
 	}
@@ -901,7 +352,7 @@ function parseSingleV8Stack(raw) {
 	// normalize Windows path (\ -> /)
 	file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
 	if (method) {
-		method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+		method = method.replace(/__vite_ssr_import_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
 	}
 	return {
 		method,
@@ -931,17 +382,15 @@ function parseStacktrace(stack, options = {}) {
 		if (!map || typeof map !== "object" || !map.version) {
 			return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
 		}
-		const traceMap = new TraceMap(map);
-		const { line, column, source, name } = originalPositionFor(traceMap, stack);
-		let file = stack.file;
-		if (source) {
-			const fileUrl = stack.file.startsWith("file://") ? stack.file : `file://${stack.file}`;
-			const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
-			file = new URL(source, sourceRootUrl).pathname;
-			// if the file path is on windows, we need to remove the leading slash
-			if (file.match(/\/\w:\//)) {
-				file = file.slice(1);
-			}
+		const traceMap = new DecodedMap(map, stack.file);
+		const position = getOriginalPosition(traceMap, 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;
@@ -992,5 +441,38 @@ function parseErrorStacktrace(e, options = {}) {
 	e.stacks = stackFrames;
 	return stackFrames;
 }
+class DecodedMap {
+	_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(s || "", from));
+	}
+}
+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;
+}
 
-export { TraceMap, createStackString, eachMapping, generatedPositionFor, originalPositionFor, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };
+export { DecodedMap, createStackString, stackIgnorePatterns as defaultStackIgnorePatterns, getOriginalPosition, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };