@posthog/core 1.1.0 → 1.2.0

package/src/error-tracking/error-properties-builder.ts

@@ -0,0 +1,169 @@
+import { getFilenameToChunkIdMap } from './chunk-ids'
+import { createStackParser } from './parsers'
+import {
+  ErrorProperties,
+  ExceptionLike,
+  ExceptionList,
+  CoercingContext,
+  StackFrame,
+  StackFrameModifierFn,
+  StackParser,
+  ErrorTrackingCoercer,
+  EventHint,
+  StackLineParser,
+  ParsingContext,
+  ChunkIdMapType,
+  Mechanism,
+  ParsedException,
+  Exception,
+} from './types'
+
+const MAX_CAUSE_RECURSION = 4
+
+export class ErrorPropertiesBuilder {
+  stackParser: StackParser
+
+  constructor(
+    private coercers: ErrorTrackingCoercer<any>[] = [],
+    parsers: StackLineParser[] = [],
+    private modifiers: StackFrameModifierFn[] = []
+  ) {
+    this.stackParser = createStackParser(...parsers)
+  }
+
+  buildFromUnknown(input: unknown, hint: EventHint = {}): ErrorProperties {
+    const providedMechanism = hint && hint.mechanism
+    const mechanism = providedMechanism || {
+      handled: true,
+      type: 'generic',
+    }
+    const coercingContext: CoercingContext = this.buildCoercingContext(mechanism, hint, 0)
+    const exceptionWithCause = coercingContext.apply(input)
+    const parsingContext: ParsingContext = this.buildParsingContext()
+    const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext)
+    const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism)
+    return {
+      $exception_list: exceptionList,
+      $exception_level: 'error',
+    }
+  }
+
+  coerceFallback(ctx: CoercingContext): ExceptionLike {
+    return {
+      type: 'Error',
+      value: 'Unknown error',
+      stack: ctx.syntheticException?.stack,
+      synthetic: true,
+    }
+  }
+
+  parseStacktrace(err: ExceptionLike, ctx: ParsingContext): ParsedException {
+    let cause: ParsedException | undefined = undefined
+    if (err.cause != null) {
+      cause = this.parseStacktrace(err.cause, ctx)
+    }
+    let stack: StackFrame[] | undefined = undefined
+    if (err.stack != '' && err.stack != null) {
+      stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? 1 : 0), ctx.chunkIdMap)
+    }
+    return { ...err, cause, stack }
+  }
+
+  private applyChunkIds(frames: StackFrame[], chunkIdMap?: ChunkIdMapType): StackFrame[] {
+    return frames.map((frame) => {
+      if (frame.filename && chunkIdMap) {
+        frame.chunk_id = chunkIdMap[frame.filename]
+      }
+      return frame
+    })
+  }
+
+  private applyCoercers(input: unknown, ctx: CoercingContext): ExceptionLike | undefined {
+    for (const adapter of this.coercers) {
+      if (adapter.match(input)) {
+        return adapter.coerce(input, ctx)
+      }
+    }
+    return this.coerceFallback(ctx)
+  }
+
+  private async applyModifiers(frames: StackFrame[]): Promise<StackFrame[]> {
+    let newFrames = frames
+    for (const modifier of this.modifiers) {
+      newFrames = await modifier(newFrames)
+    }
+    return newFrames
+  }
+
+  private async modifyFrames(exceptionWithStack: ParsedException): Promise<ParsedException> {
+    let cause: ParsedException | undefined = undefined
+    if (exceptionWithStack.cause != null) {
+      cause = await this.modifyFrames(exceptionWithStack.cause)
+    }
+    let stack: StackFrame[] = []
+    if (exceptionWithStack.stack != null) {
+      stack = await this.applyModifiers(exceptionWithStack.stack)
+    }
+    return { ...exceptionWithStack, cause, stack }
+  }
+
+  private convertToExceptionList(exceptionWithStack: ParsedException, mechanism: Mechanism): ExceptionList {
+    const currentException: Exception = {
+      type: exceptionWithStack.type,
+      value: exceptionWithStack.value,
+      mechanism: {
+        type: mechanism.type ?? 'generic',
+        handled: mechanism.handled ?? true,
+        synthetic: exceptionWithStack.synthetic ?? false,
+      },
+    }
+    if (exceptionWithStack.stack) {
+      currentException.stacktrace = {
+        type: 'raw',
+        frames: exceptionWithStack.stack,
+      }
+    }
+    const exceptionList: ExceptionList = [currentException]
+    if (exceptionWithStack.cause != null) {
+      // Cause errors are necessarily handled
+      exceptionList.push(
+        ...this.convertToExceptionList(exceptionWithStack.cause, {
+          ...mechanism,
+          handled: true,
+        })
+      )
+    }
+    return exceptionList
+  }
+
+  buildParsingContext(): ParsingContext {
+    const context = {
+      chunkIdMap: getFilenameToChunkIdMap(this.stackParser),
+    } as ParsingContext
+    return context
+  }
+
+  buildCoercingContext(mechanism: Mechanism, hint: EventHint, depth: number = 0): CoercingContext {
+    const coerce = (input: unknown, depth: number) => {
+      if (depth <= MAX_CAUSE_RECURSION) {
+        const ctx = this.buildCoercingContext(mechanism, hint, depth)
+        return this.applyCoercers(input, ctx)
+      } else {
+        return undefined
+      }
+    }
+    const context = {
+      ...hint,
+      // Do not propagate synthetic exception as it doesn't make sense
+      syntheticException: depth == 0 ? hint.syntheticException : undefined,
+      mechanism,
+      apply: (input: unknown) => {
+        return coerce(input, depth)
+      },
+      next: (input: unknown) => {
+        return coerce(input, depth + 1)
+      },
+    } as CoercingContext
+    return context
+  }
+}

