bippy 0.7.3-dev.ebf9a42 → 0.7.3-dev.fbafc40

package/src/source/get-source.ts

@@ -1,26 +1,17 @@
-import type { Fiber } from "../react-internals/index.js";
-import { getDisplayName } from "../core.js";
+import type { Fiber } from "../react-internals/index";
+import { getDisplayName } from "../core";
 
-import type { FiberSource } from "./types.js";
-import {
-  SCHEME_REGEX,
-  INTERNAL_SCHEME_PREFIXES,
-  ABOUT_REACT_PREFIX,
-  ANONYMOUS_FILE_PATTERNS,
-  SOURCE_FILE_EXTENSION_REGEX,
-  BUNDLED_FILE_PATTERN_REGEX,
-  QUERY_PARAMETER_PATTERN_REGEX,
-} from "./constants.js";
-import { getDefinitionFrameFromOwnedChild, getParentStack, hasDebugStack } from "./owner-stack.js";
-import { parseDebugStack } from "./parse-debug-stack.js";
-import { parseStack, type StackFrame } from "./parse-stack.js";
+import type { FiberSource } from "./types";
+import { getDefinitionFrameFromOwnedChild, getParentStack, hasDebugStack } from "./owner-stack";
+import { parseDebugStack } from "./parse-debug-stack";
+import { parseStack, type StackFrame } from "./parse-stack";
 import {
   getSourceFromSourceMapByFunctionName,
   getSourceMap,
   symbolicateStack,
   type SourceFetch,
   type SourceMapRequestOptions,
-} from "./symbolication.js";
+} from "./symbolication";
 
 export const hasDebugSource = (
   fiber: Fiber,
@@ -165,130 +156,4 @@ export const getSource = async (
   return getSourceByComponentName(fiber, shouldUseCache, sourceFetch, requestOptions);
 };
 
-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;
-  }
-
-  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.startsWith("@")) {
-    return path;
-  }
-
-  if (firstRemainderSegment.length > 4) {
-    return path;
-  }
-
-  return remainderPath;
-};
-
-export const normalizeFileName = (fileName: string): string => {
-  if (!fileName) {
-    return "";
-  }
-
-  if (ANONYMOUS_FILE_PATTERNS.some((pattern) => pattern === fileName)) {
-    return "";
-  }
-
-  let normalizedFileName = fileName;
-  const isWindowsDrivePath = /^[a-zA-Z]:[\\/]/.test(normalizedFileName);
-
-  const isHttpUrl =
-    normalizedFileName.startsWith("http://") || normalizedFileName.startsWith("https://");
-  if (isHttpUrl) {
-    try {
-      const parsedUrl = new URL(normalizedFileName);
-      normalizedFileName = parsedUrl.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(":");
-
-    if (slashIndex !== -1 && (colonIndex === -1 || slashIndex < colonIndex)) {
-      normalizedFileName = remainder.slice(slashIndex + 1);
-    } else {
-      normalizedFileName = remainder;
-    }
-  }
-
-  let didStripPrefix = true;
-  while (didStripPrefix) {
-    didStripPrefix = false;
-    for (const prefix of INTERNAL_SCHEME_PREFIXES) {
-      if (normalizedFileName.startsWith(prefix)) {
-        normalizedFileName = normalizedFileName.slice(prefix.length);
-
-        if (prefix === "file:///") {
-          normalizedFileName = `/${normalizedFileName.replace(/^\/+/, "")}`;
-        }
-
-        didStripPrefix = true;
-        break;
-      }
-    }
-  }
-
-  if (!isWindowsDrivePath) {
-    const schemeMatch = normalizedFileName.match(SCHEME_REGEX);
-    if (schemeMatch) {
-      normalizedFileName = normalizedFileName.slice(schemeMatch[0].length);
-    }
-  }
-
-  if (normalizedFileName.startsWith("//")) {
-    const firstPathSlashIndex = normalizedFileName.indexOf("/", 2);
-    normalizedFileName =
-      firstPathSlashIndex === -1 ? "" : normalizedFileName.slice(firstPathSlashIndex);
-  }
-
-  const queryParameterIndex = normalizedFileName.indexOf("?");
-  if (queryParameterIndex !== -1) {
-    const potentialQueryParameters = normalizedFileName.slice(queryParameterIndex);
-    if (QUERY_PARAMETER_PATTERN_REGEX.test(potentialQueryParameters)) {
-      normalizedFileName = normalizedFileName.slice(0, queryParameterIndex);
-    }
-  }
-
-  return normalizedFileName;
-};
-
-export const isSourceFile = (fileName: string): boolean => {
-  const normalizedFileName = normalizeFileName(fileName);
-
-  if (!normalizedFileName) {
-    return false;
-  }
-
-  if (!SOURCE_FILE_EXTENSION_REGEX.test(normalizedFileName)) {
-    return false;
-  }
-
-  if (BUNDLED_FILE_PATTERN_REGEX.test(normalizedFileName)) {
-    return false;
-  }
-
-  return true;
-};
+export { isSourceFile, normalizeFileName } from "./normalize-file-name";

package/src/source/index.ts

@@ -6,8 +6,8 @@ export {
   getParentStack,
   getRawOwnerStack,
   hasDebugStack,
-} from "./owner-stack.js";
-export { getRawSource, getSource, isSourceFile, normalizeFileName } from "./get-source.js";
+} from "./owner-stack";
+export { getRawSource, getSource, isSourceFile, normalizeFileName } from "./get-source";
 export {
   getSourceContentFromSourceMap,
   getSourceFromSourceMap,
@@ -20,22 +20,22 @@ export {
   type SourceMap,
   type SourceMapRequestOptions,
   type StandardSourceMap,
-} from "./symbolication.js";
-export type { FiberSource } from "./types.js";
-export { parseStack, type ParseOptions, type StackFrame } from "./parse-stack.js";
-export { getDisplayNameFromSource } from "./get-display-name-from-source.js";
+} from "./symbolication";
+export type { FiberSource } from "./types";
+export { parseStack, type ParseOptions, type StackFrame } from "./parse-stack";
+export { getDisplayNameFromSource } from "./get-display-name-from-source";
 export {
   BippyError,
   BippyHookInspectionError,
   BippyHookRenderError,
   BippySourceMapError,
   BippyUnsupportedHookError,
-} from "../errors.js";
+} from "../errors";
 export {
   getFiberHooks,
   inspectHooks,
   type HookSource,
   type HooksNode,
   type HooksTree,
-} from "./inspect-hooks.js";
-export { parseHookNames, type HookNames } from "./parse-hook-names.js";
+} from "./inspect-hooks";
+export { parseHookNames, type HookNames } from "./parse-hook-names";

