bippy 0.5.28 → 0.5.29

package/src/source/parse-stack.ts

@@ -0,0 +1,295 @@
+export interface StackFrame {
+  args?: unknown[];
+  columnNumber?: number;
+  lineNumber?: number;
+  fileName?: string;
+  functionName?: string;
+  source?: string;
+  isServer?: boolean;
+  isSymbolicated?: boolean;
+}
+
+export interface ParseOptions {
+  slice?: number | [number, number];
+  allowEmpty?: boolean;
+  includeInElement?: boolean;
+}
+
+const FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code\])?$/;
+
+const getNonStandardStacktrace = (error: unknown): string | null => {
+  if (error && typeof error === 'object') {
+    const stacktrace = (error as Record<string, unknown>)['stacktrace'];
+    return typeof stacktrace === 'string' ? stacktrace : null;
+  }
+  return null;
+};
+
+export const parseStack = (
+  stackString: string,
+  options?: ParseOptions,
+): StackFrame[] => {
+  if (options?.includeInElement !== false) {
+    const lines = stackString.split('\n');
+    const frames: StackFrame[] = [];
+    for (const rawLine of lines) {
+      if (/^\s*at\s+/.test(rawLine)) {
+        const parsed = parseV8OrIeString(rawLine, undefined)[0];
+        if (parsed) frames.push(parsed);
+      } 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, undefined)[0];
+        if (parsed) frames.push(parsed);
+      }
+    }
+    return applySlice(frames, options);
+  }
+  if (stackString.match(CHROME_IE_STACK_REGEXP)) {
+    return parseV8OrIeString(stackString, options);
+  }
+  return parseFFOrSafariString(stackString, options);
+};
+
+export const extractLocation = (
+  urlLike: string,
+): [string, string | undefined, string | undefined] => {
+  if (!urlLike.includes(':')) return [urlLike, undefined, undefined];
+
+  // HACK: Chrome/V8 stack traces wrap location in parens: "(file.js:10:5)"
+  // We need to strip these outer parens but preserve parens in paths (e.g., Next.js route groups like "(docs)")
+  // Chrome format always ends with `:col)` where digit comes right before the closing paren
+  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;
+};
+
+const applySlice = <T>(lines: T[], options?: ParseOptions): T[] => {
+  if (options && options.slice != null) {
+    if (Array.isArray(options.slice))
+      return lines.slice(options.slice[0], options.slice[1]);
+    return lines.slice(0, options.slice);
+  }
+  return lines;
+};
+
+export const parseV8OrIE = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  return parseV8OrIeString(error.stack!, options);
+};
+
+export const parseV8OrIeString = (
+  stack: string,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const filteredLines = applySlice(
+    stack.split('\n').filter((line) => {
+      return !!line.match(CHROME_IE_STACK_REGEXP);
+    }),
+    options,
+  );
+
+  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 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>'].includes(locationParts[0])
+      ? undefined
+      : locationParts[0];
+
+    return {
+      functionName,
+      fileName,
+      lineNumber: locationParts[1] ? +locationParts[1] : undefined,
+      columnNumber: locationParts[2] ? +locationParts[2] : undefined,
+      source: currentLine,
+    };
+  });
+};
+
+export const parseFFOrSafari = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  return parseFFOrSafariString(error.stack!, options);
+};
+
+export const parseFFOrSafariString = (
+  stack: string,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const filteredLines = applySlice(
+    stack.split('\n').filter((line) => {
+      return !line.match(SAFARI_NATIVE_CODE_REGEXP);
+    }),
+    options,
+  );
+
+  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,
+      };
+    }
+  });
+};
+
+export const parseOpera = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const nonStandardStacktrace = getNonStandardStacktrace(error);
+  if (
+    !nonStandardStacktrace ||
+    (error.message.includes('\n') &&
+      error.message.split('\n').length >
+        nonStandardStacktrace.split('\n').length)
+  ) {
+    return parseOpera9(error, options);
+  }
+  if (!error.stack) return parseOpera10(error, options);
+  return parseOpera11(error, options);
+};
+
+export const parseOpera9 = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const lineRegex = /Line (\d+).*script (?:in )?(\S+)/i;
+  const messageLines = error.message.split('\n');
+  const parsedFrames: StackFrame[] = [];
+
+  for (let i = 2, len = messageLines.length; i < len; i += 2) {
+    const match = lineRegex.exec(messageLines[i]);
+    if (match) {
+      parsedFrames.push({
+        fileName: match[2],
+        lineNumber: +match[1],
+        source: messageLines[i],
+      });
+    }
+  }
+
+  return applySlice(parsedFrames, options);
+};
+
+export const parseOpera10 = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const lineRegex =
+    /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
+  const nonStandardStacktrace = getNonStandardStacktrace(error);
+  const stacktraceLines = (nonStandardStacktrace || '').split('\n');
+  const parsedFrames: StackFrame[] = [];
+
+  for (let i = 0, len = stacktraceLines.length; i < len; i += 2) {
+    const match = lineRegex.exec(stacktraceLines[i]);
+    if (match) {
+      parsedFrames.push({
+        functionName: match[3] || undefined,
+        fileName: match[2],
+        lineNumber: match[1] ? +match[1] : undefined,
+        source: stacktraceLines[i],
+      });
+    }
+  }
+
+  return applySlice(parsedFrames, options);
+};
+
+export const parseOpera11 = (
+  error: Error,
+  options?: ParseOptions,
+): StackFrame[] => {
+  const filteredLines = applySlice(
+    // @ts-expect-error missing stack property
+    error.stack.split('\n').filter((line) => {
+      return (
+        !!line.match(FIREFOX_SAFARI_STACK_REGEXP) &&
+        !line.match(/^Error created at/)
+      );
+    }),
+    options,
+  );
+
+  return filteredLines.map<StackFrame>((line) => {
+    const tokens = line.split('@');
+    const locationParts = extractLocation(tokens.pop()!);
+    const functionCall = tokens.shift() || '';
+    const functionName =
+      functionCall
+        .replace(/<anonymous function(: (\w+))?>/, '$2')
+        .replace(/\([^)]*\)/g, '') || undefined;
+    let argsRaw: string | undefined;
+    if (functionCall.match(/\(([^)]*)\)/))
+      argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, '$1');
+
+    const args =
+      argsRaw === undefined || argsRaw === '[arguments not available]'
+        ? undefined
+        : argsRaw.split(',');
+
+    return {
+      functionName,
+      args,
+      fileName: locationParts[0],
+      lineNumber: locationParts[1] ? +locationParts[1] : undefined,
+      columnNumber: locationParts[2] ? +locationParts[2] : undefined,
+      source: line,
+    };
+  });
+};

