Function resolveStackTrace

packages/ui/src/utils/sourceMaps.ts:52–128

(
  stack: string,
  firstOnly?: boolean,
)

  stack: string,
): Promise<StackTraceEntry[]>;
export async function resolveStackTrace(
  stack: string,
  firstOnly?: boolean,
): Promise<StackTraceEntry[] | StackTraceEntry> {
  const result: StackTraceEntry[] = [];
  for (const textLine of stack.split('\n')) {
    const match = textLine.match(StackTraceRegex);
    if (!match) continue;
    const [, functionName, uri, line, column] = match;
    const parsed = new URL(uri);
    const file = parsed.pathname;
    const directory = file.split('/').slice(0, -1).join('/') + '/';
    const entry: StackTraceEntry = {
      file,
      uri,
      line: parseInt(line),
      column: parseInt(column),
      isExternal: ExternalFileRegex.test(file),
      functionName: functionName?.trim(),
    };

    if (!entry.isExternal) {
      try {
        const sourceMap = await getSourceMap(file, parsed.search);
        const position = sourceMap.originalPositionFor(entry);
        if (position.line === null || position.column === null) {
          entry.isExternal = true;
        } else {
          const source =
            position.source[0] === '/'
              ? position.source
              : directory + position.source;

          entry.file = source;
          entry.line = position.line;
          entry.column = position.column;
          entry.source = position.source;
          entry.sourceMap = sourceMap;

          if (firstOnly) {
            return entry;
          }
        }
      } catch (e) {
        entry.isExternal = true;
      }
    }

    result.push(entry);

    if (entry.sourceMap?.raw?.includeMap) {
      const includeMap: Record<string, [string, number]> =
        entry.sourceMap.raw.includeMap;
      let current = entry;
      while (current.source in includeMap) {
        const [path, line] = includeMap[current.source];
        const file = directory + path;
        current = {