bippy 0.7.3-dev.1d4f35b → 0.7.3-dev.65d7336

package/src/source/normalize-file-name.ts

@@ -0,0 +1,416 @@
+import {
+  ABOUT_REACT_PREFIX,
+  ANONYMOUS_FILE_PATTERNS,
+  BUNDLED_FILE_PATTERN_REGEX,
+  INTERNAL_SCHEME_PREFIXES,
+  QUERY_PARAMETER_PATTERN_REGEX,
+  SCHEME_REGEX,
+  SOURCE_FILE_EXTENSION_REGEX,
+} from "./constants.js";
+
+const VITE_FS_PREFIX = "/@fs/";
+const VITE_ID_PREFIX = "/@id/";
+const VITE_NULL_BYTE_PLACEHOLDER = "__x00__";
+const NEXT_WEBPACK_NAMESPACE = "_N_E/";
+const TURBOPACK_PROJECT_TOKEN = "[project]/";
+const WINDOWS_DRIVE_PREFIX = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_DRIVE_SEGMENT = /^[a-zA-Z]:$/;
+const APP_PAGES_BROWSER_PREFIX = /^\/?(?:app-pages-browser|\(app-pages-browser\))\//;
+const NEXT_BUNDLER_LAYER_PREFIX =
+  /^\/?\((?:action-browser|api-edge|api-node|edge-asset|instrument|middleware|pages-dir-browser|pages-dir-edge|pages-dir-node|rsc|shared|ssr)\)\//;
+const ENCODED_SEPARATOR = /%(?:2f|5c)/i;
+const WINDOWS_EXTENDED_PATH_PREFIX = "\\\\?\\";
+const REACT_ENVIRONMENT_PREFIX = /^React\/[^/]+\//;
+const TURBOPACK_MAGIC_IDENTIFIER = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+const TURBOPACK_MAGIC_IDENTIFIER_EXACT = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+const IMPORTED_MODULE_PREFIX = "imported module ";
+const BUNDLER_LAYER_SUFFIX =
+  /\s\[(?:app-[a-z0-9-]+|action-browser|api-edge|api-node|edge-asset|instrument|middleware|pages-dir-browser|pages-dir-edge|pages-dir-node|rsc|shared|ssr)\]$/;
+const BUNDLER_MODULE_TYPE_SUFFIX =
+  /\s\((?:asset|client reference proxy|css(?: client reference| module)?|ecmascript(?: client reference to (?:client|ssr))?|javascript|json|less|mdx|raw|sass|scss|static|typescript|unknown|wasm)\b[^)]*\)$/;
+const BUNDLER_EXPORT_SUFFIX = /\s<(?:exports?|locals|namespace)\b[^>]*>$/;
+const BUNDLER_MODULE_SUFFIXES = [
+  BUNDLER_MODULE_TYPE_SUFFIX,
+  BUNDLER_LAYER_SUFFIX,
+  BUNDLER_EXPORT_SUFFIX,
+];
+
+const isWindowsDrivePath = (filePath: string): boolean => WINDOWS_DRIVE_PREFIX.test(filePath);
+
+const VIRTUAL_SCHEME_PREFIXES = ["astro:", "cloudflare:", "nitro:"] as const;
+
+const isVirtualModuleId = (filePath: string): boolean =>
+  filePath.startsWith("\0") ||
+  filePath.startsWith("virtual:") ||
+  VIRTUAL_SCHEME_PREFIXES.some((prefix) => filePath.startsWith(prefix));
+
+const decodeHex = (hexText: string): string => {
+  if (hexText.trim() === "") throw new Error("empty hex");
+  const codePoint = Number.parseInt(hexText, 16);
+  if (Number.isNaN(codePoint)) throw new Error("invalid hex");
+  return String.fromCodePoint(codePoint);
+};
+
+const decodeMagicIdentifier = (identifier: string): string => {
+  const innerIdentifier = identifier.match(TURBOPACK_MAGIC_IDENTIFIER_EXACT)?.[1];
+  if (!innerIdentifier) return identifier;
+
+  let output = "";
+  let mode: "text" | "underscore" | "hex" | "long-hex" = "text";
+  let buffer = "";
+
+  for (const character of innerIdentifier) {
+    if (mode === "text") {
+      if (character === "_") mode = "underscore";
+      else if (character === "$") mode = "hex";
+      else output += character;
+      continue;
+    }
+
+    if (mode === "underscore") {
+      if (character === "_") output += " ";
+      else if (character === "$") {
+        output += "_";
+        mode = "hex";
+        continue;
+      } else output += character;
+      mode = "text";
+      continue;
+    }
+
+    if (mode === "hex") {
+      if (buffer.length === 2) {
+        output += decodeHex(buffer);
+        buffer = "";
+      }
+      if (character === "_") {
+        if (buffer !== "") throw new Error("invalid hex");
+        mode = "long-hex";
+      } else if (character === "$") {
+        if (buffer !== "") throw new Error("invalid hex");
+        mode = "text";
+      } else {
+        buffer += character;
+      }
+      continue;
+    }
+
+    if (character === "_") throw new Error("invalid hex");
+    if (character === "$") {
+      output += decodeHex(buffer);
+      buffer = "";
+      mode = "text";
+      continue;
+    }
+    buffer += character;
+  }
+
+  return output;
+};
+
+const decodeMagicIdentifiers = (filePath: string): string => {
+  if (!filePath.includes("__TURBOPACK__")) return filePath;
+  const decodedFilePath = filePath.replace(TURBOPACK_MAGIC_IDENTIFIER, (identifier) => {
+    try {
+      return decodeMagicIdentifier(identifier);
+    } catch {
+      return identifier;
+    }
+  });
+  if (!decodedFilePath.startsWith(IMPORTED_MODULE_PREFIX)) return decodedFilePath;
+  return decodedFilePath.slice(IMPORTED_MODULE_PREFIX.length);
+};
+
+const stripBundlerModuleMetadata = (filePath: string): string => {
+  let strippedFilePath = filePath;
+  let didStripMetadata = true;
+  while (didStripMetadata) {
+    didStripMetadata = false;
+    for (const suffix of BUNDLER_MODULE_SUFFIXES) {
+      const suffixMatch = strippedFilePath.match(suffix);
+      if (!suffixMatch?.[0]) continue;
+      strippedFilePath = strippedFilePath.slice(0, -suffixMatch[0].length).trimEnd();
+      didStripMetadata = true;
+      break;
+    }
+  }
+  return strippedFilePath;
+};
+
+const stripWebpackLoaders = (filePath: string): string => {
+  const separatorIndex = filePath.lastIndexOf("!");
+  if (separatorIndex <= 0) return filePath;
+  const loaderPath = filePath.slice(0, separatorIndex);
+  const resourcePath = filePath.slice(separatorIndex + 1);
+  if (!loaderPath.includes("/") && !loaderPath.includes("\\")) return filePath;
+  const isResourcePath =
+    resourcePath.startsWith("./") ||
+    resourcePath.startsWith("../") ||
+    resourcePath.startsWith("/") ||
+    resourcePath.startsWith("\\") ||
+    resourcePath.includes("/") ||
+    resourcePath.includes("\\") ||
+    isWindowsDrivePath(resourcePath);
+  if (!isResourcePath) return filePath;
+  return resourcePath;
+};
+
+const decodePath = (filePath: string): string => {
+  if (!filePath.includes("%")) return filePath;
+  return filePath
+    .split("/")
+    .map((segment) => {
+      if (!segment.includes("%") || ENCODED_SEPARATOR.test(segment)) return segment;
+      try {
+        return decodeURIComponent(segment);
+      } catch {
+        return segment;
+      }
+    })
+    .join("/");
+};
+
+const resolveFileProtocol = (specifier: string): string => {
+  const afterScheme = specifier.slice("file://".length);
+  const postfixIndex = afterScheme.search(/[?#]/);
+  const pathWithHost = postfixIndex === -1 ? afterScheme : afterScheme.slice(0, postfixIndex);
+
+  let hostname = "";
+  let pathname = pathWithHost;
+  if (pathWithHost.startsWith("/")) {
+    pathname = pathWithHost.replace(/^\/+/, "/");
+  } else if (isWindowsDrivePath(pathWithHost)) {
+    pathname = pathWithHost;
+  } else {
+    const slashIndex = pathWithHost.indexOf("/");
+    hostname = slashIndex === -1 ? pathWithHost : pathWithHost.slice(0, slashIndex);
+    pathname = slashIndex === -1 ? "/" : pathWithHost.slice(slashIndex);
+  }
+
+  if (hostname.toLowerCase() === "localhost") hostname = "";
+  if (hostname) {
+    return `//${hostname}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+  }
+
+  if (pathname.startsWith("/") && isWindowsDrivePath(pathname.slice(1))) {
+    return pathname.slice(1);
+  }
+  if (isWindowsDrivePath(pathname)) return pathname;
+  return pathname.startsWith("/") ? pathname : `/${pathname}`;
+};
+
+const unwrapViteId = (filePath: string): string => {
+  if (filePath.startsWith(VITE_FS_PREFIX)) {
+    const absolutePath = filePath.slice(VITE_FS_PREFIX.length);
+    if (isWindowsDrivePath(absolutePath)) return absolutePath;
+    return absolutePath.startsWith("/") ? absolutePath : `/${absolutePath}`;
+  }
+
+  if (!filePath.startsWith(VITE_ID_PREFIX)) return filePath;
+  const unwrappedId = filePath
+    .slice(VITE_ID_PREFIX.length)
+    .replaceAll(VITE_NULL_BYTE_PLACEHOLDER, "\0");
+  if (unwrappedId.startsWith("\0") || unwrappedId.startsWith("virtual:")) return "";
+  return unwrappedId;
+};
+
+const stripWebpackNamespace = (filePath: string): string => {
+  if (filePath.startsWith(NEXT_WEBPACK_NAMESPACE)) {
+    return filePath.slice(NEXT_WEBPACK_NAMESPACE.length);
+  }
+  const slashIndex = filePath.indexOf("/");
+  if (slashIndex <= 0) return filePath;
+  const remainder = filePath.slice(slashIndex + 1);
+  if (remainder.startsWith("./") || remainder.startsWith("../")) return remainder;
+  return filePath;
+};
+
+const stripBundlerLayer = (filePath: string, didStripBundlerScheme: boolean): string => {
+  const appPagesMatch = filePath.match(APP_PAGES_BROWSER_PREFIX);
+  if (appPagesMatch?.[0]) return filePath.slice(appPagesMatch[0].length);
+  if (!didStripBundlerScheme) return filePath;
+  const layerMatch = filePath.match(NEXT_BUNDLER_LAYER_PREFIX);
+  if (!layerMatch?.[0]) return filePath;
+  return filePath.slice(layerMatch[0].length);
+};
+
+const stripUrlPostfix = (filePath: string): string => {
+  const hashIndex = filePath.indexOf("#");
+  const withoutHash = hashIndex === -1 ? filePath : filePath.slice(0, hashIndex);
+  const queryParameterIndex = withoutHash.indexOf("?");
+  if (queryParameterIndex === -1) return withoutHash;
+  const potentialQueryParameters = withoutHash.slice(queryParameterIndex);
+  if (!QUERY_PARAMETER_PATTERN_REGEX.test(potentialQueryParameters)) return withoutHash;
+  return withoutHash.slice(0, queryParameterIndex);
+};
+
+const normalizeLexicalPath = (filePath: string): string => {
+  if (!filePath || filePath.includes("\\")) return filePath;
+  const isAbsolute = filePath.startsWith("/");
+  const isNetworkPath = filePath.startsWith("//");
+  const hasRelativeDotPrefix = filePath.startsWith("./");
+  const normalizedSegments: string[] = [];
+
+  for (const segment of filePath.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      const previousSegment = normalizedSegments[normalizedSegments.length - 1];
+      if (
+        previousSegment &&
+        previousSegment !== ".." &&
+        (!isNetworkPath || normalizedSegments.length > 2) &&
+        !WINDOWS_DRIVE_SEGMENT.test(previousSegment)
+      ) {
+        normalizedSegments.pop();
+      } else if (!isAbsolute && !WINDOWS_DRIVE_SEGMENT.test(previousSegment ?? "")) {
+        normalizedSegments.push("..");
+      }
+      continue;
+    }
+    normalizedSegments.push(segment);
+  }
+
+  if (isAbsolute) return `${isNetworkPath ? "//" : "/"}${normalizedSegments.join("/")}`;
+  const joinedPath = normalizedSegments.join("/");
+  if (!joinedPath) return hasRelativeDotPrefix ? "./" : "";
+  if (hasRelativeDotPrefix && !joinedPath.startsWith("../")) return `./${joinedPath}`;
+  return joinedPath;
+};
+
+export const normalizeFileName = (fileName: string): string => {
+  if (!fileName) return "";
+  if (ANONYMOUS_FILE_PATTERNS.some((pattern) => pattern === fileName)) return "";
+  if (isVirtualModuleId(fileName)) return "";
+
+  let normalizedFileName = fileName;
+  if (normalizedFileName.startsWith(WINDOWS_EXTENDED_PATH_PREFIX)) {
+    const extendedPath = normalizedFileName.slice(WINDOWS_EXTENDED_PATH_PREFIX.length);
+    if (isWindowsDrivePath(extendedPath)) normalizedFileName = extendedPath;
+  }
+  normalizedFileName = decodeMagicIdentifiers(normalizedFileName);
+  if (isVirtualModuleId(normalizedFileName)) return "";
+
+  let didStripWebpackScheme = false;
+  let didStripBundlerScheme = false;
+  let didStripRscScheme = false;
+  let didResolveFileProtocol = false;
+
+  const isHttpUrl =
+    normalizedFileName.startsWith("http://") || normalizedFileName.startsWith("https://");
+  if (isHttpUrl) {
+    try {
+      normalizedFileName = new URL(normalizedFileName).pathname;
+    } catch {}
+    normalizedFileName = stripSingleBasePathPrefix(normalizedFileName);
+  }
+
+  if (normalizedFileName.startsWith(ABOUT_REACT_PREFIX)) {
+    const remainder = normalizedFileName.slice(ABOUT_REACT_PREFIX.length);
+    const slashIndex = remainder.indexOf("/");
+    const colonIndex = remainder.indexOf(":");
+    normalizedFileName =
+      slashIndex !== -1 && (colonIndex === -1 || slashIndex < colonIndex)
+        ? remainder.slice(slashIndex + 1)
+        : remainder;
+  }
+
+  let didStripPrefix = true;
+  while (didStripPrefix) {
+    didStripPrefix = false;
+    if (normalizedFileName.startsWith("file://")) {
+      const resolvedFilePath = resolveFileProtocol(normalizedFileName);
+      if (resolvedFilePath === normalizedFileName) break;
+      normalizedFileName = resolvedFilePath;
+      didResolveFileProtocol = true;
+      didStripPrefix = true;
+      continue;
+    }
+    if (didStripRscScheme) {
+      const reactEnvironmentMatch = normalizedFileName.match(REACT_ENVIRONMENT_PREFIX);
+      if (reactEnvironmentMatch?.[0]) {
+        normalizedFileName = normalizedFileName.slice(reactEnvironmentMatch[0].length);
+        didStripRscScheme = false;
+        didStripPrefix = true;
+        continue;
+      }
+    }
+    for (const prefix of INTERNAL_SCHEME_PREFIXES) {
+      if (!normalizedFileName.startsWith(prefix)) continue;
+      if (prefix === "rsc://") didStripRscScheme = true;
+      if (prefix === "webpack://" || prefix === "rspack://") didStripWebpackScheme = true;
+      if (
+        prefix === "webpack://" ||
+        prefix === "webpack-internal://" ||
+        prefix === "rspack://" ||
+        prefix === "rspack-internal://" ||
+        prefix === "turbopack://"
+      ) {
+        didStripBundlerScheme = true;
+      }
+      normalizedFileName = normalizedFileName.slice(prefix.length);
+      didStripPrefix = true;
+      break;
+    }
+  }
+
+  if (isVirtualModuleId(normalizedFileName)) return "";
+
+  if (!isWindowsDrivePath(normalizedFileName)) {
+    const schemeMatch = normalizedFileName.match(SCHEME_REGEX);
+    if (schemeMatch) normalizedFileName = normalizedFileName.slice(schemeMatch[0].length);
+  }
+
+  if (!didResolveFileProtocol && normalizedFileName.startsWith("//")) {
+    const firstPathSlashIndex = normalizedFileName.indexOf("/", 2);
+    normalizedFileName =
+      firstPathSlashIndex === -1 ? "" : normalizedFileName.slice(firstPathSlashIndex);
+  }
+
+  normalizedFileName = unwrapViteId(normalizedFileName);
+  if (didStripWebpackScheme) normalizedFileName = stripWebpackNamespace(normalizedFileName);
+  normalizedFileName = stripBundlerLayer(normalizedFileName, didStripBundlerScheme);
+  if (normalizedFileName.startsWith(TURBOPACK_PROJECT_TOKEN)) {
+    normalizedFileName = `./${normalizedFileName.slice(TURBOPACK_PROJECT_TOKEN.length)}`;
+  } else if (normalizedFileName.startsWith(`/${TURBOPACK_PROJECT_TOKEN}`)) {
+    normalizedFileName = normalizedFileName.slice(TURBOPACK_PROJECT_TOKEN.length);
+  }
+  normalizedFileName = stripBundlerModuleMetadata(normalizedFileName);
+  const resourcePath = stripWebpackLoaders(normalizedFileName);
+  if (resourcePath !== normalizedFileName) return normalizeFileName(resourcePath);
+  normalizedFileName = stripUrlPostfix(normalizedFileName);
+  normalizedFileName = decodePath(normalizedFileName);
+  normalizedFileName = normalizeLexicalPath(normalizedFileName);
+  if (isVirtualModuleId(normalizedFileName)) return "";
+  return normalizedFileName;
+};
+
+const getPathSegmentCount = (path: string): number => path.split("/").filter(Boolean).length;
+
+const stripSingleBasePathPrefix = (path: string): string => {
+  const firstSlashIndex = path.indexOf("/", 1);
+  if (firstSlashIndex === -1) return path;
+
+  const basePath = path.slice(0, firstSlashIndex);
+  if (getPathSegmentCount(basePath) !== 1) return path;
+  if (basePath === "/@fs" || basePath === "/@id") return path;
+
+  const remainderPath = path.slice(firstSlashIndex);
+  if (!SOURCE_FILE_EXTENSION_REGEX.test(remainderPath)) return path;
+
+  const remainderSegments = remainderPath.split("/").filter(Boolean);
+  if (remainderSegments.length < 2) return path;
+
+  const firstRemainderSegment = remainderSegments[0];
+  if (!firstRemainderSegment || firstRemainderSegment.startsWith("@")) return path;
+  if (firstRemainderSegment.length > 4) return path;
+  return remainderPath;
+};
+
+export const isSourceFile = (fileName: string): boolean => {
+  const normalizedFileName = normalizeFileName(fileName);
+  if (!normalizedFileName) return false;
+  if (normalizedFileName.includes("\0") || normalizedFileName.startsWith("virtual:")) return false;
+  if (!SOURCE_FILE_EXTENSION_REGEX.test(normalizedFileName)) return false;
+  if (BUNDLED_FILE_PATTERN_REGEX.test(normalizedFileName)) return false;
+  return true;
+};

package/src/source/parse-stack.ts

@@ -28,16 +28,14 @@ export const parseStack = (stackString: string, options?: ParseOptions): StackFr
     const frames: StackFrame[] = [];
     for (const rawLine of lines) {
       if (/^\s*at\s+/.test(rawLine)) {
-        const parsed = parseV8OrIeString(rawLine)[0];
-        if (parsed) frames.push(parsed);
+        if (CHROME_IE_STACK_REGEXP.test(rawLine)) frames.push(parseV8Line(rawLine));
       } else if (/^\s*in\s+/.test(rawLine)) {
         const elementName = rawLine
           .replace(/^\s*in\s+/, "")
           .replace(/\s*(?:\(at .*\)|\[[^\]]+\])$/, "");
         frames.push({ functionName: elementName, source: rawLine });
       } else if (rawLine.match(FIREFOX_SAFARI_STACK_REGEXP)) {
-        const parsed = parseFFOrSafariString(rawLine)[0];
-        if (parsed) frames.push(parsed);
+        if (!SAFARI_NATIVE_CODE_REGEXP.test(rawLine)) frames.push(parseSafariLine(rawLine));
       }
     }
     return frames;
@@ -48,6 +46,18 @@ export const parseStack = (stackString: string, options?: ParseOptions): StackFr
   return parseFFOrSafariString(stackString);
 };
 
+const getPositionIndex = (location: string, endIndex: number): number => {
+  let positionIndex = endIndex - 1;
+  while (positionIndex >= 0) {
+    const character = location.charCodeAt(positionIndex);
+    if (character < 48 || character > 57) break;
+    positionIndex--;
+  }
+  return positionIndex < endIndex - 1 && location.charCodeAt(positionIndex) === 58
+    ? positionIndex
+    : -1;
+};
+
 export const extractLocation = (
   urlLike: string,
 ): [string, string | undefined, string | undefined] => {
@@ -59,77 +69,115 @@ export const extractLocation = (
   const isWrappedLocation = urlLike.startsWith("(") && /:\d+\)$/.test(urlLike);
   const sanitizedResult = isWrappedLocation ? urlLike.slice(1, -1) : urlLike;
 
-  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
-  const parts = regExp.exec(sanitizedResult);
-  if (!parts) return [sanitizedResult, undefined, undefined];
-  return [parts[1], parts[2] || undefined, parts[3] || undefined] as const;
-};
+  if (/[\n\r\u2028\u2029]/.test(sanitizedResult)) {
+    const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(sanitizedResult);
+    return parts
+      ? [parts[1], parts[2] || undefined, parts[3] || undefined]
+      : [sanitizedResult, undefined, undefined];
+  }
 
-export const parseV8OrIeString = (stack: string): StackFrame[] => {
-  const filteredLines = stack.split("\n").filter((line) => {
-    return !!line.match(CHROME_IE_STACK_REGEXP);
-  });
-
-  return filteredLines.map((line): StackFrame => {
-    let currentLine = line;
-    if (currentLine.includes("(eval ")) {
-      currentLine = currentLine
-        .replace(/eval code/g, "eval")
-        .replace(/(\(eval at [^()]*)|(,.*$)/g, "");
-    }
-    let sanitizedLine = currentLine
-      .replace(/^\s+/, "")
-      .replace(/\(eval code/g, "(")
-      .replace(/^.*?\s+/, "");
+  const lastPositionIndex = getPositionIndex(sanitizedResult, sanitizedResult.length);
+  if (lastPositionIndex <= 0) return [sanitizedResult, undefined, undefined];
+  const previousPositionIndex = getPositionIndex(sanitizedResult, lastPositionIndex);
+  if (previousPositionIndex <= 0) {
+    return [
+      sanitizedResult.slice(0, lastPositionIndex),
+      sanitizedResult.slice(lastPositionIndex + 1),
+      undefined,
+    ];
+  }
+  return [
+    sanitizedResult.slice(0, previousPositionIndex),
+    sanitizedResult.slice(previousPositionIndex + 1, lastPositionIndex),
+    sanitizedResult.slice(lastPositionIndex + 1),
+  ];
+};
 
-    const locationMatch = sanitizedLine.match(/ (\(.+\)$)/);
+const parseV8Line = (line: string): StackFrame => {
+  let currentLine = line;
+  if (currentLine.includes("(eval ")) {
+    currentLine = currentLine
+      .replace(/eval code/g, "eval")
+      .replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = currentLine
+    .replace(/^\s+/, "")
+    .replace(/\(eval code/g, "(")
+    .replace(/^.*?\s+/, "");
+
+  const locationMatch = sanitizedLine.match(/ (\(.+\)$)/);
+
+  sanitizedLine = locationMatch ? sanitizedLine.replace(locationMatch[0], "") : sanitizedLine;
+
+  const locationParts = extractLocation(locationMatch ? locationMatch[1] : sanitizedLine);
+  const functionName = (locationMatch && sanitizedLine) || undefined;
+  const fileName = ["eval", "<anonymous>", "(native)"].includes(locationParts[0])
+    ? undefined
+    : locationParts[0];
+
+  return {
+    functionName,
+    fileName,
+    lineNumber: locationParts[1] ? +locationParts[1] : undefined,
+    columnNumber: locationParts[2] ? +locationParts[2] : undefined,
+    source: currentLine,
+  };
+};
 
-    sanitizedLine = locationMatch ? sanitizedLine.replace(locationMatch[0], "") : sanitizedLine;
+const parseSafariLine = (line: string): StackFrame => {
+  let currentLine = line;
+  if (currentLine.includes(" > eval"))
+    currentLine = currentLine.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
 
-    const locationParts = extractLocation(locationMatch ? locationMatch[1] : sanitizedLine);
-    const functionName = (locationMatch && sanitizedLine) || undefined;
-    const fileName = ["eval", "<anonymous>", "(native)"].includes(locationParts[0])
-      ? undefined
-      : locationParts[0];
+  if (!currentLine.includes("@") && !currentLine.includes(":")) {
+    return {
+      functionName: currentLine,
+    };
+  } else {
+    const functionNameRegex =
+      /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/;
+    const matches = currentLine.match(functionNameRegex);
+    const functionName = matches && matches[1] ? matches[1] : undefined;
+    const locationParts = extractLocation(currentLine.replace(functionNameRegex, ""));
 
     return {
       functionName,
-      fileName,
+      fileName: locationParts[0],
       lineNumber: locationParts[1] ? +locationParts[1] : undefined,
       columnNumber: locationParts[2] ? +locationParts[2] : undefined,
       source: currentLine,
     };
-  });
+  }
 };
 
-export const parseFFOrSafariString = (stack: string): StackFrame[] => {
-  const filteredLines = stack.split("\n").filter((line) => {
-    return !line.match(SAFARI_NATIVE_CODE_REGEXP);
-  });
-
-  return filteredLines.map((line): StackFrame => {
-    let currentLine = line;
-    if (currentLine.includes(" > eval"))
-      currentLine = currentLine.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
-
-    if (!currentLine.includes("@") && !currentLine.includes(":")) {
-      return {
-        functionName: currentLine,
-      };
-    } else {
-      const functionNameRegex =
-        /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/;
-      const matches = currentLine.match(functionNameRegex);
-      const functionName = matches && matches[1] ? matches[1] : undefined;
-      const locationParts = extractLocation(currentLine.replace(functionNameRegex, ""));
-
-      return {
-        functionName,
-        fileName: locationParts[0],
-        lineNumber: locationParts[1] ? +locationParts[1] : undefined,
-        columnNumber: locationParts[2] ? +locationParts[2] : undefined,
-        source: currentLine,
-      };
+const parseLines = (
+  stack: string,
+  isV8: boolean,
+  cache?: Map<string, StackFrame>,
+): StackFrame[] => {
+  const frames: StackFrame[] = [];
+  for (const line of stack.split("\n")) {
+    let frame = cache?.get(line);
+    if (!frame) {
+      if (isV8 ? !CHROME_IE_STACK_REGEXP.test(line) : SAFARI_NATIVE_CODE_REGEXP.test(line))
+        continue;
+      frame = isV8 ? parseV8Line(line) : parseSafariLine(line);
+      cache?.set(line, frame);
     }
-  });
+    frames.push(frame);
+  }
+  return frames;
+};
+
+export const parseV8OrIeString = (stack: string): StackFrame[] => parseLines(stack, true);
+
+export const parseFFOrSafariString = (stack: string): StackFrame[] => parseLines(stack, false);
+
+export const createStackParser = () => {
+  const v8Frames = new Map<string, StackFrame>();
+  const safariFrames = new Map<string, StackFrame>();
+  return (stack: string): StackFrame[] => {
+    const isV8 = CHROME_IE_STACK_REGEXP.test(stack);
+    return parseLines(stack, isV8, isV8 ? v8Frames : safariFrames);
+  };
 };