package/src/source/symbolication.ts

@@ -0,0 +1,410 @@
+import {
+  decode,
+  SourceMapMappings,
+  type SourceMapSegment,
+} from '@jridgewell/sourcemap-codec';
+
+import { StackFrame } from './parse-stack.js';
+
+export interface DecodedSourceMapSection {
+  map: {
+    file?: string;
+    mappings: SourceMapSegment[][];
+    names?: string[];
+    sourceRoot?: string;
+    sources: string[];
+    sourcesContent?: string[];
+    version: 3;
+  };
+  offset: {
+    column: number;
+    line: number;
+  };
+}
+
+// https://tc39.es/ecma426/#sec-index-source-map
+export interface IndexSourceMap {
+  file?: string;
+  sections: Array<{
+    map: StandardSourceMap;
+    offset: {
+      column: number;
+      line: number;
+    };
+  }>;
+  version: 3;
+}
+
+export type RawSourceMap = IndexSourceMap | StandardSourceMap;
+
+export interface SourceMap {
+  file?: string;
+  mappings: SourceMapSegment[][];
+  names?: string[];
+  sections?: DecodedSourceMapSection[];
+  sourceRoot?: string;
+  sources: string[];
+  sourcesContent?: string[];
+  version: 3;
+}
+
+// https://developer.chrome.com/blog/sourcemaps#the_anatomy_of_a_source_map
+export interface StandardSourceMap {
+  file?: string;
+  mappings: string;
+  names?: string[];
+  sourceRoot?: string;
+  sources: string[];
+  sourcesContent?: string[];
+  version: 3;
+}
+
+// has a scheme, e.g. http://, https://, file://, data:, etc.
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+// inline sourcemap, e.g. data:application/json;base64,...
+const INLINE_SOURCEMAP_REGEX = /^data:application\/json[^,]+base64,/;
+// sourcemap url, e.g. //@ sourceMappingURL=... or /* @ sourceMappingURL=... */ at the end of the file
+const SOURCEMAP_REGEX =
+  /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/;
+
+const supportsWeakRef = typeof WeakRef !== 'undefined';
+
+export const sourceMapCache = new Map<
+  string,
+  null | SourceMap | WeakRef<SourceMap>
+>();
+const _pendingSourceMapRequests = new Map<
+  string,
+  null | Promise<null | SourceMap>
+>();
+
+const isWeakRefSourceMap = (
+  cachedValue: SourceMap | WeakRef<SourceMap>,
+): cachedValue is WeakRef<SourceMap> => {
+  return supportsWeakRef && cachedValue instanceof WeakRef;
+};
+
+const getSourceFromMappings = (
+  mappings: SourceMapMappings,
+  sources: string[],
+  lineIndexInMappings: number,
+  column: number,
+): StackFrame | null => {
+  if (lineIndexInMappings < 0 || lineIndexInMappings >= mappings.length) {
+    return null;
+  }
+
+  const lineMapping = mappings[lineIndexInMappings];
+  if (!lineMapping || lineMapping.length === 0) {
+    return null;
+  }
+
+  let closestLineSegment: null | SourceMapSegment = null;
+  for (const lineSegment of lineMapping) {
+    if (lineSegment[0] <= column) {
+      closestLineSegment = lineSegment;
+    } else {
+      break;
+    }
+  }
+
+  if (!closestLineSegment || closestLineSegment.length < 4) {
+    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,
+  };
+};
+
+export const getSourceFromSourceMap = (
+  sourceMap: SourceMap,
+  line: number,
+  column: number,
+): StackFrame | null => {
+  if (sourceMap.sections) {
+    let targetSection: DecodedSourceMapSection | null = null;
+
+    for (const section of sourceMap.sections) {
+      if (
+        line > section.offset.line ||
+        (line === section.offset.line && column >= section.offset.column)
+      ) {
+        targetSection = section;
+      } else {
+        break;
+      }
+    }
+
+    if (!targetSection) {
+      return null;
+    }
+
+    const relativeLine = line - targetSection.offset.line;
+    const relativeColumn =
+      line === targetSection.offset.line
+        ? column - targetSection.offset.column
+        : column;
+
+    return getSourceFromMappings(
+      targetSection.map.mappings,
+      targetSection.map.sources,
+      relativeLine,
+      relativeColumn,
+    );
+  }
+
+  return getSourceFromMappings(
+    sourceMap.mappings,
+    sourceMap.sources,
+    line - 1,
+    column,
+  );
+};
+
+const getSourceMapUrl = (url: string, content: string): null | string => {
+  const lines = content.split('\n');
+  let sourceMapUrl: string | undefined;
+  for (let i = lines.length - 1; i >= 0 && !sourceMapUrl; i--) {
+    const regexMatch = lines[i].match(SOURCEMAP_REGEX);
+    if (regexMatch) {
+      sourceMapUrl = regexMatch[1] || regexMatch[2];
+    }
+  }
+
+  if (!sourceMapUrl) {
+    return null;
+  }
+
+  const hasScheme = SCHEME_REGEX.test(sourceMapUrl);
+  if (
+    !(
+      INLINE_SOURCEMAP_REGEX.test(sourceMapUrl) ||
+      hasScheme ||
+      sourceMapUrl.startsWith('/')
+    )
+  ) {
+    const urlSegments = url.split('/');
+    urlSegments[urlSegments.length - 1] = sourceMapUrl;
+    sourceMapUrl = urlSegments.join('/');
+  }
+
+  return sourceMapUrl;
+};
+
+const decodeStandardSourceMap = (
+  rawSourceMap: StandardSourceMap,
+): SourceMap => ({
+  file: rawSourceMap.file,
+  mappings: decode(rawSourceMap.mappings),
+  names: rawSourceMap.names,
+  sourceRoot: rawSourceMap.sourceRoot,
+  sources: rawSourceMap.sources,
+  sourcesContent: rawSourceMap.sourcesContent,
+  version: 3,
+});
+
+const decodeIndexSourceMap = (rawSourceMap: IndexSourceMap): SourceMap => {
+  const decodedSections: DecodedSourceMapSection[] = rawSourceMap.sections.map(
+    ({ map, offset }) => ({
+      map: {
+        ...map,
+        mappings: decode(map.mappings),
+      },
+      offset,
+    }),
+  );
+
+  const allSources = new Set<string>();
+  for (const section of decodedSections) {
+    for (const source of section.map.sources) {
+      allSources.add(source);
+    }
+  }
+
+  return {
+    file: rawSourceMap.file,
+    mappings: [],
+    names: [],
+    sections: decodedSections,
+    sourceRoot: undefined,
+    sources: Array.from(allSources),
+    sourcesContent: undefined,
+    version: 3,
+  };
+};
+
+const isFetchableUrl = (url: string): boolean => {
+  if (!url) {
+    return false;
+  }
+
+  const trimmedUrl = url.trim();
+
+  if (!trimmedUrl) {
+    return false;
+  }
+
+  const schemeMatch = trimmedUrl.match(SCHEME_REGEX);
+
+  if (!schemeMatch) {
+    return true;
+  }
+
+  const scheme = schemeMatch[0].toLowerCase();
+
+  return scheme === 'http:' || scheme === 'https:';
+};
+
+export const getSourceMapImpl = async (
+  bundleUrl: string,
+  fetchFn: (url: string) => Promise<Response> = fetch,
+): Promise<null | SourceMap> => {
+  if (!isFetchableUrl(bundleUrl)) {
+    return null;
+  }
+
+  let bundleContent: string | undefined;
+  try {
+    const bundleResponse = await fetchFn(bundleUrl);
+    if (!bundleResponse.ok) {
+      return null;
+    }
+    bundleContent = await bundleResponse.text();
+  } catch {
+    return null;
+  }
+
+  if (!bundleContent) {
+    return null;
+  }
+
+  const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent);
+
+  if (!sourceMapUrl) return null;
+  if (!isFetchableUrl(sourceMapUrl)) {
+    return null;
+  }
+
+  try {
+    const sourceMapResponse = await fetchFn(sourceMapUrl);
+    if (!sourceMapResponse.ok) {
+      return null;
+    }
+    const rawSourceMap = (await sourceMapResponse.json()) as RawSourceMap;
+
+    return 'sections' in rawSourceMap
+      ? decodeIndexSourceMap(rawSourceMap)
+      : decodeStandardSourceMap(rawSourceMap);
+  } catch {
+    return null;
+  }
+};
+
+export const getSourceMap = async (
+  file: string,
+  useCache = true,
+  fetchFn?: (url: string) => Promise<Response>,
+): Promise<null | SourceMap> => {
+  if (useCache && sourceMapCache.has(file)) {
+    const cachedValue = sourceMapCache.get(file);
+    if (cachedValue === null || cachedValue === undefined) {
+      return null;
+    }
+    if (isWeakRefSourceMap(cachedValue)) {
+      const sourceMap = cachedValue.deref();
+      if (sourceMap) {
+        return sourceMap;
+      }
+      sourceMapCache.delete(file);
+    } else {
+      return cachedValue;
+    }
+  }
+
+  if (useCache && _pendingSourceMapRequests.has(file)) {
+    return _pendingSourceMapRequests.get(file)!;
+  }
+
+  const fetchPromise = getSourceMapImpl(file, fetchFn);
+  if (useCache) {
+    _pendingSourceMapRequests.set(file, fetchPromise);
+  }
+
+  const sourceMap = await fetchPromise;
+  if (useCache) {
+    _pendingSourceMapRequests.delete(file);
+  }
+
+  if (useCache) {
+    if (sourceMap === null) {
+      sourceMapCache.set(file, null);
+    } else {
+      sourceMapCache.set(
+        file,
+        supportsWeakRef ? new WeakRef(sourceMap) : sourceMap,
+      );
+    }
+  }
+
+  return sourceMap;
+};
+
+export const symbolicateStack = async (
+  stack: StackFrame[],
+  cache = true,
+  fetchFn?: (url: string) => Promise<Response>,
+): Promise<StackFrame[]> => {
+  return await Promise.all(
+    stack.map(async (stackFrame) => {
+      if (!stackFrame.fileName) return stackFrame;
+      const sourceMap = await getSourceMap(stackFrame.fileName, cache, fetchFn);
+      if (
+        !sourceMap ||
+        typeof stackFrame.lineNumber !== 'number' ||
+        typeof stackFrame.columnNumber !== 'number'
+      ) {
+        return stackFrame;
+      }
+      const symbolicatedSource = getSourceFromSourceMap(
+        sourceMap,
+        stackFrame.lineNumber,
+        stackFrame.columnNumber,
+      );
+      if (!symbolicatedSource) return stackFrame;
+      return {
+        ...stackFrame,
+        source:
+          symbolicatedSource.fileName && stackFrame.source
+            ? stackFrame.source.replace(
+                stackFrame.fileName,
+                symbolicatedSource.fileName,
+              )
+            : stackFrame.source,
+        fileName: symbolicatedSource.fileName,
+        lineNumber: symbolicatedSource.lineNumber,
+        columnNumber: symbolicatedSource.columnNumber,
+        isSymbolicated: true,
+      };
+    }),
+  );
+};

package/src/source/types.ts

@@ -0,0 +1,6 @@
+export interface FiberSource {
+  columnNumber?: number;
+  fileName: string;
+  lineNumber?: number;
+  functionName?: string;
+}