package/src/error-tracking/index.ts

@@ -0,0 +1,5 @@
+export * from './error-properties-builder'
+export type * from './types'
+export * from './parsers'
+export * from './coercers'
+export * from './utils'

package/src/error-tracking/parsers/base.ts

@@ -0,0 +1,29 @@
+import { isUndefined } from '@/utils'
+import { StackFrame } from '../types'
+
+export const UNKNOWN_FUNCTION = '?'
+export const OPERA10_PRIORITY = 10
+export const OPERA11_PRIORITY = 20
+export const CHROME_PRIORITY = 30
+export const WINJS_PRIORITY = 40
+export const GECKO_PRIORITY = 50
+
+export function createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {
+  const frame: StackFrame = {
+    // TODO: should be a variable here
+    platform: 'web:javascript',
+    filename,
+    function: func === '<anonymous>' ? UNKNOWN_FUNCTION : func,
+    in_app: true, // All browser frames are considered in_app
+  }
+
+  if (!isUndefined(lineno)) {
+    frame.lineno = lineno
+  }
+
+  if (!isUndefined(colno)) {
+    frame.colno = colno
+  }
+
+  return frame
+}

package/src/error-tracking/parsers/chrome.ts

@@ -0,0 +1,53 @@
+// This regex matches frames that have no function name (ie. are at the top level of a module).
+// For example "at http://localhost:5000//script.js:1:126"
+
+import { StackLineParser } from '../types'
+import { createFrame, UNKNOWN_FUNCTION } from './base'
+import { extractSafariExtensionDetails } from './safari'
+
+// Frames _with_ function names usually look as follows: "at commitLayoutEffects (react-dom.development.js:23426:1)"
+const chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i
+
+// This regex matches all the frames that have a function name.
+const chromeRegex =
+  /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i
+
+const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/
+
+// Chromium based browsers: Chrome, Brave, new Opera, new Edge
+// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments
+// See: https://github.com/getsentry/sentry-javascript/issues/6880
+export const chromeStackLineParser: StackLineParser = (line) => {
+  // If the stack line has no function name, we need to parse it differently
+  const noFnParts = chromeRegexNoFnName.exec(line) as null | [string, string, string, string]
+
+  if (noFnParts) {
+    const [, filename, line, col] = noFnParts
+    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col)
+  }
+
+  const parts = chromeRegex.exec(line) as null | [string, string, string, string, string]
+
+  if (parts) {
+    const isEval = parts[2] && parts[2].indexOf('eval') === 0 // start of line
+
+    if (isEval) {
+      const subMatch = chromeEvalRegex.exec(parts[2]) as null | [string, string, string, string]
+
+      if (subMatch) {
+        // throw out eval line/column and use top-most line/column number
+        parts[2] = subMatch[1] // url
+        parts[3] = subMatch[2] // line
+        parts[4] = subMatch[3] // column
+      }
+    }
+
+    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
+    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
+    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2])
+
+    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined)
+  }
+
+  return
+}

