@vitest/snapshot 0.33.0 → 0.34.1

package/dist/index.js

@@ -134,166 +134,7 @@ try {
   nodeInspect = false;
 }
 
-function normalizeWindowsPath(input = "") {
-  if (!input || !input.includes("\\")) {
-    return input;
-  }
-  return input.replace(/\\/g, "/");
-}
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-function cwd() {
-  if (typeof process !== "undefined") {
-    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 lineSplitRE = /\r?\n/;
-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/"
-];
-function extractLocation(urlLike) {
-  if (!urlLike.includes(":"))
-    return [urlLike];
-  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
-  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
-  if (!parts)
-    return [urlLike];
-  return [parts[1], parts[2] || void 0, parts[3] || void 0];
-}
-function parseSingleStack(raw) {
-  let line = raw.trim();
-  if (line.includes("(eval "))
-    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
-  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-  const location = sanitizedLine.match(/ (\(.+\)$)/);
-  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
-  let method = location && sanitizedLine || "";
-  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
-  if (!file || !lineNumber || !columnNumber)
-    return null;
-  if (method.startsWith("async "))
-    method = method.slice(6);
-  if (file.startsWith("file://"))
-    file = file.slice(7);
-  file = resolve(file);
-  return {
-    method,
-    file,
-    line: Number.parseInt(lineNumber),
-    column: Number.parseInt(columnNumber)
-  };
-}
-function parseStacktrace(stack, ignore = stackIgnorePatterns) {
-  const stackFrames = stack.split("\n").map((raw) => {
-    const stack2 = parseSingleStack(raw);
-    if (!stack2 || ignore.length && ignore.some((p) => stack2.file.match(p)))
-      return null;
-    return stack2;
-  }).filter(notNullish);
-  return stackFrames;
-}
-function parseErrorStacktrace(e, ignore = stackIgnorePatterns) {
-  if (!e || isPrimitive(e))
-    return [];
-  if (e.stacks)
-    return e.stacks;
-  const stackStr = e.stack || e.stackStr || "";
-  const stackFrames = parseStacktrace(stackStr, ignore);
-  e.stacks = stackFrames;
-  return stackFrames;
-}
 function positionToOffset(source, lineNumber, columnNumber) {
   const lines = source.split(lineSplitRE);
   const nl = /\r\n/.test(source) ? 2 : 1;
@@ -493,6 +334,646 @@ function deepMergeSnapshot(target, source) {
   return target;
 }
 
+function normalizeWindowsPath(input = "") {
+  if (!input || !input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+  if (typeof process !== "undefined") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve$2 = 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 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 decode(mappings) {
+  const state = new Int32Array(5);
+  const decoded = [];
+  let index = 0;
+  do {
+    const semi = indexOf(mappings, index);
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    state[0] = 0;
+    for (let i = index; i < semi; i++) {
+      let seg;
+      i = decodeInteger(mappings, i, state, 0);
+      const col = state[0];
+      if (col < lastCol)
+        sorted = false;
+      lastCol = col;
+      if (hasMoreVlq(mappings, i, semi)) {
+        i = decodeInteger(mappings, i, state, 1);
+        i = decodeInteger(mappings, i, state, 2);
+        i = decodeInteger(mappings, i, state, 3);
+        if (hasMoreVlq(mappings, i, semi)) {
+          i = decodeInteger(mappings, i, state, 4);
+          seg = [col, state[1], state[2], state[3], state[4]];
+        } else {
+          seg = [col, state[1], state[2], state[3]];
+        }
+      } else {
+        seg = [col];
+      }
+      line.push(seg);
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    index = semi + 1;
+  } while (index <= mappings.length);
+  return decoded;
+}
+function indexOf(mappings, index) {
+  const idx = mappings.indexOf(";", index);
+  return idx === -1 ? mappings.length : idx;
+}
+function decodeInteger(mappings, pos, state, j) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = mappings.charCodeAt(pos++);
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  state[j] += value;
+  return pos;
+}
+function hasMoreVlq(mappings, i, length) {
+  if (i >= length)
+    return false;
+  return mappings.charCodeAt(i) !== comma;
+}
+function sort(line) {
+  line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+  return a[0] - b[0];
+}
+const schemeRegex = /^[\w+.-]+:\/\//;
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var UrlType;
+(function(UrlType2) {
+  UrlType2[UrlType2["Empty"] = 1] = "Empty";
+  UrlType2[UrlType2["Hash"] = 2] = "Hash";
+  UrlType2[UrlType2["Query"] = 3] = "Query";
+  UrlType2[UrlType2["RelativePath"] = 4] = "RelativePath";
+  UrlType2[UrlType2["AbsolutePath"] = 5] = "AbsolutePath";
+  UrlType2[UrlType2["SchemeRelative"] = 6] = "SchemeRelative";
+  UrlType2[UrlType2["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 url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = UrlType.SchemeRelative;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = UrlType.AbsolutePath;
+    return url2;
+  }
+  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;
+  }
+}
+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;
+}
+function resolve$1(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(input, base) {
+  if (base && !base.endsWith("/"))
+    base += "/";
+  return resolve$1(input, base);
+}
+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;
+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;
+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
+  };
+}
+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);
+}
+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;
+let decodedMappings;
+let originalPositionFor;
+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;
+    const from = resolve(sourceRoot || "", stripFilename(mapUrl));
+    this.resolvedSources = sources.map((s) => resolve(s || "", from));
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+}
+(() => {
+  decodedMappings = (map) => {
+    return map._decoded || (map._decoded = decode(map._encoded));
+  };
+  originalPositionFor = (map, { line, column, bias }) => {
+    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, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    if (index === -1)
+      return OMapping(null, null, null, null);
+    const segment = segments[index];
+    if (segment.length === 1)
+      return OMapping(null, null, null, null);
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+  };
+})();
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+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/chai.js",
+  /__vitest_browser__/
+];
+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("http:") || url.startsWith("https:")) {
+    const urlObj = new URL(url);
+    url = urlObj.pathname;
+  }
+  if (url.startsWith("/@fs/")) {
+    url = url.slice(typeof process !== "undefined" && process.platform === "win32" ? 5 : 4);
+  }
+  return [url, parts[2] || void 0, parts[3] || void 0];
+}
+function parseSingleFFOrSafariStack(raw) {
+  let line = raw.trim();
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line))
+    return null;
+  if (line.includes(" > eval"))
+    line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+  if (!line.includes("@") && !line.includes(":"))
+    return null;
+  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
+  const matches = line.match(functionNameRegex);
+  const functionName = matches && matches[1] ? matches[1] : void 0;
+  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 parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line))
+    return null;
+  if (line.includes("(eval "))
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  if (!file || !lineNumber || !columnNumber)
+    return null;
+  if (method.startsWith("async "))
+    method = method.slice(6);
+  if (file.startsWith("file://"))
+    file = file.slice(7);
+  file = resolve$2(file);
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseStacktrace(stack, options = {}) {
+  const { ignoreStackEntries = stackIgnorePatterns } = options;
+  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+  if (ignoreStackEntries.length)
+    stacks = stacks.filter((stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p)));
+  return stacks.map((stack2) => {
+    var _a;
+    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
+    if (!map || typeof map !== "object" || !map.version)
+      return stack2;
+    const traceMap = new TraceMap(map);
+    const { line, column } = originalPositionFor(traceMap, stack2);
+    if (line != null && column != null)
+      return { ...stack2, line, column };
+    return stack2;
+  });
+}
+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 || e.stackStr || "";
+  const stackFrames = parseStacktrace(stackStr, options);
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+
 async function saveInlineSnapshots(environment, snapshots) {
   const MagicString = (await import('magic-string')).default;
   const files = new Set(snapshots.map((i) => i.file));
@@ -659,7 +1140,7 @@ class SnapshotState {
   _addSnapshot(key, receivedSerialized, options) {
     this._dirty = true;
     if (options.isInline) {
-      const stacks = parseErrorStacktrace(options.error || new Error("snapshot"), []);
+      const stacks = parseErrorStacktrace(options.error || new Error("snapshot"), { ignoreStackEntries: [] });
       const stack = this._inferInlineSnapshotStack(stacks);
       if (!stack) {
         throw new Error(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/snapshot",
   "type": "module",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "description": "Vitest snapshot manager",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -45,7 +45,7 @@
   "devDependencies": {
     "@types/natural-compare": "^1.4.1",
     "natural-compare": "^1.4.0",
-    "@vitest/utils": "0.33.0"
+    "@vitest/utils": "0.34.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",