{"version":3,"file":"static/js/main-5b69c406-f4fd9b97e120e18e349c.js","mappings":"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AAyB,SApCN,CAAE/G,EAAuC,MACvE,MAAMkG,EAAW,CACfc,SAAS,EACTC,KAAK,EACLC,OAAO,EACPC,SAAS,EACTC,QAAQ,EACRC,KAAK,KACFrH,GAGL,MAAO,CACL8B,KAdqB,cAerBwF,MAAMzE,GACAqD,EAASc,UACX,OAgH2E,YACA,mBACA,kBACA,OAGA,SACA,mBACA,MACA,iBACA,kBAEA,uBACA,8BAGA,uBACA,kBAKA,OAJA,iFACA,kCAOA,UACA,aACA,iBA5I1CO,CAA6B1E,IAE5DqD,EAASe,MACX,OA+C2E,SACA,EACA,GAEA,mBACA,kBACA,OAGA,MACA,EACA,iDAEA,EACA,gFACA,SACA,KACA,UACA,iHAEA,KAGA,qBACA,OAIA,IACA,gBACA,EAyNA,YACA,sBA1NA,eAEA,6CACA,cACA,SACA,cAGA,gBACA,OAGA,SACA,wBACA,WAGA,IACA,iCAGA,UACA,cACA,YACA,mBArGpCO,CAAyB3E,EAAQqD,EAASe,MAE/Ef,EAASmB,MACX,QA8I2E,YACA,mBACA,kBACA,OAGA,yCAEA,cAGA,cACA,OAGA,6CAEA,GACA,SACA,MACA,eAGA,GACA,UACA,QACA,iBACA,gBAGA,cAEA,OACA,CACA,eACA,OACA,YACA,SAEA,IArL9CI,CAAyB5E,IAEpDqD,EAASgB,QACX,QA0L2E,YACA,mBACA,kBACA,OAGA,yCAGA,QAIA,kEAKA,aASA,OACA,CACA,iBACA,KAXA,YAYA,cACA,aAZA,CACA,aACA,aACA,iBACA,qBAYA,CACA,mBACA,MACA,YACA,yBAEA,GACA,aACA,WACA,iBACA,gBAEA,0BAEA,OACA,CACA,iBACA,OACA,YACA,SAEA,KAnP5CQ,CAA2B7E,IAExDqD,EAASiB,UACX,IAAAQ,GAyP2E,YACA,mBACA,kBACA,OAGA,aACA,OACA,qCACA,2BACA,oBAGA,YACA,KAKA,2CACA,cAEA,2CACA,eAGA,QACA,sBACA,MACA,OACA,SAvR1CC,CAA6B/E,IAE5DqD,EAASkB,QACXvE,EAAOgF,GAAG,kBAWlB,SAAqChF,GACnC,OAAO,SAA6B7B,IAC9B,YAAg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","sources":["webpack://leadsbridge/./node_modules/@sentry/browser/src/debug-build.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/helpers.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/eventbuilder.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/userfeedback.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/client.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/integrations/breadcrumbs.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/integrations/browserapierrors.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/integrations/globalhandlers.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/integrations/httpcontext.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/integrations/linkederrors.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/stack-parsers.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/transports/fetch.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/sdk.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/tracing/request.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/tracing/browserTracingIntegration.ts","webpack://leadsbridge/./node_modules/@sentry/browser/src/tracing/backgroundtab.ts"],"sourcesContent":["declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import type { Mechanism, WrappedFunction } from '@sentry/core';\nimport {\n  GLOBAL_OBJ,\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  captureException,\n  getOriginalFunction,\n  markFunctionWrapped,\n  withScope,\n} from '@sentry/core';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\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++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype WrappableFunction = Function;\n\nexport function wrap<T extends WrappableFunction>(\n  fn: T,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): WrappedFunction<T>;\nexport function wrap<NonFunction>(\n  fn: NonFunction,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): NonFunction;\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. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap<T extends WrappableFunction, NonFunction>(\n  fn: T | NonFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n): NonFunction | WrappedFunction<T> {\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  function isFunction(fn: T | NonFunction): fn is T {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\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 as WrappedFunction<T>).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\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  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function (this: unknown, ...args: unknown[]): unknown {\n    try {\n      // Also wrap arguments that are themselves functions\n      const wrappedArguments = args.map(arg => 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 => {\n        scope.addEventProcessor(event => {\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  } as unknown as WrappedFunction<T>;\n\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property as keyof T] = fn[property as keyof T];\n      }\n    }\n  } catch {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name')!;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n  } catch {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n","import type {\n  Event,\n  EventHint,\n  Exception,\n  ParameterizedString,\n  SeverityLevel,\n  StackFrame,\n  StackParser,\n} from '@sentry/core';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  getClient,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isParameterizedString,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/core';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: extractType(ex),\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\nfunction eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const client = getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  // If we can, we extract an exception from the object properties\n  const errorFromProp = getErrorPropertyFromObject(exception);\n\n  const extra = {\n    __serialized__: normalizeToSize(exception, normalizeDepth),\n  };\n\n  if (errorFromProp) {\n    return {\n      exception: {\n        values: [exceptionFromError(stackParser, errorFromProp)],\n      },\n      extra,\n    };\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        } as Exception,\n      ],\n    },\n    extra,\n  } satisfies Event;\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception.values[0]!.stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\nfunction eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): 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 skipLines = getSkipFirstStackStringLines(ex);\n  const framesToPop = getPopFirstTopFrames(ex);\n\n  try {\n    return stackParser(stacktrace, skipLines, framesToPop);\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\n/**\n * Certain known React errors contain links that would be falsely\n * parsed as frames. This function check for these errors and\n * returns number of the stack string lines to skip.\n */\nfunction getSkipFirstStackStringLines(ex: Error): number {\n  if (ex && reactMinifiedRegexp.test(ex.message)) {\n    return 1;\n  }\n\n  return 0;\n}\n\n/**\n * If error has `framesToPop` property, it means that the\n * creator tells us the first x frames will be useless\n * and should be discarded. Typically error from wrapper function\n * which don't point to the actual location in the developer's code.\n *\n * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46\n */\nfunction getPopFirstTopFrames(ex: Error & { framesToPop?: unknown }): number {\n  if (typeof ex.framesToPop === 'number') {\n    return ex.framesToPop;\n  }\n\n  return 0;\n}\n\n// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception\n// @ts-expect-error - WebAssembly.Exception is a valid class\nfunction isWebAssemblyException(exception: unknown): exception is WebAssembly.Exception {\n  // Check for support\n  // @ts-expect-error - WebAssembly.Exception is a valid class\n  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {\n    // @ts-expect-error - WebAssembly.Exception is a valid class\n    return exception instanceof WebAssembly.Exception;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Extracts from errors what we use as the exception `type` in error events.\n *\n * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.\n */\nexport function extractType(ex: Error & { message: { error?: Error } }): string | undefined {\n  const name = ex && ex.name;\n\n  // The name for WebAssembly.Exception Errors needs to be extracted differently.\n  // Context: https://github.com/getsentry/sentry-javascript/issues/13787\n  if (!name && isWebAssemblyException(ex)) {\n    // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;\n    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';\n  }\n\n  return name;\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 */\nexport function extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex && ex.message;\n\n  if (!message) {\n    return 'No error message';\n  }\n\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n\n  // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n  if (isWebAssemblyException(ex) && Array.isArray(ex.message) && ex.message.length == 2) {\n    return ex.message[1];\n  }\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  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = '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  stackParser: StackParser,\n  message: ParameterizedString,\n  level: SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, 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  stackParser: StackParser,\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(stackParser, 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) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, 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(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\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(stackParser, 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(stackParser, 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(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\nfunction eventFromString(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception: Record<string, unknown>,\n  { isUnhandledRejection }: { isUnhandledRejection?: boolean },\n): string {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj: unknown): string | undefined | void {\n  try {\n    const prototype: Prototype | null = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch (e) {\n    // ignore errors here\n  }\n}\n\n/** If a plain object has a property that is an `Error`, return this error. */\nfunction getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {\n  for (const prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      const value = obj[prop];\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return undefined;\n}\n","import { createEnvelope, dsnToString } from '@sentry/core';\nimport type { DsnComponents, EventEnvelope, SdkMetadata, UserFeedback, UserFeedbackItem } from '@sentry/core';\n\n/**\n * Creates an envelope from a user feedback.\n */\nexport function createUserFeedbackEnvelope(\n  feedback: UserFeedback,\n  {\n    metadata,\n    tunnel,\n    dsn,\n  }: {\n    metadata: SdkMetadata | undefined;\n    tunnel: string | undefined;\n    dsn: DsnComponents | undefined;\n  },\n): EventEnvelope {\n  const headers: EventEnvelope[0] = {\n    event_id: feedback.event_id,\n    sent_at: new Date().toISOString(),\n    ...(metadata &&\n      metadata.sdk && {\n        sdk: {\n          name: metadata.sdk.name,\n          version: metadata.sdk.version,\n        },\n      }),\n    ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),\n  };\n  const item = createUserFeedbackEnvelopeItem(feedback);\n\n  return createEnvelope(headers, [item]);\n}\n\nfunction createUserFeedbackEnvelopeItem(feedback: UserFeedback): UserFeedbackItem {\n  const feedbackHeaders: UserFeedbackItem[0] = {\n    type: 'user_report',\n  };\n  return [feedbackHeaders, feedback];\n}\n","import type {\n  BrowserClientProfilingOptions,\n  BrowserClientReplayOptions,\n  ClientOptions,\n  Event,\n  EventHint,\n  Options,\n  ParameterizedString,\n  Scope,\n  SeverityLevel,\n  UserFeedback,\n} from '@sentry/core';\nimport { BaseClient, applySdkMetadata, getSDKSource, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { WINDOW } from './helpers';\nimport type { BrowserTransportOptions } from './transports/types';\nimport { createUserFeedbackEnvelope } from './userfeedback';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/core Options for more information.\n */\nexport type BrowserOptions = Options<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions & {\n    /**\n     * Important: Only set this option if you know what you are doing!\n     *\n     * By default, the SDK will check if `Sentry.init` is called in a browser extension.\n     * In case it is, it will stop initialization and log a warning\n     * because browser extensions require a different Sentry initialization process:\n     * https://docs.sentry.io/platforms/javascript/best-practices/shared-environments/\n     *\n     * Setting up the SDK in a browser extension with global error monitoring is not recommended\n     * and will likely flood you with errors from other web sites or extensions. This can heavily\n     * impact your quota and cause interference with your and other Sentry SDKs in shared environments.\n     *\n     * If this check wrongfully flags your setup as a browser extension, you can set this\n     * option to `true` to skip the check.\n     *\n     * @default false\n     */\n    skipBrowserExtensionCheck?: boolean;\n  };\n\n/**\n * Configuration options for the Sentry Browser SDK Client class\n * @see BrowserClient for more information.\n */\nexport type BrowserClientOptions = ClientOptions<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions & {\n    /** If configured, this URL will be used as base URL for lazy loading integration. */\n    cdnBaseUrl?: string;\n  };\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<BrowserClientOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserClientOptions) {\n    const opts = {\n      // We default this to true, as it is the safer scenario\n      parentSpanIsAlwaysRootSpan: true,\n      ...options,\n    };\n    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n    applySdkMetadata(opts, 'browser', ['browser'], sdkSource);\n\n    super(opts);\n\n    if (opts.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(\n    message: ParameterizedString,\n    level: SeverityLevel = 'info',\n    hint?: EventHint,\n  ): PromiseLike<Event> {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * Sends user feedback to Sentry.\n   *\n   * @deprecated Use `captureFeedback` instead.\n   */\n  public captureUserFeedback(feedback: UserFeedback): void {\n    if (!this._isEnabled()) {\n      DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');\n      return;\n    }\n\n    const envelope = createUserFeedbackEnvelope(feedback, {\n      metadata: this.getSdkMetadata(),\n      dsn: this.getDsn(),\n      tunnel: this.getOptions().tunnel,\n    });\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n}\n","/* eslint-disable max-lines */\n\nimport {\n  SENTRY_XHR_DATA_KEY,\n  addClickKeypressInstrumentationHandler,\n  addHistoryInstrumentationHandler,\n  addXhrInstrumentationHandler,\n} from '@sentry-internal/browser-utils';\nimport type {\n  Breadcrumb,\n  Client,\n  Event as SentryEvent,\n  FetchBreadcrumbData,\n  FetchBreadcrumbHint,\n  HandlerDataConsole,\n  HandlerDataDom,\n  HandlerDataFetch,\n  HandlerDataHistory,\n  HandlerDataXhr,\n  IntegrationFn,\n  XhrBreadcrumbData,\n  XhrBreadcrumbHint,\n} from '@sentry/core';\nimport {\n  addBreadcrumb,\n  addConsoleInstrumentationHandler,\n  addFetchInstrumentationHandler,\n  defineIntegration,\n  getBreadcrumbLogLevelFromHttpStatusCode,\n  getClient,\n  getComponentName,\n  getEventDescription,\n  htmlTreeAsString,\n  logger,\n  parseUrl,\n  safeJoin,\n  severityLevelFromString,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom:\n    | boolean\n    | {\n        serializeAttribute?: string | string[];\n        maxStringLength?: number;\n      };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) => {\n  const _options = {\n    console: true,\n    dom: true,\n    fetch: true,\n    history: true,\n    sentry: true,\n    xhr: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      if (_options.console) {\n        addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n      }\n      if (_options.dom) {\n        addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n      }\n      if (_options.xhr) {\n        addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n      }\n      if (_options.fetch) {\n        addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n      }\n      if (_options.history) {\n        addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n      }\n      if (_options.sentry) {\n        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client: Client): (event: SentryEvent) => void {\n  return function addSentryBreadcrumb(event: SentryEvent): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    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/**\n * A HOC that creates 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 */\nfunction _getDomBreadcrumbHandler(\n  client: Client,\n  dom: BreadcrumbsOptions['dom'],\n): (handlerData: HandlerDataDom) => void {\n  return function _innerDomBreadcrumb(handlerData: HandlerDataDom): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let target;\n    let componentName;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    let maxStringLength =\n      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n        );\n      maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n    }\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      const event = handlerData.event as Event | Node;\n      const element = _isEvent(event) ? event.target : event;\n\n      target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n      componentName = getComponentName(element);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    const breadcrumb: Breadcrumb = {\n      category: `ui.${handlerData.name}`,\n      message: target,\n    };\n\n    if (componentName) {\n      breadcrumb.data = { 'ui.component_name': componentName };\n    }\n\n    addBreadcrumb(breadcrumb, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client: Client): (handlerData: HandlerDataConsole) => void {\n  return function _consoleBreadcrumb(handlerData: HandlerDataConsole): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: severityLevelFromString(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    addBreadcrumb(breadcrumb, {\n      input: handlerData.args,\n      level: handlerData.level,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client: Client): (handlerData: HandlerDataXhr) => void {\n  return function _xhrBreadcrumb(handlerData: HandlerDataXhr): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n    // We only capture complete, non-sentry requests\n    if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n      return;\n    }\n\n    const { method, url, status_code, body } = sentryXhrData;\n\n    const data: XhrBreadcrumbData = {\n      method,\n      url,\n      status_code,\n    };\n\n    const hint: XhrBreadcrumbHint = {\n      xhr: handlerData.xhr,\n      input: body,\n      startTimestamp,\n      endTimestamp,\n    };\n\n    const level = getBreadcrumbLogLevelFromHttpStatusCode(status_code);\n\n    addBreadcrumb(\n      {\n        category: 'xhr',\n        data,\n        type: 'http',\n        level,\n      },\n      hint,\n    );\n  };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client: Client): (handlerData: HandlerDataFetch) => void {\n  return function _fetchBreadcrumb(handlerData: HandlerDataFetch): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    // We only capture complete fetch requests\n    if (!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      const data: FetchBreadcrumbData = handlerData.fetchData;\n      const hint: FetchBreadcrumbHint = {\n        data: handlerData.error,\n        input: handlerData.args,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          level: 'error',\n          type: 'http',\n        },\n        hint,\n      );\n    } else {\n      const response = handlerData.response as Response | undefined;\n      const data: FetchBreadcrumbData = {\n        ...handlerData.fetchData,\n        status_code: response && response.status,\n      };\n      const hint: FetchBreadcrumbHint = {\n        input: handlerData.args,\n        response,\n        startTimestamp,\n        endTimestamp,\n      };\n      const level = getBreadcrumbLogLevelFromHttpStatusCode(data.status_code);\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          type: 'http',\n          level,\n        },\n        hint,\n      );\n    }\n  };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client: Client): (handlerData: HandlerDataHistory) => void {\n  return function _historyBreadcrumb(handlerData: HandlerDataHistory): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let from: string | undefined = handlerData.from;\n    let to: string | undefined = handlerData.to;\n    const parsedLoc = parseUrl(WINDOW.location.href);\n    let parsedFrom = from ? parseUrl(from) : undefined;\n    const parsedTo = parseUrl(to);\n\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom || !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    addBreadcrumb({\n      category: 'navigation',\n      data: {\n        from,\n        to,\n      },\n    });\n  };\n}\n\nfunction _isEvent(event: unknown): event is Event {\n  return !!event && !!(event as Record<string, unknown>).target;\n}\n","import type { IntegrationFn, WrappedFunction } from '@sentry/core';\nimport { defineIntegration, fill, getFunctionName, getOriginalFunction } from '@sentry/core';\n\nimport { WINDOW, wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\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  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'BrowserApiErrors';\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\ninterface BrowserApiErrorsOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n}\n\nconst _browserApiErrorsIntegration = ((options: Partial<BrowserApiErrorsOptions> = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n */\nexport const browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\nfunction _wrapTimeFunction(original: () => void): () => number {\n  return function (this: unknown, ...args: unknown[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: false,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\nfunction _wrapRAF(original: () => void): (callback: () => void) => unknown {\n  return function (this: unknown, callback: () => void): () => void {\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend: () => void): () => void {\n  return function (this: XMLHttpRequest, ...args: unknown[]): 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        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before BrowserApiErrors, 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\nfunction _wrapEventTarget(target: string): void {\n  const globalObject = WINDOW as unknown as Record<string, { prototype?: object }>;\n  const targetObj = globalObject[target];\n  const proto = targetObj && targetObj.prototype;\n\n  // eslint-disable-next-line no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: VoidFunction,): (\n    ...args: Parameters<typeof WINDOW.addEventListener>\n  ) => ReturnType<typeof WINDOW.addEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\n      try {\n        if (isEventListenerObject(fn)) {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        wrap(fn, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener: VoidFunction,): (\n    this: unknown,\n    ...args: Parameters<typeof WINDOW.removeEventListener>\n  ) => ReturnType<typeof WINDOW.removeEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\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      try {\n        const originalEventHandler = (fn as WrappedFunction).__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, fn, options);\n    };\n  });\n}\n\nfunction isEventListenerObject(obj: unknown): obj is EventListenerObject {\n  return typeof (obj as EventListenerObject).handleEvent === 'function';\n}\n","import type { Client, Event, IntegrationFn, Primitive, StackParser } from '@sentry/core';\nimport {\n  UNKNOWN_FUNCTION,\n  addGlobalErrorInstrumentationHandler,\n  addGlobalUnhandledRejectionInstrumentationHandler,\n  captureEvent,\n  defineIntegration,\n  getClient,\n  getLocationHref,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/core';\n\nimport type { BrowserClient } from '../client';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options: Partial<GlobalHandlersIntegrations> = {}) => {\n  const _options = {\n    onerror: true,\n    onunhandledrejection: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      Error.stackTraceLimit = 50;\n    },\n    setup(client) {\n      if (_options.onerror) {\n        _installGlobalOnErrorHandler(client);\n        globalHandlerLog('onerror');\n      }\n      if (_options.onunhandledrejection) {\n        _installGlobalOnUnhandledRejectionHandler(client);\n        globalHandlerLog('onunhandledrejection');\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\nfunction _installGlobalOnErrorHandler(client: Client): void {\n  addGlobalErrorInstrumentationHandler(data => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const { msg, url, line, column, error } = data;\n\n    const event = _enhanceEventWithInitialFrame(\n      eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n      url,\n      line,\n      column,\n    );\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onerror',\n      },\n    });\n  });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client: Client): void {\n  addGlobalUnhandledRejectionInstrumentationHandler(e => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const error = _getUnhandledRejectionError(e as unknown);\n\n    const event = isPrimitive(error)\n      ? _eventFromRejectionWithPrimitive(error)\n      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n  });\n}\n\nfunction _getUnhandledRejectionError(error: unknown): unknown {\n  if (isPrimitive(error)) {\n    return error;\n  }\n\n  // dig the object of the rejection out of known event types\n  try {\n    type ErrorWithReason = { reason: unknown };\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 (error as ErrorWithReason)) {\n      return (error as ErrorWithReason).reason;\n    }\n\n    type CustomEventWithDetail = { detail: { reason: unknown } };\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    if ('detail' in (error as CustomEventWithDetail) && 'reason' in (error as CustomEventWithDetail).detail) {\n      return (error as CustomEventWithDetail).detail.reason;\n    }\n  } catch {} // eslint-disable-line no-empty\n\n  return error;\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// 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: UNKNOWN_FUNCTION,\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions(): { stackParser: StackParser; attachStacktrace?: boolean } {\n  const client = getClient<BrowserClient>();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return options;\n}\n","import { defineIntegration } from '@sentry/core';\nimport { WINDOW } from '../helpers';\n\n/**\n * Collects information about HTTP request headers and\n * attaches them to the event.\n */\nexport const httpContextIntegration = defineIntegration(() => {\n  return {\n    name: 'HttpContext',\n    preprocessEvent(event) {\n      // if none of the information we want exists, don't bother\n      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n        return;\n      }\n\n      // grab as much info as exists and add it to the event\n      const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n      const { referrer } = WINDOW.document || {};\n      const { userAgent } = WINDOW.navigator || {};\n\n      const headers = {\n        ...(event.request && event.request.headers),\n        ...(referrer && { Referer: referrer }),\n        ...(userAgent && { 'User-Agent': userAgent }),\n      };\n      const request = { ...event.request, ...(url && { url }), headers };\n\n      event.request = request;\n    },\n  };\n});\n","import type { IntegrationFn } from '@sentry/core';\nimport { applyAggregateErrorsToEvent, defineIntegration } from '@sentry/core';\nimport { exceptionFromError } from '../eventbuilder';\n\ninterface LinkedErrorsOptions {\n  key?: string;\n  limit?: number;\n}\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => {\n  const limit = options.limit || DEFAULT_LIMIT;\n  const key = options.key || DEFAULT_KEY;\n\n  return {\n    name: INTEGRATION_NAME,\n    preprocessEvent(event, hint, client) {\n      const options = client.getOptions();\n\n      applyAggregateErrorsToEvent(\n        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n        exceptionFromError,\n        options.stackParser,\n        options.maxValueLength,\n        key,\n        limit,\n        event,\n        hint,\n      );\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Aggregrate linked errors in an event.\n */\nexport const linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n","// This was originally forked from https://github.com/csnover/TraceKit, and was largely\n// re - written as part of raven - js.\n//\n// This code was later copied to the JavaScript mono - repo and further modified and\n// refactored over the years.\n\n// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this\n// software and associated documentation files(the 'Software'), to deal in the Software\n// without restriction, including without limitation the rights to use, copy, modify,\n// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to the following\n// conditions:\n//\n// The above copyright notice and this permission notice shall be included in all copies\n// or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\n// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF\n// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE\n// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nimport { UNKNOWN_FUNCTION, createStackParser } from '@sentry/core';\nimport type { StackFrame, StackLineParser, StackLineParserFn } from '@sentry/core';\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 === '<anonymous>' ? UNKNOWN_FUNCTION : func,\n    in_app: true, // All browser frames are considered in_app\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// This regex matches frames that have no function name (ie. are at the top level of a module).\n// For example \"at http://localhost:5000//script.js:1:126\"\n// Frames _with_ function names usually look as follows: \"at commitLayoutEffects (react-dom.development.js:23426:1)\"\nconst chromeRegexNoFnName = /^\\s*at (\\S+?)(?::(\\d+))(?::(\\d+))\\s*$/i;\n\n// This regex matches all the frames that have a function name.\nconst chromeRegex =\n  /^\\s*at (?:(.+?\\)(?: \\[.+\\])?|.*?) ?\\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn: StackLineParserFn = line => {\n  // If the stack line has no function name, we need to parse it differently\n  const noFnParts = chromeRegexNoFnName.exec(line) as null | [string, string, string, string];\n\n  if (noFnParts) {\n    const [, filename, line, col] = noFnParts;\n    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col);\n  }\n\n  const parts = chromeRegex.exec(line) as null | [string, string, string, string, string];\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]) as null | [string, string, string, string];\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 chromeStackLineParser: StackLineParser = [CHROME_PRIORITY, chromeStackParserFn];\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*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[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) as null | [string, string, string, string, string, string];\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]) as null | [string, string, string];\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 geckoStackLineParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line) as null | [string, string, string, string, string];\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 winjsStackLineParser: 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) as null | [string, string, string, string];\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackLineParser: 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) as null | [string, string, string, string, string, string];\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackLineParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\nexport const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser];\n\nexport const defaultStackParser = createStackParser(...defaultStackLineParsers);\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] as string) : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","import { clearCachedImplementation, getNativeImplementation } from '@sentry-internal/browser-utils';\nimport type { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/core';\nimport { createTransport, rejectedSyncPromise } from '@sentry/core';\nimport type { WINDOW } from '../helpers';\nimport type { BrowserTransportOptions } from './types';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeFetchTransport(\n  options: BrowserTransportOptions,\n  nativeFetch: typeof WINDOW.fetch | undefined = getNativeImplementation('fetch'),\n): Transport {\n  let pendingBodySize = 0;\n  let pendingCount = 0;\n\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestSize = request.body.length;\n    pendingBodySize += requestSize;\n    pendingCount++;\n\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. when finishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):\n      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n      //   We will therefore only activate the flag when we're below that limit.\n      // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n      keepalive: pendingBodySize <= 60_000 && pendingCount < 15,\n      ...options.fetchOptions,\n    };\n\n    if (!nativeFetch) {\n      clearCachedImplementation('fetch');\n      return rejectedSyncPromise('No fetch implementation available');\n    }\n\n    try {\n      // TODO: This may need a `suppressTracing` call in the future when we switch the browser SDK to OTEL\n      return nativeFetch(options.url, requestOptions).then(response => {\n        pendingBodySize -= requestSize;\n        pendingCount--;\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    } catch (e) {\n      clearCachedImplementation('fetch');\n      pendingBodySize -= requestSize;\n      pendingCount--;\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport {\n  captureSession,\n  consoleSandbox,\n  dedupeIntegration,\n  functionToStringIntegration,\n  getClient,\n  getCurrentScope,\n  getIntegrationsToSetup,\n  getReportDialogEndpoint,\n  inboundFiltersIntegration,\n  initAndBind,\n  lastEventId,\n  logger,\n  stackParserFromStackParserOptions,\n  startSession,\n  supportsFetch,\n} from '@sentry/core';\nimport type { Client, DsnLike, Integration, Options, UserFeedback } from '@sentry/core';\nimport type { BrowserClientOptions, BrowserOptions } from './client';\nimport { BrowserClient } from './client';\nimport { DEBUG_BUILD } from './debug-build';\nimport { WINDOW } from './helpers';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs';\nimport { browserApiErrorsIntegration } from './integrations/browserapierrors';\nimport { globalHandlersIntegration } from './integrations/globalhandlers';\nimport { httpContextIntegration } from './integrations/httpcontext';\nimport { linkedErrorsIntegration } from './integrations/linkederrors';\nimport { defaultStackParser } from './stack-parsers';\nimport { makeFetchTransport } from './transports/fetch';\n\n/** Get the default integrations for the browser SDK. */\nexport function getDefaultIntegrations(_options: Options): Integration[] {\n  /**\n   * Note: Please make sure this stays in sync with Angular SDK, which re-exports\n   * `getDefaultIntegrations` but with an adjusted set of integrations.\n   */\n  return [\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    browserApiErrorsIntegration(),\n    breadcrumbsIntegration(),\n    globalHandlersIntegration(),\n    linkedErrorsIntegration(),\n    dedupeIntegration(),\n    httpContextIntegration(),\n  ];\n}\n\nfunction applyDefaultOptions(optionsArg: BrowserOptions = {}): BrowserOptions {\n  const defaultOptions: BrowserOptions = {\n    defaultIntegrations: getDefaultIntegrations(optionsArg),\n    release:\n      typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n        ? __SENTRY_RELEASE__\n        : WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id // This supports the variable that sentry-webpack-plugin injects\n          ? WINDOW.SENTRY_RELEASE.id\n          : undefined,\n    autoSessionTracking: true,\n    sendClientReports: true,\n  };\n\n  // TODO: Instead of dropping just `defaultIntegrations`, we should simply\n  // call `dropUndefinedKeys` on the entire `optionsArg`.\n  // However, for this to work we need to adjust the `hasTracingEnabled()` logic\n  // first as it differentiates between `undefined` and the key not being in the object.\n  if (optionsArg.defaultIntegrations == null) {\n    delete optionsArg.defaultIntegrations;\n  }\n\n  return { ...defaultOptions, ...optionsArg };\n}\n\ntype ExtensionProperties = {\n  chrome?: Runtime;\n  browser?: Runtime;\n  nw?: unknown;\n};\ntype Runtime = {\n  runtime?: {\n    id?: string;\n  };\n};\n\nfunction shouldShowBrowserExtensionError(): boolean {\n  const windowWithMaybeExtension =\n    typeof WINDOW.window !== 'undefined' && (WINDOW as typeof WINDOW & ExtensionProperties);\n  if (!windowWithMaybeExtension) {\n    // No need to show the error if we're not in a browser window environment (e.g. service workers)\n    return false;\n  }\n\n  const extensionKey = windowWithMaybeExtension.chrome ? 'chrome' : 'browser';\n  const extensionObject = windowWithMaybeExtension[extensionKey];\n\n  const runtimeId = extensionObject && extensionObject.runtime && extensionObject.runtime.id;\n  const href = (WINDOW.location && WINDOW.location.href) || '';\n\n  const extensionProtocols = ['chrome-extension:', 'moz-extension:', 'ms-browser-extension:', 'safari-web-extension:'];\n\n  // Running the SDK in a dedicated extension page and calling Sentry.init is fine; no risk of data leakage\n  const isDedicatedExtensionPage =\n    !!runtimeId && WINDOW === WINDOW.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}//`));\n\n  // Running the SDK in NW.js, which appears like a browser extension but isn't, is also fine\n  // see: https://github.com/getsentry/sentry-javascript/issues/12668\n  const isNWjs = typeof windowWithMaybeExtension.nw !== 'undefined';\n\n  return !!runtimeId && !isDedicatedExtensionPage && !isNWjs;\n}\n\n/**\n * A magic string that build tooling can leverage in order to inject a release value into the SDK.\n */\ndeclare const __SENTRY_RELEASE__: string | undefined;\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 { 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(browserOptions: BrowserOptions = {}): Client | undefined {\n  const options = applyDefaultOptions(browserOptions);\n\n  if (!options.skipBrowserExtensionCheck && shouldShowBrowserExtensionError()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(\n        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',\n      );\n    });\n    return;\n  }\n\n  if (DEBUG_BUILD) {\n    if (!supportsFetch()) {\n      logger.warn(\n        'No Fetch API detected. The Sentry SDK requires a Fetch API compatible environment to send events. Please add a Fetch API polyfill.',\n      );\n    }\n  }\n  const clientOptions: BrowserClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeFetchTransport,\n  };\n\n  const client = initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n\n  return client;\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?(this: void): void;\n  /** Callback after reportDialog closed */\n  onClose?(this: void): void;\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  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const scope = getCurrentScope();\n  const client = scope.getClient();\n  const dsn = client && client.getDsn();\n\n  if (!dsn) {\n    DEBUG_BUILD && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    const eventId = lastEventId();\n    if (eventId) {\n      options.eventId = eventId;\n    }\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.crossOrigin = 'anonymous';\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    script.onload = options.onLoad;\n  }\n\n  const { onClose } = options;\n  if (onClose) {\n    const reportDialogClosedMessageHandler = (event: MessageEvent): void => {\n      if (event.data === '__sentry_reportdialog_closed__') {\n        try {\n          onClose();\n        } finally {\n          WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n        }\n      }\n    };\n    WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\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 * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  if (typeof WINDOW.document === 'undefined') {\n    DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\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  startSession({ ignoreDuration: true });\n  captureSession();\n\n  // We want to create a session for every navigation as well\n  addHistoryInstrumentationHandler(({ 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      startSession({ ignoreDuration: true });\n      captureSession();\n    }\n  });\n}\n\n/**\n * Captures user feedback and sends it to Sentry.\n *\n * @deprecated Use `captureFeedback` instead.\n */\nexport function captureUserFeedback(feedback: UserFeedback): void {\n  const client = getClient<BrowserClient>();\n  if (client) {\n    // eslint-disable-next-line deprecation/deprecation\n    client.captureUserFeedback(feedback);\n  }\n}\n","import {\n  SENTRY_XHR_DATA_KEY,\n  addPerformanceInstrumentationHandler,\n  addXhrInstrumentationHandler,\n} from '@sentry-internal/browser-utils';\nimport type { Client, HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/core';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SentryNonRecordingSpan,\n  addFetchEndInstrumentationHandler,\n  addFetchInstrumentationHandler,\n  browserPerformanceTimeOrigin,\n  getActiveSpan,\n  getTraceData,\n  hasTracingEnabled,\n  instrumentFetchRequest,\n  parseUrl,\n  setHttpStatus,\n  spanToJSON,\n  startInactiveSpan,\n  stringMatchesSomePattern,\n} from '@sentry/core';\nimport { WINDOW } from '../helpers';\n\n/** Options for Request Instrumentation */\nexport interface RequestInstrumentationOptions {\n  /**\n   * List of strings and/or Regular Expressions used to determine which outgoing requests will have `sentry-trace` and `baggage`\n   * headers attached.\n   *\n   * **Default:** If this option is not provided, tracing headers will be attached to all outgoing requests.\n   * If you are using a browser SDK, by default, tracing headers will only be attached to outgoing requests to the same origin.\n   *\n   * **Disclaimer:** Carelessly setting this option in browser environments may result into CORS errors!\n   * Only attach tracing headers to requests to the same origin, or to requests to services you can control CORS headers of.\n   * Cross-origin requests, meaning requests to a different domain, for example a request to `https://api.example.com/` while you're on `https://example.com/`, take special care.\n   * If you are attaching headers to cross-origin requests, make sure the backend handling the request returns a `\"Access-Control-Allow-Headers: sentry-trace, baggage\"` header to ensure your requests aren't blocked.\n   *\n   * If you provide a `tracePropagationTargets` array, the entries you provide will be matched against the entire URL of the outgoing request.\n   * If you are using a browser SDK, the entries will also be matched against the pathname of the outgoing requests.\n   * This is so you can have matchers for relative requests, for example, `/^\\/api/` if you want to trace requests to your `/api` routes on the same domain.\n   *\n   * If any of the two match any of the provided values, tracing headers will be attached to the outgoing request.\n   * Both, the string values, and the RegExes you provide in the array will match if they partially match the URL or pathname.\n   *\n   * Examples:\n   * - `tracePropagationTargets: [/^\\/api/]` and request to `https://same-origin.com/api/posts`:\n   *   - Tracing headers will be attached because the request is sent to the same origin and the regex matches the pathname \"/api/posts\".\n   * - `tracePropagationTargets: [/^\\/api/]` and request to `https://different-origin.com/api/posts`:\n   *   - Tracing headers will not be attached because the pathname will only be compared when the request target lives on the same origin.\n   * - `tracePropagationTargets: [/^\\/api/, 'https://external-api.com']` and request to `https://external-api.com/v1/data`:\n   *   - Tracing headers will be attached because the request URL matches the string `'https://external-api.com'`.\n   */\n  tracePropagationTargets?: Array<string | RegExp>;\n\n  /**\n   * Flag to disable patching all together for fetch requests.\n   *\n   * Default: true\n   */\n  traceFetch: boolean;\n\n  /**\n   * Flag to disable patching all together for xhr requests.\n   *\n   * Default: true\n   */\n  traceXHR: boolean;\n\n  /**\n   * Flag to disable tracking of long-lived streams, like server-sent events (SSE) via fetch.\n   * Do not enable this in case you have live streams or very long running streams.\n   *\n   * Disabled by default since it can lead to issues with streams using the `cancel()` api\n   * (https://github.com/getsentry/sentry-javascript/issues/13950)\n   *\n   * Default: false\n   */\n  trackFetchStreamPerformance: boolean;\n\n  /**\n   * If true, Sentry will capture http timings and add them to the corresponding http spans.\n   *\n   * Default: true\n   */\n  enableHTTPTimings: boolean;\n\n  /**\n   * This function will be called before creating a span for a request with the given url.\n   * Return false if you don't want a span for the given url.\n   *\n   * Default: (url: string) => true\n   */\n  shouldCreateSpanForRequest?(this: void, url: string): boolean;\n}\n\nconst responseToSpanId = new WeakMap<object, string>();\nconst spanIdToEndTimestamp = new Map<string, number>();\n\nexport const defaultRequestInstrumentationOptions: RequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  enableHTTPTimings: true,\n  trackFetchStreamPerformance: false,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nexport function instrumentOutgoingRequests(client: Client, _options?: Partial<RequestInstrumentationOptions>): void {\n  const {\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    tracePropagationTargets,\n  } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    trackFetchStreamPerformance: defaultRequestInstrumentationOptions.trackFetchStreamPerformance,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_: string) => true;\n\n  const shouldAttachHeadersWithTargets = (url: string): boolean => shouldAttachHeaders(url, tracePropagationTargets);\n\n  const spans: Record<string, Span> = {};\n\n  if (traceFetch) {\n    // Keeping track of http requests, whose body payloads resolved later than the initial resolved request\n    // e.g. streaming using server sent events (SSE)\n    client.addEventProcessor(event => {\n      if (event.type === 'transaction' && event.spans) {\n        event.spans.forEach(span => {\n          if (span.op === 'http.client') {\n            const updatedTimestamp = spanIdToEndTimestamp.get(span.span_id);\n            if (updatedTimestamp) {\n              span.timestamp = updatedTimestamp / 1000;\n              spanIdToEndTimestamp.delete(span.span_id);\n            }\n          }\n        });\n      }\n      return event;\n    });\n\n    if (trackFetchStreamPerformance) {\n      addFetchEndInstrumentationHandler(handlerData => {\n        if (handlerData.response) {\n          const span = responseToSpanId.get(handlerData.response);\n          if (span && handlerData.endTimestamp) {\n            spanIdToEndTimestamp.set(span, handlerData.endTimestamp);\n          }\n        }\n      });\n    }\n\n    addFetchInstrumentationHandler(handlerData => {\n      const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n\n      if (handlerData.response && handlerData.fetchData.__span) {\n        responseToSpanId.set(handlerData.response, handlerData.fetchData.__span);\n      }\n\n      // We cannot use `window.location` in the generic fetch instrumentation,\n      // but we need it for reliable `server.address` attribute.\n      // so we extend this in here\n      if (createdSpan) {\n        const fullUrl = getFullURL(handlerData.fetchData.url);\n        const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n        createdSpan.setAttributes({\n          'http.url': fullUrl,\n          'server.address': host,\n        });\n      }\n\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n\n  if (traceXHR) {\n    addXhrInstrumentationHandler(handlerData => {\n      const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n}\n\nfunction isPerformanceResourceTiming(entry: PerformanceEntry): entry is PerformanceResourceTiming {\n  return (\n    entry.entryType === 'resource' &&\n    'initiatorType' in entry &&\n    typeof (entry as PerformanceResourceTiming).nextHopProtocol === 'string' &&\n    (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')\n  );\n}\n\n/**\n * Creates a temporary observer to listen to the next fetch/xhr resourcing timings,\n * so that when timings hit their per-browser limit they don't need to be removed.\n *\n * @param span A span that has yet to be finished, must contain `url` on data.\n */\nfunction addHTTPTimings(span: Span): void {\n  const { url } = spanToJSON(span).data || {};\n\n  if (!url || typeof url !== 'string') {\n    return;\n  }\n\n  const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => {\n    entries.forEach(entry => {\n      if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) {\n        const spanData = resourceTimingEntryToSpanData(entry);\n        spanData.forEach(data => span.setAttribute(...data));\n        // In the next tick, clean this handler up\n        // We have to wait here because otherwise this cleans itself up before it is fully done\n        setTimeout(cleanup);\n      }\n    });\n  });\n}\n\n/**\n * Converts ALPN protocol ids to name and version.\n *\n * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)\n * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol\n */\nexport function extractNetworkProtocol(nextHopProtocol: string): { name: string; version: string } {\n  let name = 'unknown';\n  let version = 'unknown';\n  let _name = '';\n  for (const char of nextHopProtocol) {\n    // http/1.1 etc.\n    if (char === '/') {\n      [name, version] = nextHopProtocol.split('/') as [string, string];\n      break;\n    }\n    // h2, h3 etc.\n    if (!isNaN(Number(char))) {\n      name = _name === 'h' ? 'http' : _name;\n      version = nextHopProtocol.split(_name)[1] as string;\n      break;\n    }\n    _name += char;\n  }\n  if (_name === nextHopProtocol) {\n    // webrtc, ftp, etc.\n    name = _name;\n  }\n  return { name, version };\n}\n\nfunction getAbsoluteTime(time: number = 0): number {\n  return ((browserPerformanceTimeOrigin || performance.timeOrigin) + time) / 1000;\n}\n\nfunction resourceTimingEntryToSpanData(resourceTiming: PerformanceResourceTiming): [string, string | number][] {\n  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);\n\n  const timingSpanData: [string, string | number][] = [];\n\n  timingSpanData.push(['network.protocol.version', version], ['network.protocol.name', name]);\n\n  if (!browserPerformanceTimeOrigin) {\n    return timingSpanData;\n  }\n  return [\n    ...timingSpanData,\n    ['http.request.redirect_start', getAbsoluteTime(resourceTiming.redirectStart)],\n    ['http.request.fetch_start', getAbsoluteTime(resourceTiming.fetchStart)],\n    ['http.request.domain_lookup_start', getAbsoluteTime(resourceTiming.domainLookupStart)],\n    ['http.request.domain_lookup_end', getAbsoluteTime(resourceTiming.domainLookupEnd)],\n    ['http.request.connect_start', getAbsoluteTime(resourceTiming.connectStart)],\n    ['http.request.secure_connection_start', getAbsoluteTime(resourceTiming.secureConnectionStart)],\n    ['http.request.connection_end', getAbsoluteTime(resourceTiming.connectEnd)],\n    ['http.request.request_start', getAbsoluteTime(resourceTiming.requestStart)],\n    ['http.request.response_start', getAbsoluteTime(resourceTiming.responseStart)],\n    ['http.request.response_end', getAbsoluteTime(resourceTiming.responseEnd)],\n  ];\n}\n\n/**\n * A function that determines whether to attach tracing headers to a request.\n * We only export this function for testing purposes.\n */\nexport function shouldAttachHeaders(\n  targetUrl: string,\n  tracePropagationTargets: (string | RegExp)[] | undefined,\n): boolean {\n  // window.location.href not being defined is an edge case in the browser but we need to handle it.\n  // Potentially dangerous situations where it may not be defined: Browser Extensions, Web Workers, patching of the location obj\n  const href: string | undefined = WINDOW.location && WINDOW.location.href;\n\n  if (!href) {\n    // If there is no window.location.origin, we default to only attaching tracing headers to relative requests, i.e. ones that start with `/`\n    // BIG DISCLAIMER: Users can call URLs with a double slash (fetch(\"//example.com/api\")), this is a shorthand for \"send to the same protocol\",\n    // so we need a to exclude those requests, because they might be cross origin.\n    const isRelativeSameOriginRequest = !!targetUrl.match(/^\\/(?!\\/)/);\n    if (!tracePropagationTargets) {\n      return isRelativeSameOriginRequest;\n    } else {\n      return stringMatchesSomePattern(targetUrl, tracePropagationTargets);\n    }\n  } else {\n    let resolvedUrl;\n    let currentOrigin;\n\n    // URL parsing may fail, we default to not attaching trace headers in that case.\n    try {\n      resolvedUrl = new URL(targetUrl, href);\n      currentOrigin = new URL(href).origin;\n    } catch (e) {\n      return false;\n    }\n\n    const isSameOriginRequest = resolvedUrl.origin === currentOrigin;\n    if (!tracePropagationTargets) {\n      return isSameOriginRequest;\n    } else {\n      return (\n        stringMatchesSomePattern(resolvedUrl.toString(), tracePropagationTargets) ||\n        (isSameOriginRequest && stringMatchesSomePattern(resolvedUrl.pathname, tracePropagationTargets))\n      );\n    }\n  }\n}\n\n/**\n * Create and track xhr request spans\n *\n * @returns Span if a span was created, otherwise void.\n */\nexport function xhrCallback(\n  handlerData: HandlerDataXhr,\n  shouldCreateSpan: (url: string) => boolean,\n  shouldAttachHeaders: (url: string) => boolean,\n  spans: Record<string, Span>,\n): Span | undefined {\n  const xhr = handlerData.xhr;\n  const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(sentryXhrData.url);\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span && sentryXhrData.status_code !== undefined) {\n      setHttpStatus(span, sentryXhrData.status_code);\n      span.end();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const fullUrl = getFullURL(sentryXhrData.url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${sentryXhrData.method} ${sentryXhrData.url}`,\n          attributes: {\n            type: 'xhr',\n            'http.method': sentryXhrData.method,\n            'http.url': fullUrl,\n            url: sentryXhrData.url,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;\n  spans[xhr.__sentry_xhr_span_id__] = span;\n\n  if (shouldAttachHeaders(sentryXhrData.url)) {\n    addTracingHeadersToXhrRequest(\n      xhr,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasTracingEnabled() && hasParent ? span : undefined,\n    );\n  }\n\n  return span;\n}\n\nfunction addTracingHeadersToXhrRequest(xhr: SentryWrappedXMLHttpRequest, span?: Span): void {\n  const { 'sentry-trace': sentryTrace, baggage } = getTraceData({ span });\n\n  if (sentryTrace) {\n    setHeaderOnXhr(xhr, sentryTrace, baggage);\n  }\n}\n\nfunction setHeaderOnXhr(\n  xhr: SentryWrappedXMLHttpRequest,\n  sentryTraceHeader: string,\n  sentryBaggageHeader: string | undefined,\n): void {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    xhr.setRequestHeader!('sentry-trace', sentryTraceHeader);\n    if (sentryBaggageHeader) {\n      // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n      // We can therefore simply set a baggage header without checking what was there before\n      // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      xhr.setRequestHeader!('baggage', sentryBaggageHeader);\n    }\n  } catch (_) {\n    // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n  }\n}\n\nfunction getFullURL(url: string): string | undefined {\n  try {\n    // By adding a base URL to new URL(), this will also work for relative urls\n    // If `url` is a full URL, the base URL is ignored anyhow\n    const parsed = new URL(url, WINDOW.location.origin);\n    return parsed.href;\n  } catch {\n    return undefined;\n  }\n}\n","/* eslint-disable max-lines */\nimport {\n  addHistoryInstrumentationHandler,\n  addPerformanceEntries,\n  registerInpInteractionListener,\n  startTrackingINP,\n  startTrackingInteractions,\n  startTrackingLongAnimationFrames,\n  startTrackingLongTasks,\n  startTrackingWebVitals,\n} from '@sentry-internal/browser-utils';\nimport type { Client, IntegrationFn, Span, StartSpanOptions, TransactionSource } from '@sentry/core';\nimport {\n  GLOBAL_OBJ,\n  SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  TRACING_DEFAULTS,\n  browserPerformanceTimeOrigin,\n  generateTraceId,\n  getActiveSpan,\n  getClient,\n  getCurrentScope,\n  getDomElement,\n  getDynamicSamplingContextFromSpan,\n  getIsolationScope,\n  getRootSpan,\n  logger,\n  propagationContextFromHeaders,\n  registerSpanErrorInstrumentation,\n  spanIsSampled,\n  spanToJSON,\n  startIdleSpan,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request';\n\nexport const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\ninterface RouteInfo {\n  name: string | undefined;\n  source: TransactionSource | undefined;\n}\n\n/** Options for Browser Tracing integration */\nexport interface BrowserTracingOptions {\n  /**\n   * The time that has to pass without any span being created.\n   * If this time is exceeded, the idle span will finish.\n   *\n   * Default: 1000 (ms)\n   */\n  idleTimeout: number;\n\n  /**\n   * The max. time an idle span may run.\n   * If this time is exceeded, the idle span will finish no matter what.\n   *\n   * Default: 30000 (ms)\n   */\n  finalTimeout: number;\n\n  /**\n   The max. time an idle span may run.\n   * If this time is exceeded, the idle span will finish no matter what.\n   *\n   * Default: 15000 (ms)\n   */\n  childSpanTimeout: number;\n\n  /**\n   * If a span should be created on page load.\n   * If this is set to `false`, this integration will not start the default page load span.\n   * Default: true\n   */\n  instrumentPageLoad: boolean;\n\n  /**\n   * If a span should be created on navigation (history change).\n   * If this is set to `false`, this integration will not start the default navigation spans.\n   * Default: true\n   */\n  instrumentNavigation: boolean;\n\n  /**\n   * Flag spans where tabs moved to background with \"cancelled\". Browser background tab timing is\n   * not suited towards doing precise measurements of operations. By default, we recommend that this option\n   * be enabled as background transactions can mess up your statistics in nondeterministic ways.\n   *\n   * Default: true\n   */\n  markBackgroundSpan: boolean;\n\n  /**\n   * If true, Sentry will capture long tasks and add them to the corresponding transaction.\n   *\n   * Default: true\n   */\n  enableLongTask: boolean;\n\n  /**\n   * If true, Sentry will capture long animation frames and add them to the corresponding transaction.\n   *\n   * Default: false\n   */\n  enableLongAnimationFrame: boolean;\n\n  /**\n   * If true, Sentry will capture first input delay and add it to the corresponding transaction.\n   *\n   * Default: true\n   */\n  enableInp: boolean;\n\n  /**\n   * Flag to disable patching all together for fetch requests.\n   *\n   * Default: true\n   */\n  traceFetch: boolean;\n\n  /**\n   * Flag to disable patching all together for xhr requests.\n   *\n   * Default: true\n   */\n  traceXHR: boolean;\n\n  /**\n   * Flag to disable tracking of long-lived streams, like server-sent events (SSE) via fetch.\n   * Do not enable this in case you have live streams or very long running streams.\n   *\n   * Default: false\n   */\n  trackFetchStreamPerformance: boolean;\n\n  /**\n   * If true, Sentry will capture http timings and add them to the corresponding http spans.\n   *\n   * Default: true\n   */\n  enableHTTPTimings: boolean;\n\n  /**\n   * _experiments allows the user to send options to define how this integration works.\n   *\n   * Default: undefined\n   */\n  _experiments: Partial<{\n    enableInteractions: boolean;\n    enableStandaloneClsSpans: boolean;\n  }>;\n\n  /**\n   * A callback which is called before a span for a pageload or navigation is started.\n   * It receives the options passed to `startSpan`, and expects to return an updated options object.\n   */\n  beforeStartSpan?: (options: StartSpanOptions) => StartSpanOptions;\n\n  /**\n   * This function will be called before creating a span for a request with the given url.\n   * Return false if you don't want a span for the given url.\n   *\n   * Default: (url: string) => true\n   */\n  shouldCreateSpanForRequest?(this: void, url: string): boolean;\n}\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableLongAnimationFrame: true,\n  enableInp: true,\n  _experiments: {},\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nexport const browserTracingIntegration = ((_options: Partial<BrowserTracingOptions> = {}) => {\n  registerSpanErrorInstrumentation();\n\n  const {\n    enableInp,\n    enableLongTask,\n    enableLongAnimationFrame,\n    _experiments: { enableInteractions, enableStandaloneClsSpans },\n    beforeStartSpan,\n    idleTimeout,\n    finalTimeout,\n    childSpanTimeout,\n    markBackgroundSpan,\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    instrumentPageLoad,\n    instrumentNavigation,\n  } = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ..._options,\n  };\n\n  const _collectWebVitals = startTrackingWebVitals({ recordClsStandaloneSpans: enableStandaloneClsSpans || false });\n\n  if (enableInp) {\n    startTrackingINP();\n  }\n\n  if (\n    enableLongAnimationFrame &&\n    GLOBAL_OBJ.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes &&\n    PerformanceObserver.supportedEntryTypes.includes('long-animation-frame')\n  ) {\n    startTrackingLongAnimationFrames();\n  } else if (enableLongTask) {\n    startTrackingLongTasks();\n  }\n\n  if (enableInteractions) {\n    startTrackingInteractions();\n  }\n\n  const latestRoute: RouteInfo = {\n    name: undefined,\n    source: undefined,\n  };\n\n  /** Create routing idle transaction. */\n  function _createRouteSpan(client: Client, startSpanOptions: StartSpanOptions): Span {\n    const isPageloadTransaction = startSpanOptions.op === 'pageload';\n\n    const finalStartSpanOptions: StartSpanOptions = beforeStartSpan\n      ? beforeStartSpan(startSpanOptions)\n      : startSpanOptions;\n\n    const attributes = finalStartSpanOptions.attributes || {};\n\n    // If `finalStartSpanOptions.name` is different than `startSpanOptions.name`\n    // it is because `beforeStartSpan` set a custom name. Therefore we set the source to 'custom'.\n    if (startSpanOptions.name !== finalStartSpanOptions.name) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'custom';\n      finalStartSpanOptions.attributes = attributes;\n    }\n\n    latestRoute.name = finalStartSpanOptions.name;\n    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const idleSpan = startIdleSpan(finalStartSpanOptions, {\n      idleTimeout,\n      finalTimeout,\n      childSpanTimeout,\n      // should wait for finish signal if it's a pageload transaction\n      disableAutoFinish: isPageloadTransaction,\n      beforeSpanEnd: span => {\n        _collectWebVitals();\n        addPerformanceEntries(span, { recordClsOnPageloadSpan: !enableStandaloneClsSpans });\n      },\n    });\n\n    function emitFinish(): void {\n      if (['interactive', 'complete'].includes(WINDOW.document.readyState)) {\n        client.emit('idleSpanEnableAutoFinish', idleSpan);\n      }\n    }\n\n    if (isPageloadTransaction && WINDOW.document) {\n      WINDOW.document.addEventListener('readystatechange', () => {\n        emitFinish();\n      });\n\n      emitFinish();\n    }\n\n    return idleSpan;\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    afterAllSetup(client) {\n      let activeSpan: Span | undefined;\n      let startingUrl: string | undefined = WINDOW.location && WINDOW.location.href;\n\n      function maybeEndActiveSpan(): void {\n        if (activeSpan && !spanToJSON(activeSpan).timestamp) {\n          DEBUG_BUILD && logger.log(`[Tracing] Finishing current active span with op: ${spanToJSON(activeSpan).op}`);\n          // If there's an open active span, we need to finish it before creating an new one.\n          activeSpan.end();\n        }\n      }\n\n      client.on('startNavigationSpan', startSpanOptions => {\n        if (getClient() !== client) {\n          return;\n        }\n\n        maybeEndActiveSpan();\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'navigation',\n          ...startSpanOptions,\n        });\n      });\n\n      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {\n        if (getClient() !== client) {\n          return;\n        }\n        maybeEndActiveSpan();\n\n        const sentryTrace = traceOptions.sentryTrace || getMetaContent('sentry-trace');\n        const baggage = traceOptions.baggage || getMetaContent('baggage');\n\n        const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n        getCurrentScope().setPropagationContext(propagationContext);\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'pageload',\n          ...startSpanOptions,\n        });\n      });\n\n      // A trace should to stay the consistent over the entire time span of one route.\n      // Therefore, when the initial pageload or navigation root span ends, we update the\n      // scope's propagation context to keep span-specific attributes like the `sampled` decision and\n      // the dynamic sampling context valid, even after the root span has ended.\n      // This ensures that the trace data is consistent for the entire duration of the route.\n      client.on('spanEnd', span => {\n        const op = spanToJSON(span).op;\n        if (span !== getRootSpan(span) || (op !== 'navigation' && op !== 'pageload')) {\n          return;\n        }\n\n        const scope = getCurrentScope();\n        const oldPropagationContext = scope.getPropagationContext();\n\n        scope.setPropagationContext({\n          ...oldPropagationContext,\n          sampled: oldPropagationContext.sampled !== undefined ? oldPropagationContext.sampled : spanIsSampled(span),\n          dsc: oldPropagationContext.dsc || getDynamicSamplingContextFromSpan(span),\n        });\n      });\n\n      if (WINDOW.location) {\n        if (instrumentPageLoad) {\n          startBrowserTracingPageLoadSpan(client, {\n            name: WINDOW.location.pathname,\n            // pageload should always start at timeOrigin (and needs to be in s, not ms)\n            startTime: browserPerformanceTimeOrigin ? browserPerformanceTimeOrigin / 1000 : undefined,\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.browser',\n            },\n          });\n        }\n\n        if (instrumentNavigation) {\n          addHistoryInstrumentationHandler(({ to, from }) => {\n            /**\n             * This early return is there to account for some cases where a navigation transaction starts right after\n             * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n             * create an uneccessary navigation transaction.\n             *\n             * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n             * only be caused in certain development environments where the usage of a hot module reloader is causing\n             * errors.\n             */\n            if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n              startingUrl = undefined;\n              return;\n            }\n\n            if (from !== to) {\n              startingUrl = undefined;\n              startBrowserTracingNavigationSpan(client, {\n                name: WINDOW.location.pathname,\n                attributes: {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.browser',\n                },\n              });\n            }\n          });\n        }\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (enableInteractions) {\n        registerInteractionListener(idleTimeout, finalTimeout, childSpanTimeout, latestRoute);\n      }\n\n      if (enableInp) {\n        registerInpInteractionListener();\n      }\n\n      instrumentOutgoingRequests(client, {\n        traceFetch,\n        traceXHR,\n        trackFetchStreamPerformance,\n        tracePropagationTargets: client.getOptions().tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Manually start a page load span.\n * This will only do something if a browser tracing integration integration has been setup.\n *\n * If you provide a custom `traceOptions` object, it will be used to continue the trace\n * instead of the default behavior, which is to look it up on the <meta> tags.\n */\nexport function startBrowserTracingPageLoadSpan(\n  client: Client,\n  spanOptions: StartSpanOptions,\n  traceOptions?: { sentryTrace?: string | undefined; baggage?: string | undefined },\n): Span | undefined {\n  client.emit('startPageLoadSpan', spanOptions, traceOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'pageload' ? span : undefined;\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if a browser tracing integration has been setup.\n */\nexport function startBrowserTracingNavigationSpan(client: Client, spanOptions: StartSpanOptions): Span | undefined {\n  getIsolationScope().setPropagationContext({ traceId: generateTraceId() });\n  getCurrentScope().setPropagationContext({ traceId: generateTraceId() });\n\n  client.emit('startNavigationSpan', spanOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'navigation' ? span : undefined;\n}\n\n/** Returns the value of a meta tag */\nexport function getMetaContent(metaName: string): string | undefined {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : undefined;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  idleTimeout: BrowserTracingOptions['idleTimeout'],\n  finalTimeout: BrowserTracingOptions['finalTimeout'],\n  childSpanTimeout: BrowserTracingOptions['childSpanTimeout'],\n  latestRoute: RouteInfo,\n): void {\n  let inflightInteractionSpan: Span | undefined;\n  const registerInteractionTransaction = (): void => {\n    const op = 'ui.action.click';\n\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan && getRootSpan(activeSpan);\n    if (rootSpan) {\n      const currentRootSpanOp = spanToJSON(rootSpan).op;\n      if (['navigation', 'pageload'].includes(currentRootSpanOp as string)) {\n        DEBUG_BUILD &&\n          logger.warn(`[Tracing] Did not create ${op} span because a pageload or navigation span is in progress.`);\n        return undefined;\n      }\n    }\n\n    if (inflightInteractionSpan) {\n      inflightInteractionSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'interactionInterrupted');\n      inflightInteractionSpan.end();\n      inflightInteractionSpan = undefined;\n    }\n\n    if (!latestRoute.name) {\n      DEBUG_BUILD && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);\n      return undefined;\n    }\n\n    inflightInteractionSpan = startIdleSpan(\n      {\n        name: latestRoute.name,\n        op,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',\n        },\n      },\n      {\n        idleTimeout,\n        finalTimeout,\n        childSpanTimeout,\n      },\n    );\n  };\n\n  if (WINDOW.document) {\n    addEventListener('click', registerInteractionTransaction, { once: false, capture: true });\n  }\n}\n","import { SPAN_STATUS_ERROR, getActiveSpan, getRootSpan, logger, spanToJSON } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nexport function registerBackgroundTabDetection(): void {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeSpan = getActiveSpan();\n      if (!activeSpan) {\n        return;\n      }\n\n      const rootSpan = getRootSpan(activeSpan);\n\n      if (WINDOW.document.hidden && rootSpan) {\n        const cancelledStatus = 'cancelled';\n\n        const { op, status } = spanToJSON(rootSpan);\n\n        if (DEBUG_BUILD) {\n          logger.log(`[Tracing] Transaction: ${cancelledStatus} -> since tab moved to the background, op: ${op}`);\n        }\n\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!status) {\n          rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: cancelledStatus });\n        }\n\n        rootSpan.setAttribute('sentry.cancellation_reason', 'document.hidden');\n        rootSpan.end();\n      }\n    });\n  } else {\n    DEBUG_BUILD && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n"],"names":["DEBUG_BUILD","WINDOW","ignoreOnError","shouldIgnoreOnError","wrap","fn","options","isFunction","wrapper","__sentry_wrapped__","e","sentryWrapped","args","wrappedArguments","map","arg","apply","this","ex","setTimeout","scope","addEventProcessor","event","mechanism","undefined","extra","arguments","property","Object","prototype","hasOwnProperty","call","getOwnPropertyDescriptor","configurable","defineProperty","get","name","exceptionFromError","stackParser","frames","parseStackFrames","exception","type","extractType","value","extractMessage","length","stacktrace","eventFromPlainObject","syntheticException","isUnhandledRejection","client","normalizeDepth","getOptions","errorFromProp","getErrorPropertyFromObject","__serialized__","normalize","values","is","constructor","getNonErrorObjectExceptionValue","eventFromError","stack","skipLines","reactMinifiedRegexp","test","message","getSkipFirstStackStringLines","framesToPop","getPopFirstTopFrames","isWebAssemblyException","WebAssembly","Exception","Array","isArray","error","eventFromUnknownInput","attachStacktrace","domException","createUserFeedbackEnvelope","feedback","metadata","tunnel","dsn","headers","event_id","sent_at","Date","toISOString","sdk","version","item","createUserFeedbackEnvelopeItem","BrowserClient","opts","parentSpanIsAlwaysRootSpan","sdkSource","super","sendClientReports","_flushOutcomes","eventFromException","hint","level","_options","eventFromMessage","eventFromString","captureUserFeedback","_isEnabled","logger","envelope","getSdkMetadata","getDsn","sendEnvelope","_prepareEvent","platform","MAX_ALLOWED_STRING_LENGTH","breadcrumbsIntegration","console","dom","fetch","history","sentry","xhr","setup","_getConsoleBreadcrumbHandler","_getDomBreadcrumbHandler","_getXhrBreadcrumbHandler","_getFetchBreadcrumbHandler","a","_getHistoryBreadcrumbHandler","on","category","_getSentryBreadcrumbHandler","DEFAULT_EVENT_TARGET","browserApiErrorsIntegration","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","setupOnce","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","forEach","_wrapEventTarget","original","data","function","handled","callback","handler","originalSend","prop","wrapOptions","originalFunction","target","targetObj","proto","eventName","handleEvent","originalRemoveEventListener","originalEventHandler","globalHandlersIntegration","onerror","onunhandledrejection","Error","stackTraceLimit","msg","url","line","column","_enhanceEventWithInitialFrame","originalException","_installGlobalOnErrorHandler","globalHandlerLog","reason","detail","_getUnhandledRejectionError","String","_installGlobalOnUnhandledRejectionHandler","httpContextIntegration","preprocessEvent","request","referrer","userAgent","Referer","linkedErrorsIntegration","limit","key","maxValueLength","createFrame","filename","func","lineno","colno","frame","in_app","chromeRegexNoFnName","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","defaultStackParser","noFnParts","exec","col","parts","indexOf","subMatch","extractSafariExtensionDetails","isSafariExtension","isSafariWebExtension","split","makeFetchTransport","nativeFetch","getNativeImplementation","pendingBodySize","pendingCount","requestSize","body","requestOptions","method","referrerPolicy","keepalive","fetchOptions","then","response","statusCode","status","optionsArg","defaultOptions","defaultIntegrations","dedupe","release","__SENTRY_RELEASE__","autoSessionTracking","windowWithMaybeExtension","extensionObject","chrome","runtimeId","runtime","id","href","isDedicatedExtensionPage","some","protocol","startsWith","responseToSpanId","WeakMap","spanIdToEndTimestamp","Map","defaultRequestInstrumentationOptions","traceFetch","traceXHR","enableHTTPTimings","trackFetchStreamPerformance","instrumentOutgoingRequests","shouldCreateSpanForRequest","tracePropagationTargets","shouldCreateSpan","_","shouldAttachHeadersWithTargets","targetUrl","resolvedUrl","currentOrigin","URL","origin","isSameOriginRequest","string","toString","pathname","isRelativeSameOriginRequest","match","shouldAttachHeaders","spans","span","op","updatedTimestamp","span_id","timestamp","delete","handlerData","endTimestamp","set","createdSpan","fetchData","__span","fullUrl","getFullURL","host","setAttributes","addHTTPTimings","sentryXhrData","__sentry_own_request__","shouldCreateSpanResult","hasTracingEnabled","spanId","__sentry_xhr_span_id__","status_code","end","hasParent","xhrCallback","cleanup","entries","entry","entryType","nextHopProtocol","initiatorType","isPerformanceResourceTiming","endsWith","resourceTiming","_name","char","isNaN","Number","extractNetworkProtocol","timingSpanData","push","getAbsoluteTime","redirectStart","fetchStart","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","responseEnd","resourceTimingEntryToSpanData","setAttribute","time","performance","timeOrigin","DEFAULT_BROWSER_TRACING_OPTIONS","instrumentNavigation","instrumentPageLoad","markBackgroundSpan","enableLongTask","enableLongAnimationFrame","enableInp","_experiments","browserTracingIntegration","enableInteractions","enableStandaloneClsSpans","beforeStartSpan","idleTimeout","finalTimeout","childSpanTimeout","_collectWebVitals","recordClsStandaloneSpans","PerformanceObserver","supportedEntryTypes","includes","latestRoute","source","_createRouteSpan","startSpanOptions","isPageloadTransaction","finalStartSpanOptions","attributes","idleSpan","disableAutoFinish","beforeSpanEnd","recordClsOnPageloadSpan","emitFinish","emit","afterAllSetup","activeSpan","startingUrl","maybeEndActiveSpan","log","rootSpan","cancelledStatus"],"sourceRoot":""}