package/src/error-tracking/parsers/gecko.ts

@@ -0,0 +1,38 @@
+// gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
+// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
+
+import { StackLineParser } from '../types'
+import { createFrame, UNKNOWN_FUNCTION } from './base'
+import { extractSafariExtensionDetails } from './safari'
+
+// We need this specific case for now because we want no other regex to match.
+const geckoREgex =
+  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i
+const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i
+
+export const geckoStackLineParser: StackLineParser = (line) => {
+  const parts = geckoREgex.exec(line) as null | [string, string, string, string, string, string]
+
+  if (parts) {
+    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1
+    if (isEval) {
+      const subMatch = geckoEvalRegex.exec(parts[3]) as null | [string, string, string]
+
+      if (subMatch) {
+        // throw out eval line/column and use top-most line number
+        parts[1] = parts[1] || 'eval'
+        parts[3] = subMatch[1]
+        parts[4] = subMatch[2]
+        parts[5] = '' // no column when eval
+      }
+    }
+
+    let filename = parts[3]
+    let func = parts[1] || UNKNOWN_FUNCTION
+    ;[func, filename] = extractSafariExtensionDetails(func, filename)
+
+    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined)
+  }
+
+  return
+}

package/src/error-tracking/parsers/index.ts

@@ -0,0 +1,104 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+// 💖 open source
+
+// This was originally forked from https://github.com/csnover/TraceKit, and was largely
+// re-written as part of raven - js.
+//
+// This code was later copied to the JavaScript mono - repo and further modified and
+// refactored over the years.
+
+// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files(the 'Software'), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify,
+// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies
+// or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import { StackFrame, StackLineParser, StackParser } from '../types'
+import { UNKNOWN_FUNCTION } from './base'
+export { chromeStackLineParser } from './chrome'
+export { winjsStackLineParser } from './winjs'
+export { geckoStackLineParser } from './gecko'
+export { opera10StackLineParser, opera11StackLineParser } from './opera'
+export { nodeStackLineParser } from './node'
+
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/
+const STACKTRACE_FRAME_LIMIT = 50
+
+export function reverseAndStripFrames(stack: ReadonlyArray<StackFrame>): StackFrame[] {
+  if (!stack.length) {
+    return []
+  }
+
+  const localStack = Array.from(stack)
+
+  localStack.reverse()
+
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
+    ...frame,
+    filename: frame.filename || getLastStackFrame(localStack).filename,
+    function: frame.function || UNKNOWN_FUNCTION,
+  }))
+}
+
+function getLastStackFrame(arr: StackFrame[]): StackFrame {
+  return arr[arr.length - 1] || {}
+}
+
+export function createStackParser(...parsers: StackLineParser[]): StackParser {
+  // const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map((p) => p[1])
+
+  return (stack: string, skipFirstLines: number = 0): StackFrame[] => {
+    const frames: StackFrame[] = []
+    const lines = stack.split('\n')
+
+    for (let i = skipFirstLines; i < lines.length; i++) {
+      const line = lines[i] as string
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      // Many of the regular expressions use backtracking which results in run time that increases exponentially with
+      // input size. Huge strings can result in hangs/Denial of Service:
+      // https://github.com/getsentry/sentry-javascript/issues/2286
+      if (line.length > 1024) {
+        continue
+      }
+
+      // https://github.com/getsentry/sentry-javascript/issues/5459
+      // Remove webpack (error: *) wrappers
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line
+
+      // https://github.com/getsentry/sentry-javascript/issues/7813
+      // Skip Error: lines
+      if (cleanedLine.match(/\S*Error: /)) {
+        continue
+      }
+
+      for (const parser of parsers) {
+        const frame = parser(cleanedLine)
+        if (frame) {
+          frames.push(frame)
+          break
+        }
+      }
+
+      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
+        break
+      }
+    }
+
+    return reverseAndStripFrames(frames)
+  }
+}

package/src/error-tracking/parsers/node.ts

