{"version":3,"file":"static/js/main-7562278f-3c654edac8143b366665.js","mappings":"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","sources":["webpack://leadsbridge/./node_modules/src/flags.ts","webpack://leadsbridge/./node_modules/src/stack-parsers.ts","webpack://leadsbridge/./node_modules/src/eventbuilder.ts","webpack://leadsbridge/./node_modules/src/transports/base.ts","webpack://leadsbridge/./node_modules/src/transports/fetch.ts","webpack://leadsbridge/./node_modules/src/transports/xhr.ts","webpack://leadsbridge/./node_modules/src/backend.ts","webpack://leadsbridge/./node_modules/src/transports/new-fetch.ts","webpack://leadsbridge/./node_modules/src/transports/new-xhr.ts","webpack://leadsbridge/./node_modules/src/helpers.ts","webpack://leadsbridge/./node_modules/src/integrations/breadcrumbs.ts","webpack://leadsbridge/./node_modules/src/client.ts","webpack://leadsbridge/./node_modules/src/integrations/trycatch.ts","webpack://leadsbridge/./node_modules/src/integrations/globalhandlers.ts","webpack://leadsbridge/./node_modules/src/integrations/linkederrors.ts","webpack://leadsbridge/./node_modules/src/integrations/dedupe.ts","webpack://leadsbridge/./node_modules/src/integrations/useragent.ts","webpack://leadsbridge/./node_modules/src/sdk.ts"],"sourcesContent":["/*\n * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking\n * for users.\n *\n * Debug flags need to be declared in each package individually and must not be imported across package boundaries,\n * because some build tools have trouble tree-shaking imported guards.\n *\n * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.\n *\n * Debug flag files will contain \"magic strings\" like `__SENTRY_DEBUG__` that may get replaced with actual values during\n * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not\n * replaced.\n */\n\ndeclare const __SENTRY_DEBUG__: boolean;\n\n/** Flag that is true for debug builds, false otherwise. */\nexport const IS_DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' ? true : __SENTRY_DEBUG__;\n","import { StackFrame } from '@sentry/types';\nimport { StackLineParser, StackLineParserFn } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {\n  const frame: StackFrame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n  /^\\s*at (?:(.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nconst chrome: StackLineParserFn = line => {\n  const parts = chromeRegex.exec(line);\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nexport const chromeStackParser: StackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko: StackLineParserFn = line => {\n  const parts = geckoREgex.exec(line);\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nexport const geckoStackParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nexport const winjsStackParser: StackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10: StackLineParserFn = line => {\n  const parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackParser: StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11: StackLineParserFn = line => {\n  const parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","import { Event, EventHint, Exception, Severity, StackFrame } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  createStackParser,\n  extractExceptionKeysForMessage,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/utils';\n\nimport {\n  chromeStackParser,\n  geckoStackParser,\n  opera10StackParser,\n  opera11StackParser,\n  winjsStackParser,\n} from './stack-parsers';\n\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromError(ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(ex);\n\n  const exception: Exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nexport function eventFromPlainObject(\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const event: Event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception),\n    },\n  };\n\n  if (syntheticException) {\n    const frames = parseStackFrames(syntheticException);\n    if (frames.length) {\n      event.stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromError(ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nexport function parseStackFrames(ex: Error & { framesToPop?: number; stacktrace?: string }): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const popSize = getPopSize(ex);\n\n  try {\n    return createStackParser(\n      opera10StackParser,\n      opera11StackParser,\n      chromeStackParser,\n      winjsStackParser,\n      geckoStackParser,\n    )(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex: Error & { framesToPop?: number }): number {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = Severity.Error;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  message: string,\n  level: Severity = Severity.Info,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception as DOMError) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromString(input: string, syntheticException?: Error, attachStacktrace?: boolean): Event {\n  const event: Event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(syntheticException);\n    if (frames.length) {\n      event.stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n","import {\n  APIDetails,\n  eventToSentryRequest,\n  getEnvelopeEndpointWithUrlEncodedAuth,\n  getStoreEndpointWithUrlEncodedAuth,\n  initAPIDetails,\n  sessionToSentryRequest,\n} from '@sentry/core';\nimport {\n  ClientReport,\n  Event,\n  Outcome,\n  Response as SentryResponse,\n  SentryRequest,\n  SentryRequestType,\n  Session,\n  Transport,\n  TransportOptions,\n} from '@sentry/types';\nimport {\n  createClientReportEnvelope,\n  disabledUntil,\n  dsnToString,\n  eventStatusFromHttpCode,\n  getGlobalObject,\n  isRateLimited,\n  logger,\n  makePromiseBuffer,\n  PromiseBuffer,\n  RateLimits,\n  serializeEnvelope,\n  updateRateLimits,\n} from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { sendReport } from './utils';\n\nfunction requestTypeToCategory(ty: SentryRequestType): string {\n  const tyStr = ty as string;\n  return tyStr === 'event' ? 'error' : tyStr;\n}\n\nconst global = getGlobalObject<Window>();\n\n/** Base Transport class implementation */\nexport abstract class BaseTransport implements Transport {\n  /**\n   * @deprecated\n   */\n  public url: string;\n\n  /** Helper to get Sentry API endpoints. */\n  protected readonly _api: APIDetails;\n\n  /** A simple buffer holding all requests. */\n  protected readonly _buffer: PromiseBuffer<SentryResponse> = makePromiseBuffer(30);\n\n  /** Locks transport after receiving rate limits in a response */\n  protected _rateLimits: RateLimits = {};\n\n  protected _outcomes: { [key: string]: number } = {};\n\n  public constructor(public options: TransportOptions) {\n    this._api = initAPIDetails(options.dsn, options._metadata, options.tunnel);\n    // eslint-disable-next-line deprecation/deprecation\n    this.url = getStoreEndpointWithUrlEncodedAuth(this._api.dsn);\n\n    if (this.options.sendClientReports && global.document) {\n      global.document.addEventListener('visibilitychange', () => {\n        if (global.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event): PromiseLike<SentryResponse> {\n    return this._sendRequest(eventToSentryRequest(event, this._api), event);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session): PromiseLike<SentryResponse> {\n    return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this._buffer.drain(timeout);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public recordLostEvent(reason: Outcome, category: SentryRequestType): void {\n    if (!this.options.sendClientReports) {\n      return;\n    }\n    // We want to track each category (event, transaction, session) separately\n    // but still keep the distinction between different type of outcomes.\n    // We could use nested maps, but it's much easier to read and type this way.\n    // A correct type for map-based implementation if we want to go that route\n    // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n    const key = `${requestTypeToCategory(category)}:${reason}`;\n    IS_DEBUG_BUILD && logger.log(`Adding outcome: ${key}`);\n    this._outcomes[key] = (this._outcomes[key] ?? 0) + 1;\n  }\n\n  /**\n   * Send outcomes as an envelope\n   */\n  protected _flushOutcomes(): void {\n    if (!this.options.sendClientReports) {\n      return;\n    }\n\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n\n    // Nothing to send\n    if (!Object.keys(outcomes).length) {\n      IS_DEBUG_BUILD && logger.log('No outcomes to flush');\n      return;\n    }\n\n    IS_DEBUG_BUILD && logger.log(`Flushing outcomes:\\n${JSON.stringify(outcomes, null, 2)}`);\n\n    const url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);\n\n    const discardedEvents = Object.keys(outcomes).map(key => {\n      const [category, reason] = key.split(':');\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n      // TODO: Improve types on discarded_events to get rid of cast\n    }) as ClientReport['discarded_events'];\n    const envelope = createClientReportEnvelope(discardedEvents, this._api.tunnel && dsnToString(this._api.dsn));\n\n    try {\n      sendReport(url, serializeEnvelope(envelope));\n    } catch (e) {\n      IS_DEBUG_BUILD && logger.error(e);\n    }\n  }\n\n  /**\n   * Handle Sentry repsonse for promise-based transports.\n   */\n  protected _handleResponse({\n    requestType,\n    response,\n    headers,\n    resolve,\n    reject,\n  }: {\n    requestType: SentryRequestType;\n    response: Response | XMLHttpRequest;\n    headers: Record<string, string | null>;\n    resolve: (value?: SentryResponse | PromiseLike<SentryResponse> | null | undefined) => void;\n    reject: (reason?: unknown) => void;\n  }): void {\n    const status = eventStatusFromHttpCode(response.status);\n\n    this._rateLimits = updateRateLimits(this._rateLimits, headers);\n    // eslint-disable-next-line deprecation/deprecation\n    if (this._isRateLimited(requestType)) {\n      IS_DEBUG_BUILD &&\n        // eslint-disable-next-line deprecation/deprecation\n        logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);\n    }\n\n    if (status === 'success') {\n      resolve({ status });\n      return;\n    }\n\n    reject(response);\n  }\n\n  /**\n   * Gets the time that given category is disabled until for rate limiting\n   *\n   * @deprecated Please use `disabledUntil` from @sentry/utils\n   */\n  protected _disabledUntil(requestType: SentryRequestType): Date {\n    const category = requestTypeToCategory(requestType);\n    return new Date(disabledUntil(this._rateLimits, category));\n  }\n\n  /**\n   * Checks if a category is rate limited\n   *\n   * @deprecated Please use `isRateLimited` from @sentry/utils\n   */\n  protected _isRateLimited(requestType: SentryRequestType): boolean {\n    const category = requestTypeToCategory(requestType);\n    return isRateLimited(this._rateLimits, category);\n  }\n\n  protected abstract _sendRequest(\n    sentryRequest: SentryRequest,\n    originalPayload: Event | Session,\n  ): PromiseLike<SentryResponse>;\n}\n","import { Event, Response, SentryRequest, Session, TransportOptions } from '@sentry/types';\nimport { SentryError, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\n\nimport { BaseTransport } from './base';\nimport { FetchImpl, getNativeFetchImplementation } from './utils';\n\n/** `fetch` based transport */\nexport class FetchTransport extends BaseTransport {\n  /**\n   * Fetch API reference which always points to native browser implementation.\n   */\n  private _fetch: typeof fetch;\n\n  public constructor(options: TransportOptions, fetchImpl: FetchImpl = getNativeFetchImplementation()) {\n    super(options);\n    this._fetch = fetchImpl;\n  }\n\n  /**\n   * @param sentryRequest Prepared SentryRequest to be delivered\n   * @param originalPayload Original payload used to create SentryRequest\n   */\n  protected _sendRequest(sentryRequest: SentryRequest, originalPayload: Event | Session): PromiseLike<Response> {\n    // eslint-disable-next-line deprecation/deprecation\n    if (this._isRateLimited(sentryRequest.type)) {\n      this.recordLostEvent('ratelimit_backoff', sentryRequest.type);\n\n      return Promise.reject({\n        event: originalPayload,\n        type: sentryRequest.type,\n        // eslint-disable-next-line deprecation/deprecation\n        reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(\n          sentryRequest.type,\n        )} due to too many requests.`,\n        status: 429,\n      });\n    }\n\n    const options: RequestInit = {\n      body: sentryRequest.body,\n      method: 'POST',\n      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n      // (see https://caniuse.com/#feat=referrer-policy),\n      // it doesn't. And it throws an exception instead of ignoring this parameter...\n      // REF: https://github.com/getsentry/raven-js/issues/1233\n      referrerPolicy: (supportsReferrerPolicy() ? 'origin' : '') as ReferrerPolicy,\n    };\n    if (this.options.fetchParameters !== undefined) {\n      Object.assign(options, this.options.fetchParameters);\n    }\n    if (this.options.headers !== undefined) {\n      options.headers = this.options.headers;\n    }\n\n    return this._buffer\n      .add(\n        () =>\n          new SyncPromise<Response>((resolve, reject) => {\n            void this._fetch(sentryRequest.url, options)\n              .then(response => {\n                const headers = {\n                  'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                  'retry-after': response.headers.get('Retry-After'),\n                };\n                this._handleResponse({\n                  requestType: sentryRequest.type,\n                  response,\n                  headers,\n                  resolve,\n                  reject,\n                });\n              })\n              .catch(reject);\n          }),\n      )\n      .then(undefined, reason => {\n        // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.\n        if (reason instanceof SentryError) {\n          this.recordLostEvent('queue_overflow', sentryRequest.type);\n        } else {\n          this.recordLostEvent('network_error', sentryRequest.type);\n        }\n        throw reason;\n      });\n  }\n}\n","import { Event, Response, SentryRequest, Session } from '@sentry/types';\nimport { SentryError, SyncPromise } from '@sentry/utils';\n\nimport { BaseTransport } from './base';\n\n/** `XHR` based transport */\nexport class XHRTransport extends BaseTransport {\n  /**\n   * @param sentryRequest Prepared SentryRequest to be delivered\n   * @param originalPayload Original payload used to create SentryRequest\n   */\n  protected _sendRequest(sentryRequest: SentryRequest, originalPayload: Event | Session): PromiseLike<Response> {\n    // eslint-disable-next-line deprecation/deprecation\n    if (this._isRateLimited(sentryRequest.type)) {\n      this.recordLostEvent('ratelimit_backoff', sentryRequest.type);\n\n      return Promise.reject({\n        event: originalPayload,\n        type: sentryRequest.type,\n        // eslint-disable-next-line deprecation/deprecation\n        reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(\n          sentryRequest.type,\n        )} due to too many requests.`,\n        status: 429,\n      });\n    }\n\n    return this._buffer\n      .add(\n        () =>\n          new SyncPromise<Response>((resolve, reject) => {\n            const request = new XMLHttpRequest();\n\n            request.onreadystatechange = (): void => {\n              if (request.readyState === 4) {\n                const headers = {\n                  'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                  'retry-after': request.getResponseHeader('Retry-After'),\n                };\n                this._handleResponse({ requestType: sentryRequest.type, response: request, headers, resolve, reject });\n              }\n            };\n\n            request.open('POST', sentryRequest.url);\n            for (const header in this.options.headers) {\n              if (Object.prototype.hasOwnProperty.call(this.options.headers, header)) {\n                request.setRequestHeader(header, this.options.headers[header]);\n              }\n            }\n            request.send(sentryRequest.body);\n          }),\n      )\n      .then(undefined, reason => {\n        // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.\n        if (reason instanceof SentryError) {\n          this.recordLostEvent('queue_overflow', sentryRequest.type);\n        } else {\n          this.recordLostEvent('network_error', sentryRequest.type);\n        }\n        throw reason;\n      });\n  }\n}\n","import { BaseBackend, getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails } from '@sentry/core';\nimport { Event, EventHint, Options, Severity, Transport, TransportOptions } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\n\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, makeNewFetchTransport, makeNewXHRTransport, XHRTransport } from './transports';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see BrowserClient for more information.\n */\nexport interface BrowserOptions extends Options {\n  /**\n   * A pattern for error URLs which should exclusively be sent to Sentry.\n   * This is the opposite of {@link Options.denyUrls}.\n   * By default, all errors will be sent.\n   */\n  allowUrls?: Array<string | RegExp>;\n\n  /**\n   * A pattern for error URLs which should not be sent to Sentry.\n   * To allow certain errors instead, use {@link Options.allowUrls}.\n   * By default, all errors will be sent.\n   */\n  denyUrls?: Array<string | RegExp>;\n\n  /** @deprecated use {@link Options.allowUrls} instead. */\n  whitelistUrls?: Array<string | RegExp>;\n\n  /** @deprecated use {@link Options.denyUrls} instead. */\n  blacklistUrls?: Array<string | RegExp>;\n}\n\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nexport class BrowserBackend extends BaseBackend<BrowserOptions> {\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(exception, hint, this._options.attachStacktrace);\n  }\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {\n    return eventFromMessage(message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _setupTransport(): Transport {\n    if (!this._options.dsn) {\n      // We return the noop transport here in case there is no Dsn.\n      return super._setupTransport();\n    }\n\n    const transportOptions: TransportOptions = {\n      ...this._options.transportOptions,\n      dsn: this._options.dsn,\n      tunnel: this._options.tunnel,\n      sendClientReports: this._options.sendClientReports,\n      _metadata: this._options._metadata,\n    };\n\n    const api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);\n    const url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);\n\n    if (this._options.transport) {\n      return new this._options.transport(transportOptions);\n    }\n    if (supportsFetch()) {\n      const requestOptions: RequestInit = { ...transportOptions.fetchParameters };\n      this._newTransport = makeNewFetchTransport({ requestOptions, url });\n      return new FetchTransport(transportOptions);\n    }\n\n    this._newTransport = makeNewXHRTransport({\n      url,\n      headers: transportOptions.headers,\n    });\n    return new XHRTransport(transportOptions);\n  }\n}\n","import {\n  BaseTransportOptions,\n  createTransport,\n  NewTransport,\n  TransportMakeRequestResponse,\n  TransportRequest,\n} from '@sentry/core';\n\nimport { FetchImpl, getNativeFetchImplementation } from './utils';\n\nexport interface FetchTransportOptions extends BaseTransportOptions {\n  requestOptions?: RequestInit;\n}\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeNewFetchTransport(\n  options: FetchTransportOptions,\n  nativeFetch: FetchImpl = getNativeFetchImplementation(),\n): NewTransport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      ...options.requestOptions,\n    };\n\n    return nativeFetch(options.url, requestOptions).then(response => {\n      return response.text().then(body => ({\n        body,\n        headers: {\n          'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n          'retry-after': response.headers.get('Retry-After'),\n        },\n        reason: response.statusText,\n        statusCode: response.status,\n      }));\n    });\n  }\n\n  return createTransport({ bufferSize: options.bufferSize }, makeRequest);\n}\n","import {\n  BaseTransportOptions,\n  createTransport,\n  NewTransport,\n  TransportMakeRequestResponse,\n  TransportRequest,\n} from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\nexport interface XHRTransportOptions extends BaseTransportOptions {\n  headers?: { [key: string]: string };\n}\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nexport function makeNewXHRTransport(options: XHRTransportOptions): NewTransport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    return new SyncPromise<TransportMakeRequestResponse>((resolve, _reject) => {\n      const xhr = new XMLHttpRequest();\n\n      xhr.onreadystatechange = (): void => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          const response = {\n            body: xhr.response,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n            reason: xhr.statusText,\n            statusCode: xhr.status,\n          };\n          resolve(response);\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (const header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport({ bufferSize: options.bufferSize }, makeRequest);\n}\n","import { captureException, getReportDialogEndpoint, withScope } from '@sentry/core';\nimport { DsnLike, Event as SentryEvent, Mechanism, Scope, WrappedFunction } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  getGlobalObject,\n  getOriginalFunction,\n  logger,\n  markFunctionWrapped,\n} from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from './flags';\n\nconst global = getGlobalObject<Window>();\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(\n  fn: WrappedFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n  before?: WrappedFunction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  /* eslint-disable prefer-rest-params */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const sentryWrapped: WrappedFunction = function (this: any): void {\n    const args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n      const wrappedArguments = args.map((arg: any) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope: Scope) => {\n        scope.addEventProcessor((event: SentryEvent) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} // eslint-disable-line no-empty\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') as PropertyDescriptor;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n    // eslint-disable-next-line no-empty\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\nexport interface ReportDialogOptions {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n  eventId?: string;\n  dsn?: DsnLike;\n  user?: {\n    email?: string;\n    name?: string;\n  };\n  lang?: string;\n  title?: string;\n  subtitle?: string;\n  subtitle2?: string;\n  labelName?: string;\n  labelEmail?: string;\n  labelComments?: string;\n  labelClose?: string;\n  labelSubmit?: string;\n  errorGeneric?: string;\n  errorFormEntry?: string;\n  successMessage?: string;\n  /** Callback after reportDialog showed up */\n  onLoad?(): void;\n}\n\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options: ReportDialogOptions = {}): void {\n  if (!global.document) {\n    return;\n  }\n\n  if (!options.eventId) {\n    IS_DEBUG_BUILD && logger.error('Missing eventId option in showReportDialog call');\n    return;\n  }\n\n  if (!options.dsn) {\n    IS_DEBUG_BUILD && logger.error('Missing dsn option in showReportDialog call');\n    return;\n  }\n\n  const script = global.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(options.dsn, options);\n\n  if (options.onLoad) {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    script.onload = options.onLoad;\n  }\n\n  const injectionPoint = global.document.head || global.document.body;\n\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  }\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, Integration, Severity } from '@sentry/types';\nimport {\n  addInstrumentationHandler,\n  getEventDescription,\n  getGlobalObject,\n  htmlTreeAsString,\n  parseUrl,\n  safeJoin,\n  severityFromString,\n} from '@sentry/utils';\n\n/** JSDoc */\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom: boolean | { serializeAttribute: string | string[] };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nexport class Breadcrumbs implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Breadcrumbs';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Breadcrumbs.id;\n\n  /** JSDoc */\n  private readonly _options: BreadcrumbsOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: Partial<BreadcrumbsOptions>) {\n    this._options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Create a breadcrumb of `sentry` from the events themselves\n   */\n  public addSentryBreadcrumb(event: Event): void {\n    if (!this._options.sentry) {\n      return;\n    }\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n        event_id: event.event_id,\n        level: event.level,\n        message: getEventDescription(event),\n      },\n      {\n        event,\n      },\n    );\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n  public setupOnce(): void {\n    if (this._options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this._options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this._options.dom));\n    }\n    if (this._options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this._options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this._options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n}\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom: BreadcrumbsOptions['dom']): (handlerData: { [key: string]: any }) => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function _innerDomBreadcrumb(handlerData: { [key: string]: any }): void {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target as Node, keyAttrs)\n        : htmlTreeAsString(handlerData.event as unknown as Node, keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData: { [key: string]: any }): void {\n  const breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData: { [key: string]: any }): void {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData: { [key: string]: any }): void {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: Severity.Error,\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData: { [key: string]: any }): void {\n  const global = getGlobalObject<Window>();\n  let from = handlerData.from;\n  let to = handlerData.to;\n  const parsedLoc = parseUrl(global.location.href);\n  let parsedFrom = parseUrl(from);\n  const parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n","import { BaseClient, Scope, SDK_VERSION } from '@sentry/core';\nimport { Event, EventHint } from '@sentry/types';\nimport { getGlobalObject, logger } from '@sentry/utils';\n\nimport { BrowserBackend, BrowserOptions } from './backend';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { injectReportDialog, ReportDialogOptions } from './helpers';\nimport { Breadcrumbs } from './integrations';\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nexport class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserOptions = {}) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(BrowserBackend, options);\n  }\n\n  /**\n   * Show a report dialog to the user to send feedback to a specific event.\n   *\n   * @param options Set individual options for the dialog\n   */\n  public showReportDialog(options: ReportDialogOptions = {}): void {\n    // doesn't work without a document (React Native)\n    const document = getGlobalObject<Window>().document;\n    if (!document) {\n      return;\n    }\n\n    if (!this._isEnabled()) {\n      IS_DEBUG_BUILD && logger.error('Trying to call showReportDialog with Sentry Client disabled');\n      return;\n    }\n\n    injectReportDialog({\n      ...options,\n      dsn: options.dsn || this.getDsn(),\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, scope?: Scope, hint?: EventHint): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, scope, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _sendEvent(event: Event): void {\n    const integration = this.getIntegration(Breadcrumbs);\n    if (integration) {\n      integration.addSentryBreadcrumb(event);\n    }\n    super._sendEvent(event);\n  }\n}\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { fill, getFunctionName, getGlobalObject, getOriginalFunction } from '@sentry/utils';\n\nimport { wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\n/** JSDoc */\ninterface TryCatchOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n}\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nexport class TryCatch implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'TryCatch';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = TryCatch.id;\n\n  /** JSDoc */\n  private readonly _options: TryCatchOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: Partial<TryCatchOptions>) {\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n  public setupOnce(): void {\n    const global = getGlobalObject();\n\n    if (this._options.setTimeout) {\n      fill(global, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(global, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(global, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    const eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n}\n\n/** JSDoc */\nfunction _wrapTimeFunction(original: () => void): () => number {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, ...args: any[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original: any): (callback: () => void) => any {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, callback: () => void): () => void {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend: () => void): () => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: XMLHttpRequest, ...args: any[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        fill(xhr, prop, function (original: WrappedFunction): () => any {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target: string): void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const global = getGlobalObject() as { [key: string]: any };\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const proto = global[target] && global[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: () => void): (\n    eventName: string,\n    fn: EventListenerObject,\n    options?: boolean | AddEventListenerOptions,\n  ) => void {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this: any,\n      eventName: string,\n      fn: EventListenerObject,\n      options?: boolean | AddEventListenerOptions,\n    ): (eventName: string, fn: EventListenerObject, capture?: boolean, secure?: boolean) => void {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        wrap(fn as any as WrappedFunction, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener: () => void,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): (this: any, eventName: string, fn: EventListenerObject, options?: boolean | EventListenerOptions) => () => void {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this: any,\n        eventName: string,\n        fn: EventListenerObject,\n        options?: boolean | EventListenerOptions,\n      ): () => void {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        const wrappedEventHandler = fn as unknown as WrappedFunction;\n        try {\n          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Hub, Integration, Primitive, Severity } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addInstrumentationHandler,\n  getLocationHref,\n  isErrorEvent,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/utils';\n\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\n/** JSDoc */\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\n/** Global handlers */\nexport class GlobalHandlers implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'GlobalHandlers';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = GlobalHandlers.id;\n\n  /** JSDoc */\n  private readonly _options: GlobalHandlersIntegrations;\n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n  private _installFunc: Record<GlobalHandlersIntegrationsOptionKeys, (() => void) | undefined> = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };\n\n  /** JSDoc */\n  public constructor(options?: GlobalHandlersIntegrations) {\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    Error.stackTraceLimit = 50;\n    const options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n    // eslint-disable-next-line guard-for-in\n    for (const key in options) {\n      const installFunc = this._installFunc[key as GlobalHandlersIntegrationsOptionKeys];\n      if (installFunc && options[key as GlobalHandlersIntegrationsOptionKeys]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key as GlobalHandlersIntegrationsOptionKeys] = undefined;\n      }\n    }\n  }\n}\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler(): void {\n  addInstrumentationHandler(\n    'error',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (data: { msg: any; url: any; line: any; column: any; error: any }) => {\n      const [hub, attachStacktrace] = getHubAndAttachStacktrace();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      const event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = Severity.Error;\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler(): void {\n  addInstrumentationHandler(\n    'unhandledrejection',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (e: any) => {\n      const [hub, attachStacktrace] = getHubAndAttachStacktrace();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      const event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(error, undefined, attachStacktrace, true);\n\n      event.level = Severity.Error;\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason: Primitive): Event {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg: any, url: any, line: any, column: any): Event {\n  const ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  const groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event: Event, url: any, line: any, column: any): Event {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  IS_DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub: Hub, error: EventHint['originalException'], event: Event, type: string): void {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndAttachStacktrace(): [Hub, boolean | undefined] {\n  const hub = getCurrentHub();\n  const client = hub.getClient();\n  const attachStacktrace = client && client.getOptions().attachStacktrace;\n  return [hub, attachStacktrace];\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { exceptionFromError } from '../eventbuilder';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\ninterface LinkedErrorsOptions {\n  key: string;\n  limit: number;\n}\n\n/** Adds SDK info to an event. */\nexport class LinkedErrors implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'LinkedErrors';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = LinkedErrors.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _key: LinkedErrorsOptions['key'];\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: LinkedErrorsOptions['limit'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: Partial<LinkedErrorsOptions> = {}) {\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(self._key, self._limit, event, hint) : event;\n    });\n  }\n}\n\n/**\n * @inheritDoc\n */\nexport function _handler(key: string, limit: number, event: Event, hint?: EventHint): Event | null {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(limit, hint.originalException as ExtendedError, key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nexport function _walkErrorTree(limit: number, error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(error[key]);\n  return _walkErrorTree(limit, error[key], key, [exception, ...stack]);\n}\n","import { Event, EventProcessor, Exception, Hub, Integration, StackFrame } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../flags';\n\n/** Deduplication filter */\nexport class Dedupe implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Dedupe';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Dedupe.id;\n\n  /**\n   * @inheritDoc\n   */\n  private _previousEvent?: Event;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor((currentEvent: Event) => {\n      const self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            IS_DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    });\n  }\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames as StackFrame[];\n  previousFrames = previousFrames as StackFrame[];\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    const frameA = previousFrames[i];\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint as string[];\n  previousFingerprint = previousFingerprint as string[];\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event: Event): Exception | undefined {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event: Event): StackFrame[] | undefined {\n  const exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  } else if (event.stacktrace) {\n    return event.stacktrace.frames;\n  }\n  return undefined;\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, Integration } from '@sentry/types';\nimport { getGlobalObject } from '@sentry/utils';\n\nconst global = getGlobalObject<Window>();\n\n/** UserAgent */\nexport class UserAgent implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'UserAgent';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = UserAgent.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    addGlobalEventProcessor((event: Event) => {\n      if (getCurrentHub().getIntegration(UserAgent)) {\n        // if none of the information we want exists, don't bother\n        if (!global.navigator && !global.location && !global.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        const url = (event.request && event.request.url) || (global.location && global.location.href);\n        const { referrer } = global.document || {};\n        const { userAgent } = global.navigator || {};\n\n        const headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        const request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n}\n","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { Hub } from '@sentry/types';\nimport { addInstrumentationHandler, getGlobalObject, logger, resolvedSyncPromise } from '@sentry/utils';\n\nimport { BrowserOptions } from './backend';\nimport { BrowserClient } from './client';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { ReportDialogOptions, wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, Dedupe, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\n\nexport const defaultIntegrations = [\n  new CoreIntegrations.InboundFilters(),\n  new CoreIntegrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new UserAgent(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options: BrowserOptions = {}): void {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    const window = getGlobalObject<Window>();\n    // This supports the variable that sentry-webpack-plugin injects\n    if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {\n      options.release = window.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  initAndBind(BrowserClient, options);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options: ReportDialogOptions = {}): void {\n  const hub = getCurrentHub();\n  const scope = hub.getScope();\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n  const client = hub.getClient<BrowserClient>();\n  if (client) {\n    client.showReportDialog(options);\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId(): string | undefined {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad(): void {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback: () => void): void {\n  callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function flush(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.flush(timeout);\n  }\n  IS_DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function close(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.close(timeout);\n  }\n  IS_DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn: (...args: any) => any): any {\n  return internalWrap(fn)();\n}\n\nfunction startSessionOnHub(hub: Hub): void {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  const window = getGlobalObject<Window>();\n  const document = window.document;\n\n  if (typeof document === 'undefined') {\n    IS_DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  const hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n"],"names":["IS_DEBUG_BUILD","__SENTRY_DEBUG__","UNKNOWN_FUNCTION","createFrame","filename","func","lineno","colno","frame","function","in_app","undefined","chromeRegex","chromeEvalRegex","chromeStackParser","line","parts","exec","indexOf","subMatch","geckoREgex","geckoEvalRegex","geckoStackParser","winjsRegex","winjsStackParser","opera10Regex","opera10StackParser","opera11Regex","opera11StackParser","extractSafariExtensionDetails","isSafariExtension","isSafariWebExtension","split","exceptionFromError","ex","frames","parseStackFrames","exception","type","name","value","extractMessage","length","stacktrace","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","e","error","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","event","is","domException","eventFromString","tags","code","constructor","extra","__serialized__","normalize","eventFromPlainObject","synthetic","input","requestTypeToCategory","ty","global","options","_buffer","_rateLimits","_outcomes","this","_api","dsn","_metadata","tunnel","url","sendClientReports","document","addEventListener","visibilityState","_flushOutcomes","sendEvent","_sendRequest","sendSession","session","close","timeout","drain","recordLostEvent","reason","category","key","log","outcomes","Object","keys","JSON","stringify","discardedEvents","map","quantity","envelope","_handleResponse","requestType","response","headers","resolve","reject","status","_isRateLimited","_disabledUntil","Date","fetchImpl","_fetch","sentryRequest","originalPayload","Promise","body","method","referrerPolicy","supports","fetchParameters","assign","add","then","get","catch","BaseTransport","request","XMLHttpRequest","header","onreadystatechange","readyState","getResponseHeader","open","prototype","hasOwnProperty","call","setRequestHeader","send","eventFromException","hint","level","event_id","_options","eventFromMessage","_setupTransport","nativeFetch","transportOptions","api","transport","requestOptions","_newTransport","bufferSize","text","statusText","statusCode","FetchTransport","_reject","xhr","makeNewXHRTransport","XHRTransport","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","slice","arguments","apply","wrappedArguments","arg","scope","addEventProcessor","mechanism","property","_oO","getOwnPropertyDescriptor","configurable","defineProperty","Breadcrumbs","id","console","dom","fetch","history","sentry","addSentryBreadcrumb","addBreadcrumb","setupOnce","_consoleBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","data","logger","endTimestamp","__sentry_own_request__","status_code","fetchData","match","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","sdk","packages","version","BrowserBackend","showReportDialog","_isEnabled","eventId","script","createElement","async","src","onLoad","onload","injectionPoint","head","appendChild","injectReportDialog","getDsn","_prepareEvent","platform","_sendEvent","integration","getIntegration","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","forEach","_wrapEventTarget","original","originalCallback","handled","callback","handler","originalSend","xmlHttpRequestProps","prop","wrapOptions","originalFunction","proto","eventName","handleEvent","bind","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","installFunc","hub","msg","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","String","ev","ev0","ev0s","ev0sf","isNaN","parseInt","push","captureEvent","originalException","getHubAndAttachStacktrace","client","getClient","getOptions","LinkedErrors","_key","_limit","limit","self","linkedErrors","_walkErrorTree","_handler","Dedupe","addGlobalEventProcessor","getCurrentHub","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","i","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","UserAgent","navigator","referrer","userAgent","Referer","defaultIntegrations","init","release","SENTRY_RELEASE","autoSessionTracking","BrowserClient","captureSession","startSessionOnHub","startSessionTracking","getScope","user","getUser","lastEventId","startSession","ignoreDuration"],"sourceRoot":""}