bippy 0.7.3-dev.775b69e → 0.7.3-dev.7d8af8d

package/src/rdt-hook.ts

@@ -1,5 +1,6 @@
 // This module must load before React so renderers can inject into the hook.
 
+import { callListener } from "./call-listener.js";
 import type { FiberRoot, ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
 
 export interface Unsubscribe extends Disposable {
@@ -23,6 +24,10 @@ interface RDTHookReplaceListener {
   (rdtHook: ReactDevToolsGlobalHook, target: ReactDevToolsTarget): void;
 }
 
+interface RDTHookReplaceSubscription {
+  listener: RDTHookReplaceListener;
+}
+
 export interface ReactDevToolsTarget {
   __REACT_DEVTOOLS_GLOBAL_HOOK__?: ReactDevToolsGlobalHook;
 }
@@ -93,7 +98,7 @@ export const _renderers = new Set<ReactRenderer>();
 
 const activeListenerTargets = new WeakMap<ActiveListener, Set<ReactDevToolsTarget>>();
 const rendererInjectSubscriptions = new Set<RendererInjectSubscription>();
-const rdtHookReplaceListeners = new Set<RDTHookReplaceListener>();
+const rdtHookReplaceSubscriptions = new Set<RDTHookReplaceSubscription>();
 const notifiedRenderersByTarget = new WeakMap<ReactDevToolsTarget, WeakSet<ReactRenderer>>();
 
 const addActiveListener = (listener: ActiveListener, target: ReactDevToolsTarget): void => {
@@ -115,9 +120,12 @@ export const removeActiveListener = (
   }
 };
 
-const notifyActiveListeners = (target: ReactDevToolsTarget): void => {
-  for (const listener of _onActiveListeners) {
-    if (activeListenerTargets.get(listener)?.has(target)) listener();
+const notifyActiveListeners = (
+  target: ReactDevToolsTarget,
+  pendingListeners = [..._onActiveListeners],
+): void => {
+  for (const listener of pendingListeners) {
+    if (activeListenerTargets.get(listener)?.has(target)) callListener(listener, undefined);
   }
 };
 
@@ -125,8 +133,11 @@ const notifyRendererInjectListeners = (
   target: ReactDevToolsTarget,
   renderer: ReactRenderer,
 ): void => {
-  for (const subscription of rendererInjectSubscriptions) {
-    if (subscription.target === target) subscription.listener(renderer);
+  const subscriptionSnapshot = [...rendererInjectSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rendererInjectSubscriptions.has(subscription) && subscription.target === target) {
+      callListener(subscription.listener, subscription, renderer);
+    }
   }
 };
 
@@ -134,8 +145,11 @@ const notifyRDTHookReplaceListeners = (
   rdtHook: ReactDevToolsGlobalHook,
   target: ReactDevToolsTarget,
 ): void => {
-  for (const listener of rdtHookReplaceListeners) {
-    listener(rdtHook, target);
+  const subscriptionSnapshot = [...rdtHookReplaceSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rdtHookReplaceSubscriptions.has(subscription)) {
+      callListener(subscription.listener, undefined, rdtHook, target);
+    }
   }
 };
 
@@ -152,9 +166,10 @@ export const onRendererInject = (
 };
 
 export const onRDTHookReplace = (listener: RDTHookReplaceListener): Unsubscribe => {
-  rdtHookReplaceListeners.add(listener);
+  const subscription = { listener };
+  rdtHookReplaceSubscriptions.add(subscription);
   return createUnsubscribe(() => {
-    rdtHookReplaceListeners.delete(listener);
+    rdtHookReplaceSubscriptions.delete(subscription);
   });
 };
 
@@ -242,10 +257,11 @@ export const installRDTHook = (
             _renderers.add(renderer);
             nextRenderers.set(rendererId, renderer);
           });
-          if (ourRenderers.size > 0 || rdtHookReplaceListeners.size > 0) {
-            patchRDTHook(onActive, target);
+          if (ourRenderers.size > 0 || rdtHookReplaceSubscriptions.size > 0) {
+            patchRDTHook(undefined, target, () => notifyRDTHookReplaceListeners(newHook, target));
+          } else {
+            notifyRDTHookReplaceListeners(newHook, target);
           }
-          notifyRDTHookReplaceListeners(rdtHook, target);
         }
       },
     });