package/src/source/inspect-hooks.ts

@@ -1,5 +1,5 @@
-import { getRenderer } from "../core.js";
-import type { ReactDevToolsTarget } from "../rdt-hook.js";
+import { getRenderer } from "../core";
+import type { ReactDevToolsTarget } from "../rdt-hook";
 import type {
   Fiber,
   ContextDependency,
@@ -7,19 +7,15 @@ import type {
   ReactContext,
   ReactDebugInfo,
   RendererDispatcherRef,
-} from "../react-internals/index.js";
+} from "../react-internals/index";
 import {
   BippyHookInspectionError,
   BippyHookRenderError,
   BippyUnsupportedHookError,
-} from "../errors.js";
-import { getReactWorkTagsForFiber } from "../react-internals/index.js";
-import { createStackParser, parseStack, type StackFrame } from "./parse-stack.js";
-import {
-  getRendererDispatcherRefs,
-  readDispatcher,
-  writeDispatcher,
-} from "./renderer-dispatchers.js";
+} from "../errors";
+import { getReactWorkTagsForFiber } from "../react-internals/index";
+import { createStackParser, parseStack, type StackFrame } from "./parse-stack";
+import { getRendererDispatcherRefs, readDispatcher, writeDispatcher } from "./renderer-dispatchers";
 
 const REACT_CONTEXT_TYPE = Symbol.for("react.context");
 const REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");

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";
+
+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/owner-stack.ts

@@ -1,28 +1,16 @@
-import { getDisplayName, getType, traverseFiber } from "../core.js";
-import { getReactWorkTagsForFiber } from "../react-internals/index.js";
-import type {
-  Fiber,
-  RendererDispatcherRef,
-  ServerComponentInfo,
-} from "../react-internals/index.js";
+import { getDisplayName, getType, traverseFiber } from "../core";
+import { getReactWorkTagsForFiber } from "../react-internals/index";
+import type { Fiber, RendererDispatcherRef, ServerComponentInfo } from "../react-internals/index";
 import {
   REACT_STACK_BOTTOM_FRAME_PATTERNS,
   SERVER_ENV_PATTERN,
   SERVER_COMPONENT_URL_PREFIXES,
-} from "./constants.js";
-import { getPrepareStackTrace, setPrepareStackTrace } from "./error-stack.js";
-import { parseDebugStack } from "./parse-debug-stack.js";
-import { parseStack, type StackFrame } from "./parse-stack.js";
-import {
-  getRendererDispatcherRefs,
-  readDispatcher,
-  writeDispatcher,
-} from "./renderer-dispatchers.js";
-import {
-  symbolicateStack,
-  type SourceFetch,
-  type SourceMapRequestOptions,
-} from "./symbolication.js";
+} from "./constants";
+import { getPrepareStackTrace, setPrepareStackTrace } from "./error-stack";
+import { parseDebugStack } from "./parse-debug-stack";
+import { parseStack, type StackFrame } from "./parse-stack";
+import { getRendererDispatcherRefs, readDispatcher, writeDispatcher } from "./renderer-dispatchers";
+import { symbolicateStack, type SourceFetch, type SourceMapRequestOptions } from "./symbolication";
 
 interface RendererDispatcherSnapshot {
   currentDispatcherRef: RendererDispatcherRef;