bippy 0.7.2 → 0.7.3-dev.0ac832d

package/src/source/parse-debug-stack.ts

@@ -1,6 +1,6 @@
 import { JSX_FACTORY_FRAME_COUNT, REACT_STACK_BOTTOM_FRAME_PATTERNS } from "./constants.js";
 import { getPrepareStackTrace, setPrepareStackTrace } from "./error-stack.js";
-import { parseStack, StackFrame } from "./parse-stack.js";
+import { parseStack, type StackFrame } from "./parse-stack.js";
 
 interface V8CallSite {
   getFunctionName?: () => string | null;

package/src/source/parse-hook-names.ts

@@ -4,6 +4,7 @@ import {
   getSourceFromSourceMap,
   getSourceMap,
   type SourceFetch,
+  type SourceMapRequestOptions,
 } from "./symbolication.js";
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -19,8 +20,10 @@ const UNNAMED_HOOKS = new Set([
 
 // HACK: matches `const/let/var [name, ...] = use...(...` or `const/let/var name = use...(...`
 // across up to 10 lines; handles TypeScript generics like `useState<T>(`
+// The member-access prefix consumes one dotless segment per repetition. Letting a segment
+// span dots too would make the parse ambiguous and backtrack exponentially on long chains.
 const HOOK_DECLARATION_REGEX =
-  /(?:const|let|var)\s+((?:\[[\s\S]*?\]|\w+))\s*=\s*(?:[\w$.]+\.)*use[A-Z]\w*\s*(?:<[\s\S]*?>)?\s*\(/g;
+  /(?:const|let|var)\s+((?:\[[\s\S]*?\]|\w+))\s*=\s*(?:(?:[\w$]+|require\s*\([^)]*\))\.)*use[A-Z]\w*\s*(?:<[\s\S]*?>)?\s*\(/g;
 
 export const getHookSourceLocationKey = (hookSource: HookSource): string =>
   `${hookSource.fileName ?? ""}:${hookSource.lineNumber ?? 0}:${hookSource.columnNumber ?? 0}`;
@@ -63,12 +66,13 @@ export const extractHookVariableName = (
 
   const allMatches = [...sourceChunk.matchAll(HOOK_DECLARATION_REGEX)];
 
-  const hookPositionInChunk = sourceChunk.lastIndexOf("\n") + 1 + columnNumber;
-  const closestMatch = allMatches.filter((match) => match.index! <= hookPositionInChunk).at(-1);
+  const hookLineStart = sourceChunk.lastIndexOf("\n") + 1;
+  const hookPositionInChunk = hookLineStart + columnNumber;
+  const closestMatch =
+    allMatches.filter((match) => match.index! <= hookPositionInChunk).at(-1) ??
+    (columnNumber === 0 ? allMatches.find((match) => match.index! >= hookLineStart) : undefined);
 
-  if (closestMatch) {
-    return extractVariableNameFromBinding(closestMatch[1]);
-  }
+  if (closestMatch) return extractVariableNameFromBinding(closestMatch[1]);
 
   return null;
 };
@@ -82,6 +86,7 @@ interface ResolvedSource {
 interface SourceResolutionContext {
   sourceContentCache: Map<string, string | null>;
   fetchFn?: SourceFetch;
+  requestOptions?: SourceMapRequestOptions;
 }
 
 const resolveOriginalSource = async (
@@ -90,9 +95,9 @@ const resolveOriginalSource = async (
   runtimeColumn: number,
   context: SourceResolutionContext,
 ): Promise<ResolvedSource | null> => {
-  const { sourceContentCache, fetchFn } = context;
+  const { sourceContentCache, fetchFn, requestOptions } = context;
 
-  const sourceMap = await getSourceMap(runtimeFileName, true, fetchFn);
+  const sourceMap = await getSourceMap(runtimeFileName, true, fetchFn, requestOptions);
 
   if (sourceMap) {
     const originalLocation = getSourceFromSourceMap(sourceMap, runtimeLine, runtimeColumn);
@@ -136,6 +141,7 @@ const resolveOriginalSource = async (
 export const parseHookNames = async (
   hooksTree: HooksTree,
   fetchFn?: SourceFetch,
+  requestOptions?: SourceMapRequestOptions,
 ): Promise<HookNames> => {
   const hookNames: HookNames = new Map();
   const hooksList = flattenHooksTree(hooksTree);
@@ -145,6 +151,7 @@ export const parseHookNames = async (
   const resolutionContext: SourceResolutionContext = {
     sourceContentCache: new Map(),
     fetchFn,
+    requestOptions,
   };
 
   await Promise.all(

package/src/source/parse-stack.ts

@@ -28,14 +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 .*\)$/, "");
+        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;
@@ -46,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] => {
@@ -57,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);
+  };
 };

package/src/source/renderer-dispatchers.ts

@@ -1,9 +1,14 @@
 import type { RendererDispatcherRef } from "../react-internals/index.js";
-import { _renderers, getRDTHook } from "../rdt-hook.js";
+import { _renderers, getRDTHook, isRendererMap } from "../rdt-hook.js";
+import type { ReactDevToolsTarget } from "../rdt-hook.js";
 
-export const getRendererDispatcherRefs = (): RendererDispatcherRef[] => {
-  const rdtHook = getRDTHook();
-  const renderers = new Set([..._renderers, ...rdtHook.renderers.values()]);
+export const getRendererDispatcherRefs = (
+  target: ReactDevToolsTarget = globalThis,
+): RendererDispatcherRef[] => {
+  const rdtHook = getRDTHook(undefined, target);
+  const targetRenderers = isRendererMap(rdtHook.renderers) ? rdtHook.renderers.values() : [];
+  const renderers =
+    target === globalThis ? new Set([..._renderers, ...targetRenderers]) : new Set(targetRenderers);
   const currentDispatcherRefs: RendererDispatcherRef[] = [];
   const seenCurrentDispatcherRefs = new Set<object>();
   for (const renderer of renderers) {

package/src/source/symbolication.ts

@@ -39,6 +39,7 @@ export interface SourceFetch {
 }
 
 export interface SourceMapRequestOptions {
+  allowCrossOriginSourceMap?: boolean;
   allowUnsafeServerFetch?: boolean;
   maxBundleSizeBytes?: number;
   maxSourceMapSizeBytes?: number;
@@ -49,6 +50,7 @@ export interface SourceMapRequestOptions {
 export interface SourceMap {
   file?: string;
   ignoredSourceIndices?: Set<number>;
+  sourceMapUrl?: string;
   mappings: SourceMapSegment[][];
   names?: string[];
   sections?: DecodedSourceMapSection[];
@@ -205,6 +207,13 @@ export const getSourceFromSourceMap = (
   );
 };
 
+const getStringIndex = (values: string[], target: string): number => {
+  for (let valueIndex = 0; valueIndex < values.length; valueIndex++) {
+    if (values[valueIndex] === target) return valueIndex;
+  }
+  return -1;
+};
+
 const getSourceFromMappingsByFunctionName = (
   mappings: SourceMapMappings,
   sources: string[],
@@ -213,13 +222,17 @@ const getSourceFromMappingsByFunctionName = (
   ignoredSourceIndices?: Set<number>,
 ): StackFrame | null => {
   if (!names) return null;
-  const functionNameIndex = names.indexOf(functionName);
+  const functionNameIndex = getStringIndex(names, functionName);
   if (functionNameIndex === -1) return null;
 
   let ignoredSource: StackFrame | null = null;
-  for (const lineMapping of mappings) {
-    for (const segment of lineMapping) {
+  for (let lineIndex = 0; lineIndex < mappings.length; lineIndex++) {
+    const lineMapping = mappings[lineIndex];
+    for (let segmentIndex = 0; segmentIndex < lineMapping.length; segmentIndex++) {
+      const segment = lineMapping[segmentIndex];
       if (segment[4] !== functionNameIndex) continue;
+      if (ignoredSource && segment[1] !== undefined && ignoredSourceIndices?.has(segment[1]))
+        continue;
       const source = getSourceFromSegment(segment, sources, ignoredSourceIndices, names);
       if (!source) continue;
       if (!source.isIgnoreListed) return source;
@@ -265,7 +278,7 @@ const findSourceContentByFileName = (
   fileName: string,
 ): string | null => {
   if (!sourcesContent) return null;
-  const sourceIndex = sources.indexOf(fileName);
+  const sourceIndex = getStringIndex(sources, fileName);
   return sourceIndex === -1 ? null : (sourcesContent[sourceIndex] ?? null);
 };
 
@@ -298,10 +311,14 @@ const resolveUrl = (reference: string, baseUrl: string): string | null => {
     return new URL(reference, baseUrl).toString();
   } catch {
     try {
-      const resolvedUrl = new URL(reference, new URL(baseUrl, "https://bippy.invalid/"));
-      return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+      return new URL(reference).toString();
     } catch {
-      return null;
+      try {
+        const resolvedUrl = new URL(reference, new URL(baseUrl, "https://bippy.invalid/"));
+        return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+      } catch {
+        return null;
+      }
     }
   }
 };
@@ -460,6 +477,11 @@ const resolveSourceMapSources = (rawSourceMap: StandardSourceMap, sourceMapUrl:
     resolveSourceRoot(rawSourceMap.sourceRoot, source, sourceMapUrl),
   );
 
+// An inline URL carries the whole encoded map, so retaining it in the cache would
+// double the memory held per source map for the lifetime of the process.
+const getRetainableSourceMapUrl = (sourceMapUrl: string): string | undefined =>
+  INLINE_SOURCEMAP_REGEX.test(sourceMapUrl) ? undefined : sourceMapUrl;
+
 const decodeStandardSourceMap = (
   rawSourceMap: StandardSourceMap,
   sourceMapUrl: string,
@@ -470,6 +492,7 @@ const decodeStandardSourceMap = (
       ignoredSourceIndices: getIgnoredSourceIndices(rawSourceMap),
       mappings: decode(rawSourceMap.mappings),
       names: rawSourceMap.names,
+      sourceMapUrl: getRetainableSourceMapUrl(sourceMapUrl),
       sourceRoot: rawSourceMap.sourceRoot,
       sources: resolveSourceMapSources(rawSourceMap, sourceMapUrl),
       sourcesContent: rawSourceMap.sourcesContent,
@@ -532,6 +555,7 @@ const decodeIndexSourceMap = async (
     mappings: [],
     names: [],
     sections: decodedSections,
+    sourceMapUrl: getRetainableSourceMapUrl(sourceMapUrl),
     sourceRoot: undefined,
     sources: Array.from(allSources),
     sourcesContent: undefined,
@@ -782,22 +806,23 @@ const readSourceMapDocument = async (
 
 const getSourceMapUncachedInternal = async (
   bundleUrl: string,
-  fetchFn?: SourceFetch,
+  sourceFetchOverride?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  const shouldAllowCustomProtocol = fetchFn !== undefined;
+  const shouldAllowCustomProtocol = sourceFetchOverride !== undefined;
   if (!isFetchableUrl(bundleUrl, shouldAllowCustomProtocol)) {
     return null;
   }
 
   const isServer = isServerRuntime();
-  const shouldRejectRedirects = isServer || isExtensionUrl(bundleUrl);
-  if (isServer && !fetchFn) {
+  const shouldRejectRedirects =
+    (isServer || isExtensionUrl(bundleUrl)) && !options.allowCrossOriginSourceMap;
+  if (isServer && !sourceFetchOverride) {
     if (!options.allowUnsafeServerFetch || !isAbsoluteHttpUrl(bundleUrl)) return null;
   }
 
   const sourceFetch =
-    fetchFn ??
+    sourceFetchOverride ??
     (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
   if (!sourceFetch) return null;
   const maxBundleSizeBytes = options.maxBundleSizeBytes ?? defaultMaxBundleSizeBytes;
@@ -864,11 +889,11 @@ const getSourceMapUncachedInternal = async (
 
 export const getSourceMapUncached = async (
   bundleUrl: string,
-  fetchFn?: SourceFetch,
+  sourceFetch?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
   try {
-    return await getSourceMapUncachedInternal(bundleUrl, fetchFn, options);
+    return await getSourceMapUncachedInternal(bundleUrl, sourceFetch, options);
   } catch (error) {
     if (error instanceof TransientSourceMapError) return null;
     throw error;
@@ -878,66 +903,67 @@ export const getSourceMapUncached = async (
 const getPerFetchMap = <Value>(
   mapsByFetch: WeakMap<SourceFetch, Map<string, Value>>,
   globalMap: Map<string, Value>,
-  fetchFn: SourceFetch | undefined,
+  sourceFetch: SourceFetch | undefined,
 ): Map<string, Value> => {
-  if (!fetchFn) return globalMap;
-  let map = mapsByFetch.get(fetchFn);
+  if (!sourceFetch) return globalMap;
+  let map = mapsByFetch.get(sourceFetch);
   if (!map) {
     map = new Map();
-    mapsByFetch.set(fetchFn, map);
+    mapsByFetch.set(sourceFetch, map);
   }
   return map;
 };
 
-const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> =>
-  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, fetchFn);
+const getSourceMapCache = (sourceFetch: SourceFetch | undefined): Map<string, null | SourceMap> =>
+  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, sourceFetch);
 
 const getPendingSourceMapRequests = (
-  fetchFn: SourceFetch | undefined,
+  sourceFetch: SourceFetch | undefined,
 ): Map<string, Promise<SourceMapResult>> =>
-  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, fetchFn);
+  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, sourceFetch);
 
 const getSourceMapCacheKey = (file: string, options: SourceMapRequestOptions): string =>
+  options.allowCrossOriginSourceMap === undefined &&
   options.allowUnsafeServerFetch === undefined &&
   options.maxBundleSizeBytes === undefined &&
   options.maxSourceMapSizeBytes === undefined &&
   options.timeoutMs === undefined
     ? file
-    : `${file}\0${options.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
+    : `${file}\0${options.allowCrossOriginSourceMap ?? ""}\0${options.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
 
 export const getSourceMap = async (
   file: string,
-  useCache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  const shouldUseCache = useCache && options.signal === undefined;
-  const cache = getSourceMapCache(fetchFn);
-  const pendingRequests = getPendingSourceMapRequests(fetchFn);
+  const canUseCache = shouldUseCache && options.signal === undefined;
+  const cache = getSourceMapCache(sourceFetch);
+  const pendingRequests = getPendingSourceMapRequests(sourceFetch);
   const cacheKey = getSourceMapCacheKey(file, options);
-  if (shouldUseCache && cache.has(cacheKey)) {
+  if (canUseCache && cache.has(cacheKey)) {
     return cache.get(cacheKey) ?? null;
   }
 
-  const pendingRequest = shouldUseCache ? pendingRequests.get(cacheKey) : undefined;
+  const pendingRequest = canUseCache ? pendingRequests.get(cacheKey) : undefined;
   if (pendingRequest) {
     return (await pendingRequest).sourceMap;
   }
 
   const fetchPromise: Promise<SourceMapResult> = getSourceMapUncachedInternal(
     file,
-    fetchFn,
+    sourceFetch,
     options,
   ).then(
     (sourceMap) => ({ sourceMap, isTransientFailure: false }),
     () => ({ sourceMap: null, isTransientFailure: true }),
   );
-  if (shouldUseCache) {
+  if (canUseCache) {
     pendingRequests.set(cacheKey, fetchPromise);
   }
 
   const { sourceMap, isTransientFailure } = await fetchPromise;
-  if (shouldUseCache) {
+  if (canUseCache) {
     pendingRequests.delete(cacheKey);
     if (!isTransientFailure) {
       cache.set(cacheKey, sourceMap);
@@ -949,13 +975,19 @@ export const getSourceMap = async (
 
 export const symbolicateStack = async (
   stack: StackFrame[],
-  cache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
 ): Promise<StackFrame[]> => {
   return Promise.all(
     stack.map(async (stackFrame) => {
       if (!stackFrame.fileName) return stackFrame;
-      const sourceMap = await getSourceMap(stackFrame.fileName, cache, fetchFn);
+      const sourceMap = await getSourceMap(
+        stackFrame.fileName,
+        shouldUseCache,
+        sourceFetch,
+        requestOptions,
+      );
       if (
         !sourceMap ||
         typeof stackFrame.lineNumber !== "number" ||