bippy 0.6.1-dev.b88fcb4 → 0.6.1-dev.f9e6c65

package/src/source/symbolication.ts

@@ -1,7 +1,8 @@
-import { decode, SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
+import { decode, type SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
 
 import { BippySourceMapError } from "../errors.js";
-import { StackFrame } from "./parse-stack.js";
+import { SCHEME_REGEX } from "./constants.js";
+import type { StackFrame } from "./parse-stack.js";
 
 export interface DecodedSourceMapSection {
   map: {
@@ -69,7 +70,6 @@ export interface StandardSourceMap {
   x_google_ignoreList?: number[];
 }
 
-const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
 const INLINE_SOURCEMAP_REGEX = /^data:application\/json(?:;[^,]*)?,/i;
 const SOURCEMAP_REGEX =
   /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/;
@@ -83,13 +83,42 @@ interface SourceMapResult {
 
 class TransientSourceMapError extends Error {}
 
-const _pendingSourceMapRequests = new Map<string, Promise<SourceMapResult>>();
+const pendingSourceMapRequests = new Map<string, Promise<SourceMapResult>>();
 const pendingSourceMapRequestsByFetch = new WeakMap<
   SourceFetch,
   Map<string, Promise<SourceMapResult>>
 >();
 const defaultMaxBundleSizeBytes = 25 * 1024 * 1024;
 const defaultMaxSourceMapSizeBytes = 100 * 1024 * 1024;
+const extensionProtocols = new Set([
+  "chrome-extension:",
+  "moz-extension:",
+  "safari-web-extension:",
+]);
+const defaultFetchableProtocols = new Set(["http:", "https:", ...extensionProtocols]);
+
+const getSourceFromSegment = (
+  segment: SourceMapSegment,
+  sources: string[],
+  ignoredSourceIndices?: Set<number>,
+  names?: string[],
+): StackFrame | null => {
+  const [, sourceIndex, sourceLine, sourceColumn, nameIndex] = segment;
+  if (sourceIndex === undefined || sourceLine === undefined || sourceColumn === undefined) {
+    return null;
+  }
+
+  const fileName = sources[sourceIndex];
+  if (!fileName) return null;
+
+  return {
+    columnNumber: sourceColumn,
+    fileName,
+    functionName: nameIndex === undefined ? undefined : names?.[nameIndex] || undefined,
+    isIgnoreListed: ignoredSourceIndices?.has(sourceIndex) ?? false,
+    lineNumber: sourceLine + 1,
+  };
+};
 
 const getSourceFromMappings = (
   mappings: SourceMapMappings,
@@ -97,6 +126,7 @@ const getSourceFromMappings = (
   lineIndexInMappings: number,
   column: number,
   ignoredSourceIndices?: Set<number>,
+  names?: string[],
 ): StackFrame | null => {
   if (lineIndexInMappings < 0 || lineIndexInMappings >= mappings.length) {
     return null;
@@ -124,24 +154,7 @@ const getSourceFromMappings = (
     return null;
   }
 
-  const [, sourceIndex, sourceLine, sourceColumn] = closestLineSegment;
-
-  if (sourceIndex === undefined || sourceLine === undefined || sourceColumn === undefined) {
-    return null;
-  }
-
-  const fileName = sources[sourceIndex];
-
-  if (!fileName) {
-    return null;
-  }
-
-  return {
-    columnNumber: sourceColumn,
-    fileName,
-    lineNumber: sourceLine + 1,
-    isIgnoreListed: ignoredSourceIndices?.has(sourceIndex) ?? false,
-  };
+  return getSourceFromSegment(closestLineSegment, sources, ignoredSourceIndices, names);
 };
 
 export const getSourceFromSourceMap = (
@@ -178,6 +191,7 @@ export const getSourceFromSourceMap = (
       relativeLine,
       relativeColumn,
       targetSection.map.ignoredSourceIndices,
+      targetSection.map.names,
     );
   }
 
@@ -187,9 +201,97 @@ export const getSourceFromSourceMap = (
     line - 1,
     column,
     sourceMap.ignoredSourceIndices,
+    sourceMap.names,
+  );
+};
+
+const getSourceFromMappingsByFunctionName = (
+  mappings: SourceMapMappings,
+  sources: string[],
+  names: string[] | undefined,
+  functionName: string,
+  ignoredSourceIndices?: Set<number>,
+): StackFrame | null => {
+  if (!names) return null;
+  const functionNameIndex = names.indexOf(functionName);
+  if (functionNameIndex === -1) return null;
+
+  let ignoredSource: StackFrame | null = null;
+  for (const lineMapping of mappings) {
+    for (const segment of lineMapping) {
+      if (segment[4] !== functionNameIndex) continue;
+      const source = getSourceFromSegment(segment, sources, ignoredSourceIndices, names);
+      if (!source) continue;
+      if (!source.isIgnoreListed) return source;
+      ignoredSource ??= source;
+    }
+  }
+  return ignoredSource;
+};
+
+export const getSourceFromSourceMapByFunctionName = (
+  sourceMap: SourceMap,
+  functionName: string,
+): StackFrame | null => {
+  if (sourceMap.sections) {
+    let ignoredSource: StackFrame | null = null;
+    for (const section of sourceMap.sections) {
+      const source = getSourceFromMappingsByFunctionName(
+        section.map.mappings,
+        section.map.sources,
+        section.map.names,
+        functionName,
+        section.map.ignoredSourceIndices,
+      );
+      if (!source) continue;
+      if (!source.isIgnoreListed) return source;
+      ignoredSource ??= source;
+    }
+    return ignoredSource;
+  }
+
+  return getSourceFromMappingsByFunctionName(
+    sourceMap.mappings,
+    sourceMap.sources,
+    sourceMap.names,
+    functionName,
+    sourceMap.ignoredSourceIndices,
   );
 };
 
+const findSourceContentByFileName = (
+  sources: string[],
+  sourcesContent: Array<string | null> | undefined,
+  fileName: string,
+): string | null => {
+  if (!sourcesContent) return null;
+  const sourceIndex = sources.indexOf(fileName);
+  return sourceIndex === -1 ? null : (sourcesContent[sourceIndex] ?? null);
+};
+
+export const getSourceContentFromSourceMap = (
+  sourceMap: SourceMap,
+  originalFileName: string,
+): string | null => {
+  const sourceContent = findSourceContentByFileName(
+    sourceMap.sources,
+    sourceMap.sourcesContent,
+    originalFileName,
+  );
+  if (sourceContent !== null) return sourceContent;
+
+  if (!sourceMap.sections) return null;
+  for (const section of sourceMap.sections) {
+    const sectionSourceContent = findSourceContentByFileName(
+      section.map.sources,
+      section.map.sourcesContent,
+      originalFileName,
+    );
+    if (sectionSourceContent !== null) return sectionSourceContent;
+  }
+  return null;
+};
+
 const resolveUrl = (reference: string, baseUrl: string): string | null => {
   if (INLINE_SOURCEMAP_REGEX.test(reference)) return reference;
   try {
@@ -204,12 +306,43 @@ const resolveUrl = (reference: string, baseUrl: string): string | null => {
   }
 };
 
-const getSourceMapUrl = (url: string, content: string): null | string => {
+const getMetroSourceMapUrl = (bundleUrl: string): string | null => {
+  try {
+    const parsedBundleUrl = new URL(bundleUrl);
+    const bundleExtensionIndex = parsedBundleUrl.pathname.lastIndexOf(".bundle");
+    if (bundleExtensionIndex === -1) return null;
+    const embeddedSearch = parsedBundleUrl.pathname.slice(bundleExtensionIndex + ".bundle".length);
+    if (embeddedSearch && !embeddedSearch.startsWith("//&")) return null;
+    parsedBundleUrl.pathname = `${parsedBundleUrl.pathname.slice(0, bundleExtensionIndex)}.map`;
+    if (embeddedSearch) {
+      const embeddedSearchParameters = new URLSearchParams(embeddedSearch.slice("//&".length));
+      for (const [parameterName, parameterValue] of embeddedSearchParameters) {
+        parsedBundleUrl.searchParams.set(parameterName, parameterValue);
+      }
+    }
+    parsedBundleUrl.hash = "";
+    return parsedBundleUrl.toString();
+  } catch {
+    return null;
+  }
+};
+
+const getSourceMapUrl = (
+  bundleUrl: string,
+  bundleContent: string,
+  bundleResponse: Response,
+): null | string => {
+  const sourceMapHeader =
+    bundleResponse.headers.get("sourcemap") ?? bundleResponse.headers.get("x-sourcemap");
+  if (sourceMapHeader) {
+    return resolveUrl(sourceMapHeader.trim(), bundleUrl);
+  }
+
   let sourceMapUrl: string | undefined;
-  let searchEnd = content.length;
+  let searchEnd = bundleContent.length;
   while (searchEnd > 0 && !sourceMapUrl) {
-    const lineStart = content.lastIndexOf("\n", searchEnd - 1) + 1;
-    const regexMatch = content.slice(lineStart, searchEnd).match(SOURCEMAP_REGEX);
+    const lineStart = bundleContent.lastIndexOf("\n", searchEnd - 1) + 1;
+    const regexMatch = bundleContent.slice(lineStart, searchEnd).match(SOURCEMAP_REGEX);
     if (regexMatch) {
       sourceMapUrl = regexMatch[1] || regexMatch[2];
     }
@@ -217,70 +350,82 @@ const getSourceMapUrl = (url: string, content: string): null | string => {
   }
 
   if (!sourceMapUrl) {
-    return null;
+    return getMetroSourceMapUrl(bundleUrl);
   }
 
-  return resolveUrl(sourceMapUrl, url);
+  return resolveUrl(sourceMapUrl, bundleUrl);
 };
 
-const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
-const isStringArray = (value: unknown): value is string[] =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string");
-
-const isSourcesContent = (value: unknown): value is Array<string | null> =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string" || entry === null);
-
-const isOptionalNumberArray = (value: unknown): value is number[] | undefined =>
-  value === undefined ||
-  (Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0));
-
 const isStandardSourceMap = (value: unknown): value is StandardSourceMap => {
-  if (!isObjectRecord(value)) return false;
+  if (typeof value !== "object" || value === null) return false;
+  const version = Reflect.get(value, "version");
+  const mappings = Reflect.get(value, "mappings");
+  const file = Reflect.get(value, "file");
+  const names = Reflect.get(value, "names");
+  const sourceRoot = Reflect.get(value, "sourceRoot");
+  const sources = Reflect.get(value, "sources");
+  const sourcesContent = Reflect.get(value, "sourcesContent");
+  const ignoreList = Reflect.get(value, "ignoreList");
+  const googleIgnoreList = Reflect.get(value, "x_google_ignoreList");
   if (
-    value.version !== 3 ||
-    typeof value.mappings !== "string" ||
-    (value.file !== undefined && typeof value.file !== "string") ||
-    (value.names !== undefined && !isStringArray(value.names)) ||
-    (value.sourceRoot !== undefined && typeof value.sourceRoot !== "string") ||
-    (value.sourcesContent !== undefined && !isSourcesContent(value.sourcesContent)) ||
-    !isOptionalNumberArray(value.ignoreList) ||
-    !isOptionalNumberArray(value.x_google_ignoreList)
+    version !== 3 ||
+    typeof mappings !== "string" ||
+    (file !== undefined && typeof file !== "string") ||
+    (names !== undefined &&
+      (!Array.isArray(names) || names.some((entry) => typeof entry !== "string"))) ||
+    (sourceRoot !== undefined && typeof sourceRoot !== "string") ||
+    (sourcesContent !== undefined &&
+      (!Array.isArray(sourcesContent) ||
+        sourcesContent.some((entry) => typeof entry !== "string" && entry !== null))) ||
+    (ignoreList !== undefined &&
+      (!Array.isArray(ignoreList) ||
+        ignoreList.some((entry) => !Number.isInteger(entry) || entry < 0))) ||
+    (googleIgnoreList !== undefined &&
+      (!Array.isArray(googleIgnoreList) ||
+        googleIgnoreList.some((entry) => !Number.isInteger(entry) || entry < 0)))
   ) {
     return false;
   }
-  if (!isStringArray(value.sources)) return false;
-  if (value.sourcesContent && value.sourcesContent.length !== value.sources.length) return false;
-  const sourceCount = value.sources.length;
-  return [...(value.ignoreList ?? []), ...(value.x_google_ignoreList ?? [])].every(
+  if (!Array.isArray(sources) || sources.some((entry) => typeof entry !== "string")) return false;
+  if (sourcesContent && sourcesContent.length !== sources.length) return false;
+  const sourceCount = sources.length;
+  return [...(ignoreList ?? []), ...(googleIgnoreList ?? [])].every(
     (sourceIndex) => sourceIndex < sourceCount,
   );
 };
 
 const isIndexSourceMap = (value: unknown): value is IndexSourceMap => {
-  if (!isObjectRecord(value) || value.version !== 3 || !Array.isArray(value.sections)) {
+  if (typeof value !== "object" || value === null) return false;
+  const version = Reflect.get(value, "version");
+  const sections = Reflect.get(value, "sections");
+  if (version !== 3 || !Array.isArray(sections)) {
     return false;
   }
-  return value.sections.every((section) => {
-    if (!isObjectRecord(section) || !isObjectRecord(section.offset)) return false;
-    const hasMap = isStandardSourceMap(section.map);
-    const hasUrl = typeof section.url === "string" && section.url.length > 0;
+  return sections.every((section: unknown) => {
+    if (typeof section !== "object" || section === null) return false;
+    const map = Reflect.get(section, "map");
+    const url = Reflect.get(section, "url");
+    const offset = Reflect.get(section, "offset");
+    if (typeof offset !== "object" || offset === null) return false;
+    const offsetColumn = Reflect.get(offset, "column");
+    const offsetLine = Reflect.get(offset, "line");
+    const hasMap = isStandardSourceMap(map);
+    const hasUrl = typeof url === "string" && url.length > 0;
     return (
       hasMap !== hasUrl &&
-      typeof section.offset.column === "number" &&
-      Number.isInteger(section.offset.column) &&
-      section.offset.column >= 0 &&
-      typeof section.offset.line === "number" &&
-      Number.isInteger(section.offset.line) &&
-      section.offset.line >= 0
+      typeof offsetColumn === "number" &&
+      Number.isInteger(offsetColumn) &&
+      offsetColumn >= 0 &&
+      typeof offsetLine === "number" &&
+      Number.isInteger(offsetLine) &&
+      offsetLine >= 0
     );
   });
 };
 
 const getIgnoredSourceIndices = (rawSourceMap: StandardSourceMap): Set<number> | undefined => {
   const ignoreList = rawSourceMap.ignoreList ?? rawSourceMap.x_google_ignoreList;
-  return Array.isArray(ignoreList) && ignoreList.length > 0 ? new Set(ignoreList) : undefined;
+  return ignoreList?.length ? new Set(ignoreList) : undefined;
 };
 
 const resolveSourceRoot = (
@@ -394,7 +539,7 @@ const decodeIndexSourceMap = async (
   };
 };
 
-const isFetchableUrl = (url: string): boolean => {
+const isFetchableUrl = (url: string, shouldAllowCustomProtocol = false): boolean => {
   if (!url) {
     return false;
   }
@@ -413,7 +558,7 @@ const isFetchableUrl = (url: string): boolean => {
 
   const scheme = schemeMatch[0].toLowerCase();
 
-  return scheme === "http:" || scheme === "https:";
+  return shouldAllowCustomProtocol || defaultFetchableProtocols.has(scheme);
 };
 
 const isServerRuntime = (): boolean =>
@@ -434,14 +579,53 @@ const isAbsoluteHttpUrl = (url: string): boolean => {
   }
 };
 
+const getUrlProtocol = (url: string): string | null => {
+  try {
+    return new URL(url).protocol;
+  } catch {
+    return null;
+  }
+};
+
+const isExtensionUrl = (url: string): boolean => {
+  const protocol = getUrlProtocol(url);
+  return protocol !== null && extensionProtocols.has(protocol);
+};
+
 const isSameOrigin = (firstUrl: string, secondUrl: string): boolean => {
   try {
-    return new URL(firstUrl).origin === new URL(secondUrl).origin;
+    const firstParsedUrl = new URL(firstUrl);
+    const secondParsedUrl = new URL(secondUrl);
+    return (
+      firstParsedUrl.protocol === secondParsedUrl.protocol &&
+      firstParsedUrl.host === secondParsedUrl.host
+    );
   } catch {
     return false;
   }
 };
 
+const isAllowedSourceMapUrl = (
+  bundleUrl: string,
+  sourceMapUrl: string,
+  shouldRejectCrossOrigin: boolean,
+  shouldAllowCustomProtocol: boolean,
+): boolean => {
+  if (INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return true;
+  if (!isFetchableUrl(sourceMapUrl, shouldAllowCustomProtocol)) return false;
+  const bundleProtocol = getUrlProtocol(bundleUrl);
+  const sourceMapProtocol = getUrlProtocol(sourceMapUrl);
+  const hasCustomProtocol =
+    (bundleProtocol !== null && !defaultFetchableProtocols.has(bundleProtocol)) ||
+    (sourceMapProtocol !== null && !defaultFetchableProtocols.has(sourceMapProtocol));
+  const shouldRequireSameOrigin =
+    shouldRejectCrossOrigin ||
+    hasCustomProtocol ||
+    isExtensionUrl(bundleUrl) ||
+    isExtensionUrl(sourceMapUrl);
+  return !shouldRequireSameOrigin || isSameOrigin(bundleUrl, sourceMapUrl);
+};
+
 const isTransientHttpStatus = (status: number): boolean =>
   status === 408 || status === 425 || status === 429 || status >= 500;
 
@@ -453,14 +637,21 @@ const assertResponseIsCacheable = (response: Response): boolean => {
   return false;
 };
 
+const isResponseUrlAllowed = (
+  requestedUrl: string,
+  response: Response,
+  shouldRejectCrossOrigin: boolean,
+): boolean =>
+  !shouldRejectCrossOrigin || response.url.length === 0 || isSameOrigin(requestedUrl, response.url);
+
 interface RequestSignal {
   cleanup: () => void;
   signal?: AbortSignal;
 }
 
 const createRequestSignal = (options: SourceMapRequestOptions): RequestSignal => {
-  if (!options.signal && options.timeoutMs === undefined) {
-    return { cleanup: () => {} };
+  if (options.timeoutMs === undefined || options.timeoutMs < 0) {
+    return { cleanup: () => {}, signal: options.signal };
   }
   const abortController = new AbortController();
   const abortFromSource = (): void => abortController.abort(options.signal?.reason);
@@ -469,16 +660,13 @@ const createRequestSignal = (options: SourceMapRequestOptions): RequestSignal =>
   } else {
     options.signal?.addEventListener("abort", abortFromSource, { once: true });
   }
-  const timeoutHandle =
-    options.timeoutMs !== undefined && options.timeoutMs >= 0
-      ? setTimeout(
-          () => abortController.abort(new BippySourceMapError("Source map request timed out")),
-          options.timeoutMs,
-        )
-      : undefined;
+  const timeoutHandle = setTimeout(
+    () => abortController.abort(new BippySourceMapError("Source map request timed out")),
+    options.timeoutMs,
+  );
   return {
     cleanup: () => {
-      if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
+      clearTimeout(timeoutHandle);
       options.signal?.removeEventListener("abort", abortFromSource);
     },
     signal: abortController.signal,
@@ -491,7 +679,10 @@ const readResponseText = async (
 ): Promise<string | null> => {
   const contentLength = Number(response.headers.get("content-length"));
   if (Number.isFinite(contentLength) && contentLength > maxSizeBytes) return null;
-  if (!response.body) return "";
+  if (!response.body) {
+    const responseText = await response.text();
+    return new TextEncoder().encode(responseText).byteLength > maxSizeBytes ? null : responseText;
+  }
 
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -579,6 +770,7 @@ const readSourceMapDocument = async (
     signal,
   });
   if (!assertResponseIsCacheable(sourceMapResponse)) return null;
+  if (!isResponseUrlAllowed(sourceMapUrl, sourceMapResponse, shouldRejectRedirects)) return null;
   const sourceMapContent = await readResponseText(sourceMapResponse, maxSizeBytes);
   if (sourceMapContent === null) return null;
   try {
@@ -593,13 +785,15 @@ const getSourceMapUncachedInternal = async (
   fetchFn?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  if (!isFetchableUrl(bundleUrl)) {
+  const shouldAllowCustomProtocol = fetchFn !== undefined;
+  if (!isFetchableUrl(bundleUrl, shouldAllowCustomProtocol)) {
     return null;
   }
 
-  const shouldRejectRedirects = isServerRuntime();
-  if (shouldRejectRedirects) {
-    if ((!fetchFn && !options.allowUnsafeServerFetch) || !isAbsoluteHttpUrl(bundleUrl)) return null;
+  const isServer = isServerRuntime();
+  const shouldRejectRedirects = isServer || isExtensionUrl(bundleUrl);
+  if (isServer && !fetchFn) {
+    if (!options.allowUnsafeServerFetch || !isAbsoluteHttpUrl(bundleUrl)) return null;
   }
 
   const sourceFetch =
@@ -616,15 +810,18 @@ const getSourceMapUncachedInternal = async (
       signal: requestSignal.signal,
     });
     if (!assertResponseIsCacheable(bundleResponse)) return null;
+    if (!isResponseUrlAllowed(bundleUrl, bundleResponse, shouldRejectRedirects)) return null;
     const bundleContent = await readResponseText(bundleResponse, maxBundleSizeBytes);
-    if (!bundleContent) return null;
-    const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent);
+    if (bundleContent === null) return null;
+    const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent, bundleResponse);
     if (!sourceMapUrl) return null;
-    if (!isFetchableUrl(sourceMapUrl) && !INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return null;
     if (
-      shouldRejectRedirects &&
-      !INLINE_SOURCEMAP_REGEX.test(sourceMapUrl) &&
-      !isSameOrigin(bundleUrl, sourceMapUrl)
+      !isAllowedSourceMapUrl(
+        bundleUrl,
+        sourceMapUrl,
+        shouldRejectRedirects,
+        shouldAllowCustomProtocol,
+      )
     ) {
       return null;
     }
@@ -642,9 +839,12 @@ const getSourceMapUncachedInternal = async (
     if (!isIndexSourceMap(rawSourceMap)) return null;
     return decodeIndexSourceMap(rawSourceMap, sourceMapUrl, async (sectionUrl) => {
       if (
-        shouldRejectRedirects &&
-        !INLINE_SOURCEMAP_REGEX.test(sectionUrl) &&
-        !isSameOrigin(bundleUrl, sectionUrl)
+        !isAllowedSourceMapUrl(
+          bundleUrl,
+          sectionUrl,
+          shouldRejectRedirects,
+          shouldAllowCustomProtocol,
+        )
       ) {
         return null;
       }
@@ -675,27 +875,27 @@ export const getSourceMapUncached = async (
   }
 };
 
-const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> => {
-  if (!fetchFn) return sourceMapCache;
-  let cache = sourceMapCachesByFetch.get(fetchFn);
-  if (!cache) {
-    cache = new Map();
-    sourceMapCachesByFetch.set(fetchFn, cache);
-  }
-  return cache;
+const getPerFetchMap = <Value>(
+  mapsByFetch: WeakMap<SourceFetch, Map<string, Value>>,
+  globalMap: Map<string, Value>,
+  fetchFn: SourceFetch | undefined,
+): Map<string, Value> => {
+  if (!fetchFn) return globalMap;
+  let map = mapsByFetch.get(fetchFn);
+  if (!map) {
+    map = new Map();
+    mapsByFetch.set(fetchFn, map);
+  }
+  return map;
 };
 
+const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> =>
+  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, fetchFn);
+
 const getPendingSourceMapRequests = (
   fetchFn: SourceFetch | undefined,
-): Map<string, Promise<SourceMapResult>> => {
-  if (!fetchFn) return _pendingSourceMapRequests;
-  let pendingRequests = pendingSourceMapRequestsByFetch.get(fetchFn);
-  if (!pendingRequests) {
-    pendingRequests = new Map();
-    pendingSourceMapRequestsByFetch.set(fetchFn, pendingRequests);
-  }
-  return pendingRequests;
-};
+): Map<string, Promise<SourceMapResult>> =>
+  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, fetchFn);
 
 const getSourceMapCacheKey = (file: string, options: SourceMapRequestOptions): string =>
   options.allowUnsafeServerFetch === undefined &&
@@ -750,7 +950,7 @@ export const getSourceMap = async (
 export const symbolicateStack = async (
   stack: StackFrame[],
   cache = true,
-  fetchFn?: (url: string) => Promise<Response>,
+  fetchFn?: SourceFetch,
 ): Promise<StackFrame[]> => {
   return Promise.all(
     stack.map(async (stackFrame) => {
@@ -776,6 +976,7 @@ export const symbolicateStack = async (
             ? stackFrame.source.replace(stackFrame.fileName, symbolicatedSource.fileName)
             : stackFrame.source,
         fileName: symbolicatedSource.fileName,
+        functionName: symbolicatedSource.functionName ?? stackFrame.functionName,
         lineNumber: symbolicatedSource.lineNumber,
         columnNumber: symbolicatedSource.columnNumber,
         isIgnoreListed: symbolicatedSource.isIgnoreListed,