@@ -287,9 +303,10 @@ export const installRDTHook = (
 export const patchRDTHook = (
   onActive?: ActiveListener,
   target: ReactDevToolsTarget = globalThis,
+  onReady?: () => void,
 ): void => {
   if (onActive) addActiveListener(onActive, target);
-  let didNotifyActiveListeners = false;
+  let shouldNotifyActiveListeners = false;
   const rdtHook = getTargetHook(target);
   if (!rdtHook) return;
   const renderers = getRendererMap(rdtHook);
@@ -305,28 +322,25 @@ export const patchRDTHook = (
     if (!isReactDevtools) {
       rdtHook.on = noOp;
     }
-    if (renderers.size) {
-      renderers.forEach((renderer) => _renderers.add(renderer));
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners(target);
-      didNotifyActiveListeners = true;
-    } else if (!isReactDevtools && isReactRefresh(rdtHook)) {
-      // HACK: react-refresh's stub inject never records renderers, so a React app
-      // that injected before bippy loaded is undetectable through the renderers map.
-      // A react-refresh hook implies a dev renderer, so activate immediately.
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners(target);
-      didNotifyActiveListeners = true;
-    }
+    const shouldActivate = renderers.size > 0 || (!isReactDevtools && isReactRefresh(rdtHook));
     const previousInject = rdtHook.inject;
     rdtHook.inject = (renderer) => {
       const rendererId = previousInject.call(rdtHook, renderer);
       trackInjectedRenderer(rdtHook, target, renderers, rendererId, renderer);
       return rendererId;
     };
+    if (shouldActivate) {
+      renderers.forEach((renderer) => _renderers.add(renderer));
+      rdtHook._instrumentationIsActive = true;
+      shouldNotifyActiveListeners = true;
+    }
   }
-  if (!didNotifyActiveListeners && (renderers.size || rdtHook._instrumentationIsActive)) {
-    onActive?.();
+  const pendingListeners = shouldNotifyActiveListeners ? [..._onActiveListeners] : [];
+  onReady?.();
+  if (shouldNotifyActiveListeners) {
+    notifyActiveListeners(target, pendingListeners);
+  } else if (onActive && (renderers.size || rdtHook._instrumentationIsActive)) {
+    callListener(onActive, undefined);
   }
 };
 

package/src/react-internals/generated/react-work-tags.ts

@@ -25,6 +25,9 @@ export const ReactSymbols = {
   DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
   ELEMENT_SYMBOL_STRING: "Symbol(react.transitional.element)",
   LEGACY_ELEMENT_SYMBOL_STRING: "Symbol(react.element)",
+  STRICT_MODE_NUMBER: 60108,
+  STRICT_MODE_SYMBOL_DESCRIPTION: "react.strict_mode",
+  STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)",
 } as const;
 
 export interface ReactWorkTagMap {

package/src/react-internals/index.ts

@@ -18,8 +18,24 @@ export type {
 } from "./generated/react-work-tags.js";
 export * from "./types.js";
 
+interface InheritedWorkTags {
+  workTags: Readonly<ReactWorkTagMap>;
+  generation: number;
+}
+
 const defaultReactWorkTags = getReactWorkTags();
 const fiberReactWorkTags = new WeakMap<Fiber, Readonly<ReactWorkTagMap>>();
+const inheritedFiberWorkTags = new WeakMap<Fiber, InheritedWorkTags>();
+let workTagGeneration = 0;
+
+const getCachedWorkTags = (fiber: Fiber): Readonly<ReactWorkTagMap> | undefined => {
+  const assignedWorkTags = fiberReactWorkTags.get(fiber);
+  if (assignedWorkTags) return assignedWorkTags;
+  const inheritedWorkTags = inheritedFiberWorkTags.get(fiber);
+  return inheritedWorkTags?.generation === workTagGeneration
+    ? inheritedWorkTags.workTags
+    : undefined;
+};
 
 // React's experimental channel historically reported "0.0.0-experimental-<sha>"
 // as the runtime version; those builds use modern work tags, not the 16.x rows
@@ -39,30 +55,36 @@ export const getReactWorkTagsForRenderer = (
 
 export const setReactWorkTagsForFiber = (fiber: Fiber, renderer?: ReactRenderer): void => {
   const workTags = getReactWorkTagsForRenderer(renderer);
+  if (
+    getCachedWorkTags(fiber) !== workTags ||
+    (fiber.alternate && getCachedWorkTags(fiber.alternate) !== workTags)
+  ) {
+    workTagGeneration++;
+  }
   fiberReactWorkTags.set(fiber, workTags);
   if (fiber.alternate) fiberReactWorkTags.set(fiber.alternate, workTags);
 };
 
 export const getReactWorkTagsForFiber = (fiber: Fiber): Readonly<ReactWorkTagMap> => {
-  const cachedWorkTags = fiberReactWorkTags.get(fiber);
-  if (cachedWorkTags) return cachedWorkTags;
-
-  const traversedFibers: Fiber[] = [fiber];
-  let rootFiber = fiber;
-  let workTags = defaultReactWorkTags;
-  while (rootFiber.return) {
-    rootFiber = rootFiber.return;
-    const ancestorWorkTags = fiberReactWorkTags.get(rootFiber);
-    if (ancestorWorkTags) {
-      workTags = ancestorWorkTags;
+  let workTags = getCachedWorkTags(fiber);
+  if (workTags) return workTags;
+  const traversedFibers: Fiber[] = [];
+  let ancestor = fiber;
+  while (!workTags) {
+    traversedFibers.push(ancestor);
+    const parent = ancestor.return;
+    if (!parent) {
+      workTags = inheritedFiberWorkTags.get(ancestor)?.workTags ?? defaultReactWorkTags;
       break;
     }
-    traversedFibers.push(rootFiber);
+    ancestor = parent;
+    workTags = getCachedWorkTags(ancestor);
   }
+  const inheritedWorkTags = { workTags, generation: workTagGeneration };
   for (const traversedFiber of traversedFibers) {
-    fiberReactWorkTags.set(traversedFiber, workTags);
+    inheritedFiberWorkTags.set(traversedFiber, inheritedWorkTags);
     if (traversedFiber.alternate) {
-      fiberReactWorkTags.set(traversedFiber.alternate, workTags);
+      inheritedFiberWorkTags.set(traversedFiber.alternate, inheritedWorkTags);
     }
   }
   return workTags;

package/src/react.ts

@@ -2,6 +2,7 @@ import "./install-hook-only.js";
 import React from "react";
 import { isFiber, traverseFiber } from "./core.js";
 import { _renderers } from "./rdt-hook.js";
+import { getCurrentFiberFromRoot } from "./react-internals/current-fiber.js";
 import type { Fiber } from "./react-internals/index.js";
 
 export type { Fiber } from "./react-internals/index.js";
@@ -115,6 +116,12 @@ const getRenderingFiberFromRoot = (
     return null;
   }
   const renderingRoot = root.current.alternate;
+  const renderingFiber = getCurrentFiberFromRoot(fiber)?.alternate;
+  if (renderingFiber) {
+    let ancestor = renderingFiber;
+    while (ancestor.return) ancestor = ancestor.return;
+    if (ancestor === renderingRoot) return renderingFiber;
+  }
   return traverseFiber(renderingRoot, (candidate) => {
     if (candidate !== fiber && candidate !== fiber.alternate) return false;
     let parent = candidate;
@@ -147,6 +154,9 @@ export const useFiber = (): Fiber | undefined => {
       : knownFiber.alternate && hasRenderMarker(knownFiber.alternate, renderMarker)
         ? knownFiber.alternate
         : getRenderingFiberFromRoot(knownCapture, renderMarker));
-  if (fiber) fiberRef.current = { fiber, queue: knownCapture.queue };
+  if (fiber) {
+    knownCapture.fiber = fiber;
+    fiberRef.current = knownCapture;
+  }
   return fiber ?? undefined;
 };

package/src/source/inspect-hooks.ts

@@ -14,7 +14,7 @@ import {
   BippyUnsupportedHookError,
 } from "../errors.js";
 import { getReactWorkTagsForFiber } from "../react-internals/index.js";
-import { parseStack, type StackFrame } from "./parse-stack.js";
+import { createStackParser, parseStack, type StackFrame } from "./parse-stack.js";
 import {
   getRendererDispatcherRefs,
   readDispatcher,
@@ -604,8 +604,9 @@ const findPrimitiveIndex = (hookStack: StackFrame[], hook: HookLogEntry): number
 const parseTrimmedStack = (
   rootStack: StackFrame[],
   hook: HookLogEntry,
+  parseHookStack: (stack: string) => StackFrame[],
 ): [StackFrame | null, StackFrame[] | null] => {
-  const hookStack = parseErrorStack(hook.stackError);
+  const hookStack = parseHookStack(hook.stackError.stack || "");
   const rootIndex = findCommonAncestorIndex(rootStack, hookStack);
   const primitiveIndex = findPrimitiveIndex(hookStack, hook);
   if (rootIndex === -1 || primitiveIndex === -1 || rootIndex - primitiveIndex < 2) {
@@ -626,13 +627,14 @@ const NON_ID_HOOK_PRIMITIVES = new Set([
 
 const buildTree = (rootStack: StackFrame[], capturedHookLog: HookLogEntry[]): HooksTree => {
   const rootChildren: HooksNode[] = [];
+  const parseHookStack = createStackParser();
   let previousStack: StackFrame[] | null = null;
   let levelChildren = rootChildren;
   let nativeHookID = 0;
   const childrenStack: HooksNode[][] = [];
 
   for (const hook of capturedHookLog) {
-    const [primitiveFrame, stack] = parseTrimmedStack(rootStack, hook);
+    const [primitiveFrame, stack] = parseTrimmedStack(rootStack, hook, parseHookStack);
     let displayName = hook.displayName;
     if (displayName === null && primitiveFrame !== null) {
       const primitiveName = parseHookName(primitiveFrame.functionName);

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);
+  };
 };

package/src/source/symbolication.ts

@@ -207,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[],
@@ -215,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;
@@ -267,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);
 };