@@ -0,0 +1,111 @@
+import { StackLineParser } from '../types'
+import { UNKNOWN_FUNCTION } from './base'
+
+/** Node Stack line parser */
+const FILENAME_MATCH = /^\s*[-]{4,}$/
+const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/
+
+export const nodeStackLineParser: StackLineParser = (line: string) => {
+  const lineMatch = line.match(FULL_MATCH)
+
+  if (lineMatch) {
+    let object: string | undefined
+    let method: string | undefined
+    let functionName: string | undefined
+    let typeName: string | undefined
+    let methodName: string | undefined
+
+    if (lineMatch[1]) {
+      functionName = lineMatch[1]
+
+      let methodStart = functionName.lastIndexOf('.')
+      if (functionName[methodStart - 1] === '.') {
+        methodStart--
+      }
+
+      if (methodStart > 0) {
+        object = functionName.slice(0, methodStart)
+        method = functionName.slice(methodStart + 1)
+        const objectEnd = object.indexOf('.Module')
+        if (objectEnd > 0) {
+          functionName = functionName.slice(objectEnd + 1)
+          object = object.slice(0, objectEnd)
+        }
+      }
+      typeName = undefined
+    }
+
+    if (method) {
+      typeName = object
+      methodName = method
+    }
+
+    if (method === '<anonymous>') {
+      methodName = undefined
+      functionName = undefined
+    }
+
+    if (functionName === undefined) {
+      methodName = methodName || UNKNOWN_FUNCTION
+      functionName = typeName ? `${typeName}.${methodName}` : methodName
+    }
+
+    let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2]
+    const isNative = lineMatch[5] === 'native'
+
+    // If it's a Windows path, trim the leading slash so that `/C:/foo` becomes `C:/foo`
+    if (filename?.match(/\/[A-Z]:/)) {
+      filename = filename.slice(1)
+    }
+
+    if (!filename && lineMatch[5] && !isNative) {
+      filename = lineMatch[5]
+    }
+
+    return {
+      filename: filename ? decodeURI(filename) : undefined,
+      module: undefined,
+      function: functionName,
+      lineno: _parseIntOrUndefined(lineMatch[3]),
+      colno: _parseIntOrUndefined(lineMatch[4]),
+      in_app: filenameIsInApp(filename || '', isNative),
+      platform: 'node:javascript',
+    }
+  }
+
+  if (line.match(FILENAME_MATCH)) {
+    return {
+      filename: line,
+      platform: 'node:javascript',
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Does this filename look like it's part of the app code?
+ */
+function filenameIsInApp(filename: string, isNative: boolean = false): boolean {
+  const isInternal =
+    isNative ||
+    (filename &&
+      // It's not internal if it's an absolute linux path
+      !filename.startsWith('/') &&
+      // It's not internal if it's an absolute windows path
+      !filename.match(/^[A-Z]:/) &&
+      // It's not internal if the path is starting with a dot
+      !filename.startsWith('.') &&
+      // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack
+      !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//)) // Schema from: https://stackoverflow.com/a/3641782
+
+  // in_app is all that's not an internal Node function or a module within node_modules
+  // note that isNative appears to return true even for node core libraries
+  // see https://github.com/getsentry/raven-node/issues/176
+
+  return !isInternal && filename !== undefined && !filename.includes('node_modules/')
+}
+
+function _parseIntOrUndefined(input: string | undefined): number | undefined {
+  return parseInt(input || '', 10) || undefined
+}

package/src/error-tracking/parsers/opera.ts

@@ -0,0 +1,18 @@
+import { StackLineParser } from '../types'
+import { createFrame, UNKNOWN_FUNCTION } from './base'
+
+const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i
+
+export const opera10StackLineParser: StackLineParser = (line) => {
+  const parts = opera10Regex.exec(line) as null | [string, string, string, string]
+  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined
+}
+
+// export const opera10StackLineParser: StackLineParser = [OPERA10_PRIORITY, opera10]
+
+const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i
+
+export const opera11StackLineParser: StackLineParser = (line) => {
+  const parts = opera11Regex.exec(line) as null | [string, string, string, string, string, string]
+  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined
+}

package/src/error-tracking/parsers/safari.ts

@@ -0,0 +1,33 @@
+import { UNKNOWN_FUNCTION } from './base'
+
+/**
+ * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
+ * What it means, is that instead of format like:
+ *
+ * Error: wat
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *
+ * it produces something like:
+ *
+ *   function@url:row:col
+ *   function@url:row:col
+ *   function@url:row:col
+ *
+ * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.
+ * This function is extracted so that we can use it in both places without duplicating the logic.
+ * Unfortunately "just" changing RegExp is too complicated now and making it pass all tests
+ * and fix this case seems like an impossible, or at least way too time-consuming task.
+ */
+export const extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {
+  const isSafariExtension = func.indexOf('safari-extension') !== -1
+  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1
+
+  return isSafariExtension || isSafariWebExtension
+    ? [
+        func.indexOf('@') !== -1 ? (func.split('@')[0] as string) : UNKNOWN_FUNCTION,
+        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,
+      ]
+    : [func, filename]
+}

package/src/error-tracking/parsers/winjs.ts

@@ -0,0 +1,12 @@
+import { StackLineParser } from '../types'
+import { createFrame, UNKNOWN_FUNCTION } from './base'
+
+const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i
+
+export const winjsStackLineParser: StackLineParser = (line) => {
+  const parts = winjsRegex.exec(line) as null | [string, string, string, string, string]
+
+  return parts
+    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)
+    : undefined
+}

package/src/error-tracking/types.ts

@@ -0,0 +1,107 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import type { JsonType } from '../types'
+
+// levels originally copied from Sentry to work with the sentry integration
+// and to avoid relying on a frequently changing @sentry/types dependency
+// but provided as an array of literal types, so we can constrain the level below
+export const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const
+export declare type SeverityLevel = (typeof severityLevels)[number]
+
+export interface PolymorphicEvent {
+  [key: string]: unknown
+  readonly type: string
+  readonly target?: unknown
+  readonly currentTarget?: unknown
+}
+
+export interface EventHint {
+  mechanism?: Partial<Mechanism>
+  syntheticException?: Error | null
+}
+
+export interface ErrorProperties {
+  $exception_list: Exception[]
+  $exception_level?: SeverityLevel
+}
+
+export interface Exception {
+  type?: string
+  value?: string
+  mechanism?: Mechanism
+  module?: string
+  thread_id?: number
+  stacktrace?: { frames?: StackFrame[]; type: 'raw' }
+}
+
+export type ExceptionList = Exception[]
+
+export interface Mechanism {
+  handled?: boolean
+  type?: 'generic' | 'onunhandledrejection' | 'onuncaughtexception' | 'middleware'
+  source?: string
+  synthetic?: boolean
+}
+
+export type GetModuleFn = (filename: string | undefined) => string | undefined
+
+export type StackParser = (stack: string, skipFirstLines?: number) => StackFrame[]
+export type StackLineParser = (line: string) => StackFrame | undefined
+
+export type StackFrameModifierFn = (frames: StackFrame[]) => Promise<StackFrame[]>
+
+export interface StackFrame {
+  platform: string
+  filename?: string
+  function?: string
+  module?: string
+  lineno?: number
+  colno?: number
+  abs_path?: string
+  context_line?: string
+  pre_context?: string[]
+  post_context?: string[]
+  in_app?: boolean
+  instruction_addr?: string
+  addr_mode?: string
+  vars?: { [key: string]: JsonType }
+  chunk_id?: string
+}
+
+export interface CoercingContext extends EventHint {
+  // Used to forward to other types
+  apply: (input: unknown) => ExceptionLike
+  // Used to coerce nested exceptions
+  next: (input: unknown) => ExceptionLike | undefined
+}
+
+export type ChunkIdMapType = Record<string, string>
+
+export interface ParsingContext {
+  chunkIdMap?: ChunkIdMapType
+}
+
+interface Coercer<T, U, C> {
+  match(input: unknown): input is T
+  coerce(input: T, ctx: C): U
+}
+
+export type ErrorTrackingCoercer<T> = Coercer<T, ExceptionLike | undefined, CoercingContext>
+
+interface BaseException {
+  type: string
+  value: string
+  synthetic: boolean
+}
+
+export interface ExceptionLike extends BaseException {
+  stack?: string
+  cause?: ExceptionLike
+  level?: SeverityLevel
+}
+
+export interface ParsedException extends BaseException {
+  stack?: StackFrame[]
+  cause?: ParsedException
+}