{"version":3,"sources":["jsdelivr-header.js","/npm/@sentry/browser@8.55.2/src/helpers.ts","/npm/@sentry/browser@8.55.2/src/debug-build.ts","/npm/@sentry/browser@8.55.2/src/eventbuilder.ts","/npm/@sentry/browser@8.55.2/src/userfeedback.ts","/npm/@sentry/browser@8.55.2/src/client.ts","/npm/@sentry/browser@8.55.2/src/transports/fetch.ts","/npm/@sentry/browser@8.55.2/src/stack-parsers.ts","/npm/@sentry/browser@8.55.2/src/integrations/breadcrumbs.ts","/npm/@sentry/browser@8.55.2/src/integrations/browserapierrors.ts","/npm/@sentry/browser@8.55.2/src/integrations/browsersession.ts","/npm/@sentry/browser@8.55.2/src/integrations/globalhandlers.ts","/npm/@sentry/browser@8.55.2/src/integrations/httpcontext.ts","/npm/@sentry/browser@8.55.2/src/integrations/linkederrors.ts","/npm/@sentry/browser@8.55.2/src/sdk.ts","/npm/@sentry/browser@8.55.2/src/utils/lazyLoadIntegration.ts","/npm/@sentry/browser@8.55.2/src/integrations/reportingobserver.ts","/npm/@sentry/browser@8.55.2/src/integrations/httpclient.ts","/npm/@sentry/browser@8.55.2/src/integrations/contextlines.ts","/npm/@sentry/browser@8.55.2/src/feedbackAsync.ts","/npm/@sentry/browser@8.55.2/src/feedbackSync.ts","/npm/@sentry/browser@8.55.2/src/metrics.ts","/npm/@sentry/browser@8.55.2/src/tracing/request.ts","/npm/@sentry/browser@8.55.2/src/tracing/browserTracingIntegration.ts","/npm/@sentry/browser@8.55.2/src/tracing/backgroundtab.ts","/npm/@sentry/browser@8.55.2/src/transports/offline.ts","/npm/@sentry/browser@8.55.2/src/profiling/utils.ts","/npm/@sentry/browser@8.55.2/src/profiling/startProfileForSpan.ts","/npm/@sentry/browser@8.55.2/src/profiling/integration.ts","/npm/@sentry/browser@8.55.2/src/integrations/spotlight.ts","/npm/@sentry/browser@8.55.2/src/utils/featureFlags.ts","/npm/@sentry/browser@8.55.2/src/integrations/featureFlags/featureFlagsIntegration.ts","/npm/@sentry/browser@8.55.2/src/integrations/featureFlags/launchdarkly/integration.ts","/npm/@sentry/browser@8.55.2/src/integrations/featureFlags/openfeature/integration.ts","/npm/@sentry/browser@8.55.2/src/integrations/featureFlags/unleash/integration.ts","/npm/@sentry/browser@8.55.2/src/integrations/featureFlags/statsig/integration.ts"],"names":[],"mappings":"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","file":"/npm/@sentry/browser@8.55.2/build/npm/esm/index.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/@sentry/browser@8.55.2/build/npm/esm/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\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","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 {\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    addExceptionMechanism(event, { synthetic: true });\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","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","// 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","/* 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 { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport { captureSession, defineIntegration, logger, startSession } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\n/**\n * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.\n * More information: https://docs.sentry.io/product/releases/health/\n *\n * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/\n */\nexport const browserSessionIntegration = defineIntegration(() => {\n  return {\n    name: 'BrowserSession',\n    setupOnce() {\n      if (typeof WINDOW.document === 'undefined') {\n        DEBUG_BUILD &&\n          logger.warn('Using the `browserSessionIntegration` in non-browser environments 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","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\nfunction _enhanceEventWithInitialFrame(\n  event: Event,\n  url: string | undefined,\n  line: number | undefined,\n  column: number | undefined,\n): 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 = column;\n  const lineno = 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","import {\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  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 { browserSessionIntegration } from './integrations/browsersession';\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  const integrations = [\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    browserApiErrorsIntegration(),\n    breadcrumbsIntegration(),\n    globalHandlersIntegration(),\n    linkedErrorsIntegration(),\n    dedupeIntegration(),\n    httpContextIntegration(),\n  ];\n\n  // eslint-disable-next-line deprecation/deprecation\n  if (options.autoSessionTracking !== false) {\n    integrations.push(browserSessionIntegration());\n  }\n\n  return integrations;\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  return initAndBind(BrowserClient, clientOptions);\n}\n\n/**\n * All properties the report dialog supports\n */\nexport interface ReportDialogOptions {\n  // TODO(v9): Change this to  [key: string]: unknkown;\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 * 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 { SDK_VERSION, getClient } from '@sentry/core';\nimport type { IntegrationFn } from '@sentry/core';\nimport type { BrowserClient } from '../client';\nimport { WINDOW } from '../helpers';\n\n// This is a map of integration function method to bundle file name.\nconst LazyLoadableIntegrations = {\n  replayIntegration: 'replay',\n  replayCanvasIntegration: 'replay-canvas',\n  feedbackIntegration: 'feedback',\n  feedbackModalIntegration: 'feedback-modal',\n  feedbackScreenshotIntegration: 'feedback-screenshot',\n  captureConsoleIntegration: 'captureconsole',\n  contextLinesIntegration: 'contextlines',\n  linkedErrorsIntegration: 'linkederrors',\n  debugIntegration: 'debug',\n  dedupeIntegration: 'dedupe',\n  extraErrorDataIntegration: 'extraerrordata',\n  httpClientIntegration: 'httpclient',\n  reportingObserverIntegration: 'reportingobserver',\n  rewriteFramesIntegration: 'rewriteframes',\n  sessionTimingIntegration: 'sessiontiming',\n  browserProfilingIntegration: 'browserprofiling',\n  moduleMetadataIntegration: 'modulemetadata',\n} as const;\n\nconst WindowWithMaybeIntegration = WINDOW as {\n  Sentry?: Partial<Record<keyof typeof LazyLoadableIntegrations, IntegrationFn>>;\n};\n\n/**\n * Lazy load an integration from the CDN.\n * Rejects if the integration cannot be loaded.\n */\nexport async function lazyLoadIntegration(\n  name: keyof typeof LazyLoadableIntegrations,\n  scriptNonce?: string,\n): Promise<IntegrationFn> {\n  const bundle = LazyLoadableIntegrations[name];\n\n  // `window.Sentry` is only set when using a CDN bundle, but this method can also be used via the NPM package\n  const sentryOnWindow = (WindowWithMaybeIntegration.Sentry = WindowWithMaybeIntegration.Sentry || {});\n\n  if (!bundle) {\n    throw new Error(`Cannot lazy load integration: ${name}`);\n  }\n\n  // Bail if the integration already exists\n  const existing = sentryOnWindow[name];\n  // The `feedbackIntegration` is loaded by default in the CDN bundles,\n  // so we need to differentiate between the real integration and the shim.\n  // if only the shim exists, we still want to lazy load the real integration.\n  if (typeof existing === 'function' && !('_isShim' in existing)) {\n    return existing;\n  }\n\n  const url = getScriptURL(bundle);\n  const script = WINDOW.document.createElement('script');\n  script.src = url;\n  script.crossOrigin = 'anonymous';\n  script.referrerPolicy = 'origin';\n\n  if (scriptNonce) {\n    script.setAttribute('nonce', scriptNonce);\n  }\n\n  const waitForLoad = new Promise<void>((resolve, reject) => {\n    script.addEventListener('load', () => resolve());\n    script.addEventListener('error', reject);\n  });\n\n  const currentScript = WINDOW.document.currentScript;\n  const parent = WINDOW.document.body || WINDOW.document.head || (currentScript && currentScript.parentElement);\n\n  if (parent) {\n    parent.appendChild(script);\n  } else {\n    throw new Error(`Could not find parent element to insert lazy-loaded ${name} script`);\n  }\n\n  try {\n    await waitForLoad;\n  } catch {\n    throw new Error(`Error when loading integration: ${name}`);\n  }\n\n  const integrationFn = sentryOnWindow[name];\n\n  if (typeof integrationFn !== 'function') {\n    throw new Error(`Could not load integration: ${name}`);\n  }\n\n  return integrationFn;\n}\n\nfunction getScriptURL(bundle: string): string {\n  const client = getClient<BrowserClient>();\n  const options = client && client.getOptions();\n  const baseURL = (options && options.cdnBaseUrl) || 'https://browser.sentry-cdn.com';\n\n  return new URL(`/${SDK_VERSION}/${bundle}.min.js`, baseURL).toString();\n}\n","import type { Client, IntegrationFn } from '@sentry/core';\nimport {\n  GLOBAL_OBJ,\n  captureMessage,\n  defineIntegration,\n  getClient,\n  supportsReportingObserver,\n  withScope,\n} from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nconst INTEGRATION_NAME = 'ReportingObserver';\n\ninterface Report {\n  [key: string]: unknown;\n  type: ReportTypes;\n  url: string;\n  body?: ReportBody;\n}\n\ntype ReportTypes = 'crash' | 'deprecation' | 'intervention';\n\ntype ReportBody = CrashReportBody | DeprecationReportBody | InterventionReportBody;\n\ninterface CrashReportBody {\n  [key: string]: unknown;\n  crashId: string;\n  reason?: string;\n}\n\ninterface DeprecationReportBody {\n  [key: string]: unknown;\n  id: string;\n  anticipatedRemoval?: Date;\n  message: string;\n  sourceFile?: string;\n  lineNumber?: number;\n  columnNumber?: number;\n}\n\ninterface InterventionReportBody {\n  [key: string]: unknown;\n  id: string;\n  message: string;\n  sourceFile?: string;\n  lineNumber?: number;\n  columnNumber?: number;\n}\n\ninterface ReportingObserverOptions {\n  types?: ReportTypes[];\n}\n\n/** This is experimental and the types are not included with TypeScript, sadly. */\ninterface ReportingObserverClass {\n  new (\n    handler: (reports: Report[]) => void,\n    options: { buffered?: boolean; types?: ReportTypes[] },\n  ): {\n    observe: () => void;\n  };\n}\n\nconst SETUP_CLIENTS = new WeakMap<Client, boolean>();\n\nconst _reportingObserverIntegration = ((options: ReportingObserverOptions = {}) => {\n  const types = options.types || ['crash', 'deprecation', 'intervention'];\n\n  /** Handler for the reporting observer. */\n  function handler(reports: Report[]): void {\n    if (!SETUP_CLIENTS.has(getClient() as Client)) {\n      return;\n    }\n\n    for (const report of reports) {\n      withScope(scope => {\n        scope.setExtra('url', report.url);\n\n        const label = `ReportingObserver [${report.type}]`;\n        let details = 'No details available';\n\n        if (report.body) {\n          // Object.keys doesn't work on ReportBody, as all properties are inherited\n          const plainBody: {\n            [key: string]: unknown;\n          } = {};\n\n          // eslint-disable-next-line guard-for-in\n          for (const prop in report.body) {\n            plainBody[prop] = report.body[prop];\n          }\n\n          scope.setExtra('body', plainBody);\n\n          if (report.type === 'crash') {\n            const body = report.body as CrashReportBody;\n            // A fancy way to create a message out of crashId OR reason OR both OR fallback\n            details = [body.crashId || '', body.reason || ''].join(' ').trim() || details;\n          } else {\n            const body = report.body as DeprecationReportBody | InterventionReportBody;\n            details = body.message || details;\n          }\n        }\n\n        captureMessage(`${label}: ${details}`);\n      });\n    }\n  }\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!supportsReportingObserver()) {\n        return;\n      }\n\n      const observer = new (WINDOW as typeof WINDOW & { ReportingObserver: ReportingObserverClass }).ReportingObserver(\n        handler,\n        {\n          buffered: true,\n          types,\n        },\n      );\n\n      observer.observe();\n    },\n\n    setup(client): void {\n      SETUP_CLIENTS.set(client, true);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Reporting API integration - https://w3c.github.io/reporting/\n */\nexport const reportingObserverIntegration = defineIntegration(_reportingObserverIntegration);\n","import { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport type { Client, Event as SentryEvent, IntegrationFn, SentryWrappedXMLHttpRequest } from '@sentry/core';\nimport {\n  GLOBAL_OBJ,\n  addExceptionMechanism,\n  addFetchInstrumentationHandler,\n  captureEvent,\n  defineIntegration,\n  getClient,\n  isSentryRequestUrl,\n  logger,\n  supportsNativeFetch,\n} from '@sentry/core';\n\nimport { DEBUG_BUILD } from '../debug-build';\n\nexport type HttpStatusCodeRange = [number, number] | number;\nexport type HttpRequestTarget = string | RegExp;\n\nconst INTEGRATION_NAME = 'HttpClient';\n\ninterface HttpClientOptions {\n  /**\n   * HTTP status codes that should be considered failed.\n   * This array can contain tuples of `[begin, end]` (both inclusive),\n   * single status codes, or a combinations of both\n   *\n   * Example: [[500, 505], 507]\n   * Default: [[500, 599]]\n   */\n  failedRequestStatusCodes: HttpStatusCodeRange[];\n\n  /**\n   * Targets to track for failed requests.\n   * This array can contain strings or regular expressions.\n   *\n   * Example: ['http://localhost', /api\\/.*\\/]\n   * Default: [/.*\\/]\n   */\n  failedRequestTargets: HttpRequestTarget[];\n}\n\nconst _httpClientIntegration = ((options: Partial<HttpClientOptions> = {}) => {\n  const _options: HttpClientOptions = {\n    failedRequestStatusCodes: [[500, 599]],\n    failedRequestTargets: [/.*/],\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client): void {\n      _wrapFetch(client, _options);\n      _wrapXHR(client, _options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Create events for failed client side HTTP requests.\n */\nexport const httpClientIntegration = defineIntegration(_httpClientIntegration);\n\n/**\n * Interceptor function for fetch requests\n *\n * @param requestInfo The Fetch API request info\n * @param response The Fetch API response\n * @param requestInit The request init object\n */\nfunction _fetchResponseHandler(\n  options: HttpClientOptions,\n  requestInfo: RequestInfo,\n  response: Response,\n  requestInit?: RequestInit,\n  error?: unknown,\n): void {\n  if (_shouldCaptureResponse(options, response.status, response.url)) {\n    const request = _getRequest(requestInfo, requestInit);\n\n    let requestHeaders, responseHeaders, requestCookies, responseCookies;\n\n    if (_shouldSendDefaultPii()) {\n      [requestHeaders, requestCookies] = _parseCookieHeaders('Cookie', request);\n      [responseHeaders, responseCookies] = _parseCookieHeaders('Set-Cookie', response);\n    }\n\n    const event = _createEvent({\n      url: request.url,\n      method: request.method,\n      status: response.status,\n      requestHeaders,\n      responseHeaders,\n      requestCookies,\n      responseCookies,\n      error,\n    });\n\n    captureEvent(event);\n  }\n}\n\nfunction _parseCookieHeaders(\n  cookieHeader: string,\n  obj: Request | Response,\n): [Record<string, string>, Record<string, string> | undefined] {\n  const headers = _extractFetchHeaders(obj.headers);\n  let cookies;\n\n  try {\n    const cookieString = headers[cookieHeader] || headers[cookieHeader.toLowerCase()] || undefined;\n\n    if (cookieString) {\n      cookies = _parseCookieString(cookieString);\n    }\n  } catch {\n    // ignore it if parsing fails\n  }\n\n  return [headers, cookies];\n}\n\n/**\n * Interceptor function for XHR requests\n *\n * @param xhr The XHR request\n * @param method The HTTP method\n * @param headers The HTTP headers\n */\nfunction _xhrResponseHandler(\n  options: HttpClientOptions,\n  xhr: XMLHttpRequest,\n  method: string,\n  headers: Record<string, string>,\n  error?: unknown,\n): void {\n  if (_shouldCaptureResponse(options, xhr.status, xhr.responseURL)) {\n    let requestHeaders, responseCookies, responseHeaders;\n\n    if (_shouldSendDefaultPii()) {\n      try {\n        const cookieString = xhr.getResponseHeader('Set-Cookie') || xhr.getResponseHeader('set-cookie') || undefined;\n\n        if (cookieString) {\n          responseCookies = _parseCookieString(cookieString);\n        }\n      } catch {\n        // ignore it if parsing fails\n      }\n\n      try {\n        responseHeaders = _getXHRResponseHeaders(xhr);\n      } catch {\n        // ignore it if parsing fails\n      }\n\n      requestHeaders = headers;\n    }\n\n    const event = _createEvent({\n      url: xhr.responseURL,\n      method,\n      status: xhr.status,\n      requestHeaders,\n      // Can't access request cookies from XHR\n      responseHeaders,\n      responseCookies,\n      error,\n    });\n\n    captureEvent(event);\n  }\n}\n\n/**\n * Extracts response size from `Content-Length` header when possible\n *\n * @param headers\n * @returns The response size in bytes or undefined\n */\nfunction _getResponseSizeFromHeaders(headers?: Record<string, string>): number | undefined {\n  if (headers) {\n    const contentLength = headers['Content-Length'] || headers['content-length'];\n\n    if (contentLength) {\n      return parseInt(contentLength, 10);\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Creates an object containing cookies from the given cookie string\n *\n * @param cookieString The cookie string to parse\n * @returns The parsed cookies\n */\nfunction _parseCookieString(cookieString: string): Record<string, string> {\n  return cookieString.split('; ').reduce((acc: Record<string, string>, cookie: string) => {\n    const [key, value] = cookie.split('=');\n    if (key && value) {\n      acc[key] = value;\n    }\n    return acc;\n  }, {});\n}\n\n/**\n * Extracts the headers as an object from the given Fetch API request or response object\n *\n * @param headers The headers to extract\n * @returns The extracted headers as an object\n */\nfunction _extractFetchHeaders(headers: Headers): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  headers.forEach((value, key) => {\n    result[key] = value;\n  });\n\n  return result;\n}\n\n/**\n * Extracts the response headers as an object from the given XHR object\n *\n * @param xhr The XHR object to extract the response headers from\n * @returns The response headers as an object\n */\nfunction _getXHRResponseHeaders(xhr: XMLHttpRequest): Record<string, string> {\n  const headers = xhr.getAllResponseHeaders();\n\n  if (!headers) {\n    return {};\n  }\n\n  return headers.split('\\r\\n').reduce((acc: Record<string, string>, line: string) => {\n    const [key, value] = line.split(': ');\n    if (key && value) {\n      acc[key] = value;\n    }\n    return acc;\n  }, {});\n}\n\n/**\n * Checks if the given target url is in the given list of targets\n *\n * @param target The target url to check\n * @returns true if the target url is in the given list of targets, false otherwise\n */\nfunction _isInGivenRequestTargets(\n  failedRequestTargets: HttpClientOptions['failedRequestTargets'],\n  target: string,\n): boolean {\n  return failedRequestTargets.some((givenRequestTarget: HttpRequestTarget) => {\n    if (typeof givenRequestTarget === 'string') {\n      return target.includes(givenRequestTarget);\n    }\n\n    return givenRequestTarget.test(target);\n  });\n}\n\n/**\n * Checks if the given status code is in the given range\n *\n * @param status The status code to check\n * @returns true if the status code is in the given range, false otherwise\n */\nfunction _isInGivenStatusRanges(\n  failedRequestStatusCodes: HttpClientOptions['failedRequestStatusCodes'],\n  status: number,\n): boolean {\n  return failedRequestStatusCodes.some((range: HttpStatusCodeRange) => {\n    if (typeof range === 'number') {\n      return range === status;\n    }\n\n    return status >= range[0] && status <= range[1];\n  });\n}\n\n/**\n * Wraps `fetch` function to capture request and response data\n */\nfunction _wrapFetch(client: Client, options: HttpClientOptions): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  addFetchInstrumentationHandler(handlerData => {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { response, args, error, virtualError } = handlerData;\n    const [requestInfo, requestInit] = args as [RequestInfo, RequestInit | undefined];\n\n    if (!response) {\n      return;\n    }\n\n    _fetchResponseHandler(options, requestInfo, response as Response, requestInit, error || virtualError);\n  }, false);\n}\n\n/**\n * Wraps XMLHttpRequest to capture request and response data\n */\nfunction _wrapXHR(client: Client, options: HttpClientOptions): void {\n  if (!('XMLHttpRequest' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  addXhrInstrumentationHandler(handlerData => {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { error, virtualError } = handlerData;\n\n    const xhr = handlerData.xhr as SentryWrappedXMLHttpRequest & XMLHttpRequest;\n\n    const sentryXhrData = xhr[SENTRY_XHR_DATA_KEY];\n\n    if (!sentryXhrData) {\n      return;\n    }\n\n    const { method, request_headers: headers } = sentryXhrData;\n\n    try {\n      _xhrResponseHandler(options, xhr, method, headers, error || virtualError);\n    } catch (e) {\n      DEBUG_BUILD && logger.warn('Error while extracting response event form XHR response', e);\n    }\n  });\n}\n\n/**\n * Checks whether to capture given response as an event\n *\n * @param status response status code\n * @param url response url\n */\nfunction _shouldCaptureResponse(options: HttpClientOptions, status: number, url: string): boolean {\n  return (\n    _isInGivenStatusRanges(options.failedRequestStatusCodes, status) &&\n    _isInGivenRequestTargets(options.failedRequestTargets, url) &&\n    !isSentryRequestUrl(url, getClient())\n  );\n}\n\n/**\n * Creates a synthetic Sentry event from given response data\n *\n * @param data response data\n * @returns event\n */\nfunction _createEvent(data: {\n  url: string;\n  method: string;\n  status: number;\n  responseHeaders?: Record<string, string>;\n  responseCookies?: Record<string, string>;\n  requestHeaders?: Record<string, string>;\n  requestCookies?: Record<string, string>;\n  error?: unknown;\n}): SentryEvent {\n  const client = getClient();\n  const virtualStackTrace = client && data.error && data.error instanceof Error ? data.error.stack : undefined;\n  // Remove the first frame from the stack as it's the HttpClient call\n  const stack = virtualStackTrace && client ? client.getOptions().stackParser(virtualStackTrace, 0, 1) : undefined;\n  const message = `HTTP Client Error with status code: ${data.status}`;\n\n  const event: SentryEvent = {\n    message,\n    exception: {\n      values: [\n        {\n          type: 'Error',\n          value: message,\n          stacktrace: stack ? { frames: stack } : undefined,\n        },\n      ],\n    },\n    request: {\n      url: data.url,\n      method: data.method,\n      headers: data.requestHeaders,\n      cookies: data.requestCookies,\n    },\n    contexts: {\n      response: {\n        status_code: data.status,\n        headers: data.responseHeaders,\n        cookies: data.responseCookies,\n        body_size: _getResponseSizeFromHeaders(data.responseHeaders),\n      },\n    },\n  };\n\n  addExceptionMechanism(event, {\n    type: 'http.client',\n    handled: false,\n  });\n\n  return event;\n}\n\nfunction _getRequest(requestInfo: RequestInfo, requestInit?: RequestInit): Request {\n  if (!requestInit && requestInfo instanceof Request) {\n    return requestInfo;\n  }\n\n  // If both are set, we try to construct a new Request with the given arguments\n  // However, if e.g. the original request has a `body`, this will throw an error because it was already accessed\n  // In this case, as a fallback, we just use the original request - using both is rather an edge case\n  if (requestInfo instanceof Request && requestInfo.bodyUsed) {\n    return requestInfo;\n  }\n\n  return new Request(requestInfo, requestInit);\n}\n\nfunction _shouldSendDefaultPii(): boolean {\n  const client = getClient();\n  return client ? Boolean(client.getOptions().sendDefaultPii) : false;\n}\n","import type { Event, IntegrationFn, StackFrame } from '@sentry/core';\nimport { GLOBAL_OBJ, addContextToFrame, defineIntegration, stripUrlQueryAndFragment } from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nconst DEFAULT_LINES_OF_CONTEXT = 7;\n\nconst INTEGRATION_NAME = 'ContextLines';\n\ninterface ContextLinesOptions {\n  /**\n   * Sets the number of context lines for each frame when loading a file.\n   * Defaults to 7.\n   *\n   * Set to 0 to disable loading and inclusion of source files.\n   **/\n  frameContextLines?: number;\n}\n\nconst _contextLinesIntegration = ((options: ContextLinesOptions = {}) => {\n  const contextLines = options.frameContextLines != null ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;\n\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(event) {\n      return addSourceContext(event, contextLines);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Collects source context lines around the lines of stackframes pointing to JS embedded in\n * the current page's HTML.\n *\n * This integration DOES NOT work for stack frames pointing to JS files that are loaded by the browser.\n * For frames pointing to files, context lines are added during ingestion and symbolication\n * by attempting to download the JS files to the Sentry backend.\n *\n * Use this integration if you have inline JS code in HTML pages that can't be accessed\n * by our backend (e.g. due to a login-protected page).\n */\nexport const contextLinesIntegration = defineIntegration(_contextLinesIntegration);\n\n/**\n * Processes an event and adds context lines.\n */\nfunction addSourceContext(event: Event, contextLines: number): Event {\n  const doc = WINDOW.document;\n  const htmlFilename = WINDOW.location && stripUrlQueryAndFragment(WINDOW.location.href);\n  if (!doc || !htmlFilename) {\n    return event;\n  }\n\n  const exceptions = event.exception && event.exception.values;\n  if (!exceptions || !exceptions.length) {\n    return event;\n  }\n\n  const html = doc.documentElement.innerHTML;\n  if (!html) {\n    return event;\n  }\n\n  const htmlLines = ['<!DOCTYPE html>', '<html>', ...html.split('\\n'), '</html>'];\n\n  exceptions.forEach(exception => {\n    const stacktrace = exception.stacktrace;\n    if (stacktrace && stacktrace.frames) {\n      stacktrace.frames = stacktrace.frames.map(frame =>\n        applySourceContextToFrame(frame, htmlLines, htmlFilename, contextLines),\n      );\n    }\n  });\n\n  return event;\n}\n\n/**\n * Only exported for testing\n */\nexport function applySourceContextToFrame(\n  frame: StackFrame,\n  htmlLines: string[],\n  htmlFilename: string,\n  linesOfContext: number,\n): StackFrame {\n  if (frame.filename !== htmlFilename || !frame.lineno || !htmlLines.length) {\n    return frame;\n  }\n\n  addContextToFrame(htmlLines, frame, linesOfContext);\n\n  return frame;\n}\n","import { buildFeedbackIntegration } from '@sentry-internal/feedback';\nimport { lazyLoadIntegration } from './utils/lazyLoadIntegration';\n\n/**\n * An integration to add user feedback to your application,\n * while loading most of the code lazily only when it's needed.\n */\nexport const feedbackAsyncIntegration = buildFeedbackIntegration({\n  lazyLoadIntegration,\n});\n","import {\n  buildFeedbackIntegration,\n  feedbackModalIntegration,\n  feedbackScreenshotIntegration,\n} from '@sentry-internal/feedback';\n\n/** Add a widget to capture user feedback to your application. */\nexport const feedbackSyncIntegration = buildFeedbackIntegration({\n  getModalIntegration: () => feedbackModalIntegration,\n  getScreenshotIntegration: () => feedbackScreenshotIntegration,\n});\n","import { BrowserMetricsAggregator, metrics as metricsCore } from '@sentry/core';\nimport type { DurationUnit, MetricData, Metrics } from '@sentry/core';\n\n/**\n * Adds a value to a counter metric\n *\n * @deprecated The Sentry metrics beta has ended. This method will be removed in a future release.\n */\nfunction increment(name: string, value: number = 1, data?: MetricData): void {\n  // eslint-disable-next-line deprecation/deprecation\n  metricsCore.increment(BrowserMetricsAggregator, name, value, data);\n}\n\n/**\n * Adds a value to a distribution metric\n *\n * @deprecated The Sentry metrics beta has ended. This method will be removed in a future release.\n */\nfunction distribution(name: string, value: number, data?: MetricData): void {\n  // eslint-disable-next-line deprecation/deprecation\n  metricsCore.distribution(BrowserMetricsAggregator, name, value, data);\n}\n\n/**\n * Adds a value to a set metric. Value must be a string or integer.\n *\n * @deprecated The Sentry metrics beta has ended. This method will be removed in a future release.\n */\nfunction set(name: string, value: number | string, data?: MetricData): void {\n  // eslint-disable-next-line deprecation/deprecation\n  metricsCore.set(BrowserMetricsAggregator, name, value, data);\n}\n\n/**\n * Adds a value to a gauge metric\n *\n * @deprecated The Sentry metrics beta has ended. This method will be removed in a future release.\n */\nfunction gauge(name: string, value: number, data?: MetricData): void {\n  // eslint-disable-next-line deprecation/deprecation\n  metricsCore.gauge(BrowserMetricsAggregator, name, value, data);\n}\n\n/**\n * Adds a timing metric.\n * The metric is added as a distribution metric.\n *\n * You can either directly capture a numeric `value`, or wrap a callback function in `timing`.\n * In the latter case, the duration of the callback execution will be captured as a span & a metric.\n *\n * @deprecated The Sentry metrics beta has ended. This method will be removed in a future release.\n */\nfunction timing(name: string, value: number, unit?: DurationUnit, data?: Omit<MetricData, 'unit'>): void;\nfunction timing<T>(name: string, callback: () => T, unit?: DurationUnit, data?: Omit<MetricData, 'unit'>): T;\nfunction timing<T = void>(\n  name: string,\n  value: number | (() => T),\n  unit: DurationUnit = 'second',\n  data?: Omit<MetricData, 'unit'>,\n): T | void {\n  // eslint-disable-next-line deprecation/deprecation\n  return metricsCore.timing(BrowserMetricsAggregator, name, value, unit, data);\n}\n\n/**\n * The metrics API is used to capture custom metrics in Sentry.\n *\n * @deprecated The Sentry metrics beta has ended. This export will be removed in a future release.\n */\nexport const metrics: Metrics = {\n  increment,\n  distribution,\n  set,\n  gauge,\n  timing,\n};\n","import {\n  SENTRY_XHR_DATA_KEY,\n  addPerformanceInstrumentationHandler,\n  addXhrInstrumentationHandler,\n  extractNetworkProtocol,\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\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  // eslint-disable-next-line deprecation/deprecation\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","import type { BaseTransportOptions, Envelope, OfflineStore, OfflineTransportOptions, Transport } from '@sentry/core';\nimport { makeOfflineTransport, parseEnvelope, serializeEnvelope } from '@sentry/core';\nimport { WINDOW } from '../helpers';\nimport { makeFetchTransport } from './fetch';\n\n// 'Store', 'promisifyRequest' and 'createStore' were originally copied from the 'idb-keyval' package before being\n// modified and simplified: https://github.com/jakearchibald/idb-keyval\n//\n// At commit: 0420a704fd6cbb4225429c536b1f61112d012fca\n// Original license:\n\n// Copyright 2016, Jake Archibald\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ntype Store = <T>(callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>;\n\nfunction promisifyRequest<T = undefined>(request: IDBRequest<T> | IDBTransaction): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    // @ts-expect-error - file size hacks\n    request.oncomplete = request.onsuccess = () => resolve(request.result);\n    // @ts-expect-error - file size hacks\n    request.onabort = request.onerror = () => reject(request.error);\n  });\n}\n\n/** Create or open an IndexedDb store */\nexport function createStore(dbName: string, storeName: string): Store {\n  const request = indexedDB.open(dbName);\n  request.onupgradeneeded = () => request.result.createObjectStore(storeName);\n  const dbp = promisifyRequest(request);\n\n  return callback => dbp.then(db => callback(db.transaction(storeName, 'readwrite').objectStore(storeName)));\n}\n\nfunction keys(store: IDBObjectStore): Promise<number[]> {\n  return promisifyRequest(store.getAllKeys() as IDBRequest<number[]>);\n}\n\n/** Insert into the end of the store */\nexport function push(store: Store, value: Uint8Array | string, maxQueueSize: number): Promise<void> {\n  return store(store => {\n    return keys(store).then(keys => {\n      if (keys.length >= maxQueueSize) {\n        return;\n      }\n\n      // We insert with an incremented key so that the entries are popped in order\n      store.put(value, Math.max(...keys, 0) + 1);\n      return promisifyRequest(store.transaction);\n    });\n  });\n}\n\n/** Insert into the front of the store */\nexport function unshift(store: Store, value: Uint8Array | string, maxQueueSize: number): Promise<void> {\n  return store(store => {\n    return keys(store).then(keys => {\n      if (keys.length >= maxQueueSize) {\n        return;\n      }\n\n      // We insert with an decremented key so that the entries are popped in order\n      store.put(value, Math.min(...keys, 0) - 1);\n      return promisifyRequest(store.transaction);\n    });\n  });\n}\n\n/** Pop the oldest value from the store */\nexport function shift(store: Store): Promise<Uint8Array | string | undefined> {\n  return store(store => {\n    return keys(store).then(keys => {\n      const firstKey = keys[0];\n      if (firstKey == null) {\n        return undefined;\n      }\n\n      return promisifyRequest(store.get(firstKey)).then(value => {\n        store.delete(firstKey);\n        return promisifyRequest(store.transaction).then(() => value);\n      });\n    });\n  });\n}\n\nexport interface BrowserOfflineTransportOptions extends Omit<OfflineTransportOptions, 'createStore'> {\n  /**\n   * Name of indexedDb database to store envelopes in\n   * Default: 'sentry-offline'\n   */\n  dbName?: string;\n  /**\n   * Name of indexedDb object store to store envelopes in\n   * Default: 'queue'\n   */\n  storeName?: string;\n  /**\n   * Maximum number of envelopes to store\n   * Default: 30\n   */\n  maxQueueSize?: number;\n}\n\nfunction createIndexedDbStore(options: BrowserOfflineTransportOptions): OfflineStore {\n  let store: Store | undefined;\n\n  // Lazily create the store only when it's needed\n  function getStore(): Store {\n    if (store == undefined) {\n      store = createStore(options.dbName || 'sentry-offline', options.storeName || 'queue');\n    }\n\n    return store;\n  }\n\n  return {\n    push: async (env: Envelope) => {\n      try {\n        const serialized = await serializeEnvelope(env);\n        await push(getStore(), serialized, options.maxQueueSize || 30);\n      } catch (_) {\n        //\n      }\n    },\n    unshift: async (env: Envelope) => {\n      try {\n        const serialized = await serializeEnvelope(env);\n        await unshift(getStore(), serialized, options.maxQueueSize || 30);\n      } catch (_) {\n        //\n      }\n    },\n    shift: async () => {\n      try {\n        const deserialized = await shift(getStore());\n        if (deserialized) {\n          return parseEnvelope(deserialized);\n        }\n      } catch (_) {\n        //\n      }\n\n      return undefined;\n    },\n  };\n}\n\nfunction makeIndexedDbOfflineTransport<T>(\n  createTransport: (options: T) => Transport,\n): (options: T & BrowserOfflineTransportOptions) => Transport {\n  return options => {\n    const transport = createTransport({ ...options, createStore: createIndexedDbStore });\n\n    WINDOW.addEventListener('online', async _ => {\n      await transport.flush();\n    });\n\n    return transport;\n  };\n}\n\n/**\n * Creates a transport that uses IndexedDb to store events when offline.\n */\nexport function makeBrowserOfflineTransport<T extends BaseTransportOptions>(\n  createTransport: (options: T) => Transport = makeFetchTransport,\n): (options: T & BrowserOfflineTransportOptions) => Transport {\n  return makeIndexedDbOfflineTransport<T>(makeOfflineTransport(createTransport));\n}\n","/* eslint-disable max-lines */\nimport type { DebugImage, Envelope, Event, EventEnvelope, Profile, Span, ThreadCpuProfile } from '@sentry/core';\nimport {\n  DEFAULT_ENVIRONMENT,\n  browserPerformanceTimeOrigin,\n  forEachEnvelopeItem,\n  getClient,\n  getDebugImagesForResources,\n  logger,\n  spanToJSON,\n  timestampInSeconds,\n  uuid4,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\nimport type { JSSelfProfile, JSSelfProfileStack, JSSelfProfiler, JSSelfProfilerConstructor } from './jsSelfProfiling';\n\nconst MS_TO_NS = 1e6;\n// Use 0 as main thread id which is identical to threadId in node:worker_threads\n// where main logs 0 and workers seem to log in increments of 1\nconst THREAD_ID_STRING = String(0);\nconst THREAD_NAME = 'main';\n\n// Machine properties (eval only once)\nlet OS_PLATFORM = '';\nlet OS_PLATFORM_VERSION = '';\nlet OS_ARCH = '';\nlet OS_BROWSER = (WINDOW.navigator && WINDOW.navigator.userAgent) || '';\nlet OS_MODEL = '';\nconst OS_LOCALE =\n  (WINDOW.navigator && WINDOW.navigator.language) ||\n  (WINDOW.navigator && WINDOW.navigator.languages && WINDOW.navigator.languages[0]) ||\n  '';\n\ntype UAData = {\n  platform?: string;\n  architecture?: string;\n  model?: string;\n  platformVersion?: string;\n  fullVersionList?: {\n    brand: string;\n    version: string;\n  }[];\n};\n\ninterface UserAgentData {\n  getHighEntropyValues: (keys: string[]) => Promise<UAData>;\n}\n\nfunction isUserAgentData(data: unknown): data is UserAgentData {\n  return typeof data === 'object' && data !== null && 'getHighEntropyValues' in data;\n}\n\n// @ts-expect-error userAgentData is not part of the navigator interface yet\nconst userAgentData = WINDOW.navigator && WINDOW.navigator.userAgentData;\n\nif (isUserAgentData(userAgentData)) {\n  userAgentData\n    .getHighEntropyValues(['architecture', 'model', 'platform', 'platformVersion', 'fullVersionList'])\n    .then((ua: UAData) => {\n      OS_PLATFORM = ua.platform || '';\n      OS_ARCH = ua.architecture || '';\n      OS_MODEL = ua.model || '';\n      OS_PLATFORM_VERSION = ua.platformVersion || '';\n\n      if (ua.fullVersionList && ua.fullVersionList.length > 0) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        const firstUa = ua.fullVersionList[ua.fullVersionList.length - 1]!;\n        OS_BROWSER = `${firstUa.brand} ${firstUa.version}`;\n      }\n    })\n    .catch(e => void e);\n}\n\nfunction isProcessedJSSelfProfile(profile: ThreadCpuProfile | JSSelfProfile): profile is JSSelfProfile {\n  return !('thread_metadata' in profile);\n}\n\n// Enriches the profile with threadId of the current thread.\n// This is done in node as we seem to not be able to get the info from C native code.\n/**\n *\n */\nexport function enrichWithThreadInformation(profile: ThreadCpuProfile | JSSelfProfile): ThreadCpuProfile {\n  if (!isProcessedJSSelfProfile(profile)) {\n    return profile;\n  }\n\n  return convertJSSelfProfileToSampledFormat(profile);\n}\n\n// Profile is marked as optional because it is deleted from the metadata\n// by the integration before the event is processed by other integrations.\nexport interface ProfiledEvent extends Event {\n  sdkProcessingMetadata: {\n    profile?: JSSelfProfile;\n  };\n}\n\nfunction getTraceId(event: Event): string {\n  const traceId: unknown = event && event.contexts && event.contexts['trace'] && event.contexts['trace']['trace_id'];\n  // Log a warning if the profile has an invalid traceId (should be uuidv4).\n  // All profiles and transactions are rejected if this is the case and we want to\n  // warn users that this is happening if they enable debug flag\n  if (typeof traceId === 'string' && traceId.length !== 32) {\n    if (DEBUG_BUILD) {\n      logger.log(`[Profiling] Invalid traceId: ${traceId} on profiled event`);\n    }\n  }\n  if (typeof traceId !== 'string') {\n    return '';\n  }\n\n  return traceId;\n}\n/**\n * Creates a profiling event envelope from a Sentry event. If profile does not pass\n * validation, returns null.\n * @param event\n * @param dsn\n * @param metadata\n * @param tunnel\n * @returns {EventEnvelope | null}\n */\n\n/**\n * Creates a profiling event envelope from a Sentry event.\n */\nexport function createProfilePayload(\n  profile_id: string,\n  start_timestamp: number | undefined,\n  processed_profile: JSSelfProfile,\n  event: ProfiledEvent,\n): Profile {\n  if (event.type !== 'transaction') {\n    // createProfilingEventEnvelope should only be called for transactions,\n    // we type guard this behavior with isProfiledTransactionEvent.\n    throw new TypeError('Profiling events may only be attached to transactions, this should never occur.');\n  }\n\n  if (processed_profile === undefined || processed_profile === null) {\n    throw new TypeError(\n      `Cannot construct profiling event envelope without a valid profile. Got ${processed_profile} instead.`,\n    );\n  }\n\n  const traceId = getTraceId(event);\n  const enrichedThreadProfile = enrichWithThreadInformation(processed_profile);\n  const transactionStartMs = start_timestamp\n    ? start_timestamp\n    : typeof event.start_timestamp === 'number'\n      ? event.start_timestamp * 1000\n      : timestampInSeconds() * 1000;\n  const transactionEndMs = typeof event.timestamp === 'number' ? event.timestamp * 1000 : timestampInSeconds() * 1000;\n\n  const profile: Profile = {\n    event_id: profile_id,\n    timestamp: new Date(transactionStartMs).toISOString(),\n    platform: 'javascript',\n    version: '1',\n    release: event.release || '',\n    environment: event.environment || DEFAULT_ENVIRONMENT,\n    runtime: {\n      name: 'javascript',\n      version: WINDOW.navigator.userAgent,\n    },\n    os: {\n      name: OS_PLATFORM,\n      version: OS_PLATFORM_VERSION,\n      build_number: OS_BROWSER,\n    },\n    device: {\n      locale: OS_LOCALE,\n      model: OS_MODEL,\n      manufacturer: OS_BROWSER,\n      architecture: OS_ARCH,\n      is_emulator: false,\n    },\n    debug_meta: {\n      images: applyDebugMetadata(processed_profile.resources),\n    },\n    profile: enrichedThreadProfile,\n    transactions: [\n      {\n        name: event.transaction || '',\n        id: event.event_id || uuid4(),\n        trace_id: traceId,\n        active_thread_id: THREAD_ID_STRING,\n        relative_start_ns: '0',\n        relative_end_ns: ((transactionEndMs - transactionStartMs) * 1e6).toFixed(0),\n      },\n    ],\n  };\n\n  return profile;\n}\n\n/**\n *\n */\nexport function isProfiledTransactionEvent(event: Event): event is ProfiledEvent {\n  return !!(event.sdkProcessingMetadata && event.sdkProcessingMetadata['profile']);\n}\n\n/*\n  See packages/browser-utils/src/browser/router.ts\n*/\n/**\n *\n */\nexport function isAutomatedPageLoadSpan(span: Span): boolean {\n  return spanToJSON(span).op === 'pageload';\n}\n\n/**\n * Converts a JSSelfProfile to a our sampled format.\n * Does not currently perform stack indexing.\n */\nexport function convertJSSelfProfileToSampledFormat(input: JSSelfProfile): Profile['profile'] {\n  let EMPTY_STACK_ID: undefined | number = undefined;\n  let STACK_ID = 0;\n\n  // Initialize the profile that we will fill with data\n  const profile: Profile['profile'] = {\n    samples: [],\n    stacks: [],\n    frames: [],\n    thread_metadata: {\n      [THREAD_ID_STRING]: { name: THREAD_NAME },\n    },\n  };\n\n  const firstSample = input.samples[0];\n  if (!firstSample) {\n    return profile;\n  }\n\n  // We assert samples.length > 0 above and timestamp should always be present\n  const start = firstSample.timestamp;\n  // The JS SDK might change it's time origin based on some heuristic (see See packages/utils/src/time.ts)\n  // when that happens, we need to ensure we are correcting the profile timings so the two timelines stay in sync.\n  // Since JS self profiling time origin is always initialized to performance.timeOrigin, we need to adjust for\n  // the drift between the SDK selected value and our profile time origin.\n  const origin =\n    typeof performance.timeOrigin === 'number' ? performance.timeOrigin : browserPerformanceTimeOrigin || 0;\n  const adjustForOriginChange = origin - (browserPerformanceTimeOrigin || origin);\n\n  input.samples.forEach((jsSample, i) => {\n    // If sample has no stack, add an empty sample\n    if (jsSample.stackId === undefined) {\n      if (EMPTY_STACK_ID === undefined) {\n        EMPTY_STACK_ID = STACK_ID;\n        profile.stacks[EMPTY_STACK_ID] = [];\n        STACK_ID++;\n      }\n\n      profile['samples'][i] = {\n        // convert ms timestamp to ns\n        elapsed_since_start_ns: ((jsSample.timestamp + adjustForOriginChange - start) * MS_TO_NS).toFixed(0),\n        stack_id: EMPTY_STACK_ID,\n        thread_id: THREAD_ID_STRING,\n      };\n      return;\n    }\n\n    let stackTop: JSSelfProfileStack | undefined = input.stacks[jsSample.stackId];\n\n    // Functions in top->down order (root is last)\n    // We follow the stackTop.parentId trail and collect each visited frameId\n    const stack: number[] = [];\n\n    while (stackTop) {\n      stack.push(stackTop.frameId);\n\n      const frame = input.frames[stackTop.frameId];\n\n      // If our frame has not been indexed yet, index it\n      if (frame && profile.frames[stackTop.frameId] === undefined) {\n        profile.frames[stackTop.frameId] = {\n          function: frame.name,\n          abs_path: typeof frame.resourceId === 'number' ? input.resources[frame.resourceId] : undefined,\n          lineno: frame.line,\n          colno: frame.column,\n        };\n      }\n\n      stackTop = stackTop.parentId === undefined ? undefined : input.stacks[stackTop.parentId];\n    }\n\n    const sample: Profile['profile']['samples'][0] = {\n      // convert ms timestamp to ns\n      elapsed_since_start_ns: ((jsSample.timestamp + adjustForOriginChange - start) * MS_TO_NS).toFixed(0),\n      stack_id: STACK_ID,\n      thread_id: THREAD_ID_STRING,\n    };\n\n    profile['stacks'][STACK_ID] = stack;\n    profile['samples'][i] = sample;\n    STACK_ID++;\n  });\n\n  return profile;\n}\n\n/**\n * Adds items to envelope if they are not already present - mutates the envelope.\n * @param envelope\n */\nexport function addProfilesToEnvelope(envelope: EventEnvelope, profiles: Profile[]): Envelope {\n  if (!profiles.length) {\n    return envelope;\n  }\n\n  for (const profile of profiles) {\n    envelope[1].push([{ type: 'profile' }, profile]);\n  }\n  return envelope;\n}\n\n/**\n * Finds transactions with profile_id context in the envelope\n * @param envelope\n * @returns\n */\nexport function findProfiledTransactionsFromEnvelope(envelope: Envelope): Event[] {\n  const events: Event[] = [];\n\n  forEachEnvelopeItem(envelope, (item, type) => {\n    if (type !== 'transaction') {\n      return;\n    }\n\n    for (let j = 1; j < item.length; j++) {\n      const event = item[j] as Event;\n\n      if (event && event.contexts && event.contexts['profile'] && event.contexts['profile']['profile_id']) {\n        events.push(item[j] as Event);\n      }\n    }\n  });\n\n  return events;\n}\n\n/**\n * Applies debug meta data to an event from a list of paths to resources (sourcemaps)\n */\nexport function applyDebugMetadata(resource_paths: ReadonlyArray<string>): DebugImage[] {\n  const client = getClient();\n  const options = client && client.getOptions();\n  const stackParser = options && options.stackParser;\n\n  if (!stackParser) {\n    return [];\n  }\n\n  return getDebugImagesForResources(stackParser, resource_paths);\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nexport function isValidSampleRate(rate: unknown): boolean {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  if ((typeof rate !== 'number' && typeof rate !== 'boolean') || (typeof rate === 'number' && isNaN(rate))) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `[Profiling] Invalid sample rate. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // Boolean sample rates are always valid\n  if (rate === true || rate === false) {\n    return true;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    DEBUG_BUILD && logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n\nfunction isValidProfile(profile: JSSelfProfile): profile is JSSelfProfile & { profile_id: string } {\n  if (profile.samples.length < 2) {\n    if (DEBUG_BUILD) {\n      // Log a warning if the profile has less than 2 samples so users can know why\n      // they are not seeing any profiling data and we cant avoid the back and forth\n      // of asking them to provide us with a dump of the profile data.\n      logger.log('[Profiling] Discarding profile because it contains less than 2 samples');\n    }\n    return false;\n  }\n\n  if (!profile.frames.length) {\n    if (DEBUG_BUILD) {\n      logger.log('[Profiling] Discarding profile because it contains no frames');\n    }\n    return false;\n  }\n\n  return true;\n}\n\n// Keep a flag value to avoid re-initializing the profiler constructor. If it fails\n// once, it will always fail and this allows us to early return.\nlet PROFILING_CONSTRUCTOR_FAILED: boolean = false;\nexport const MAX_PROFILE_DURATION_MS = 30_000;\n\n/**\n * Check if profiler constructor is available.\n * @param maybeProfiler\n */\nfunction isJSProfilerSupported(maybeProfiler: unknown): maybeProfiler is typeof JSSelfProfilerConstructor {\n  return typeof maybeProfiler === 'function';\n}\n\n/**\n * Starts the profiler and returns the profiler instance.\n */\nexport function startJSSelfProfile(): JSSelfProfiler | undefined {\n  // Feature support check first\n  const JSProfilerConstructor = WINDOW.Profiler;\n\n  if (!isJSProfilerSupported(JSProfilerConstructor)) {\n    if (DEBUG_BUILD) {\n      logger.log(\n        '[Profiling] Profiling is not supported by this browser, Profiler interface missing on window object.',\n      );\n    }\n    return;\n  }\n\n  // From initial testing, it seems that the minimum value for sampleInterval is 10ms.\n  const samplingIntervalMS = 10;\n  // Start the profiler\n  const maxSamples = Math.floor(MAX_PROFILE_DURATION_MS / samplingIntervalMS);\n\n  // Attempt to initialize the profiler constructor, if it fails, we disable profiling for the current user session.\n  // This is likely due to a missing 'Document-Policy': 'js-profiling' header. We do not want to throw an error if this happens\n  // as we risk breaking the user's application, so just disable profiling and log an error.\n  try {\n    return new JSProfilerConstructor({ sampleInterval: samplingIntervalMS, maxBufferSize: maxSamples });\n  } catch (e) {\n    if (DEBUG_BUILD) {\n      logger.log(\n        \"[Profiling] Failed to initialize the Profiling constructor, this is likely due to a missing 'Document-Policy': 'js-profiling' header.\",\n      );\n      logger.log('[Profiling] Disabling profiling for current user session.');\n    }\n    PROFILING_CONSTRUCTOR_FAILED = true;\n  }\n\n  return;\n}\n\n/**\n * Determine if a profile should be profiled.\n */\nexport function shouldProfileSpan(span: Span): boolean {\n  // If constructor failed once, it will always fail, so we can early return.\n  if (PROFILING_CONSTRUCTOR_FAILED) {\n    if (DEBUG_BUILD) {\n      logger.log('[Profiling] Profiling has been disabled for the duration of the current user session.');\n    }\n    return false;\n  }\n\n  if (!span.isRecording()) {\n    if (DEBUG_BUILD) {\n      logger.log('[Profiling] Discarding profile because transaction was not sampled.');\n    }\n    return false;\n  }\n\n  const client = getClient();\n  const options = client && client.getOptions();\n  if (!options) {\n    DEBUG_BUILD && logger.log('[Profiling] Profiling disabled, no options found.');\n    return false;\n  }\n\n  // @ts-expect-error profilesSampleRate is not part of the browser options yet\n  const profilesSampleRate: number | boolean | undefined = options.profilesSampleRate;\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(profilesSampleRate)) {\n    DEBUG_BUILD && logger.warn('[Profiling] Discarding profile because of invalid sample rate.');\n    return false;\n  }\n\n  // if the function returned 0 (or false), or if `profileSampleRate` is 0, it's a sign the profile should be dropped\n  if (!profilesSampleRate) {\n    DEBUG_BUILD &&\n      logger.log(\n        '[Profiling] Discarding profile because a negative sampling decision was inherited or profileSampleRate is set to 0',\n      );\n    return false;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  const sampled = profilesSampleRate === true ? true : Math.random() < profilesSampleRate;\n  // Check if we should sample this profile\n  if (!sampled) {\n    DEBUG_BUILD &&\n      logger.log(\n        `[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(\n          profilesSampleRate,\n        )})`,\n      );\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a profiling envelope item, if the profile does not pass validation, returns null.\n * @param event\n * @returns {Profile | null}\n */\nexport function createProfilingEvent(\n  profile_id: string,\n  start_timestamp: number | undefined,\n  profile: JSSelfProfile,\n  event: ProfiledEvent,\n): Profile | null {\n  if (!isValidProfile(profile)) {\n    return null;\n  }\n\n  return createProfilePayload(profile_id, start_timestamp, profile, event);\n}\n\n// TODO (v8): We need to obtain profile ids in @sentry-internal/tracing,\n// but we don't have access to this map because importing this map would\n// cause a circular dependency. We need to resolve this in v8.\nconst PROFILE_MAP: Map<string, JSSelfProfile> = new Map();\n/**\n *\n */\nexport function getActiveProfilesCount(): number {\n  return PROFILE_MAP.size;\n}\n\n/**\n * Retrieves profile from global cache and removes it.\n */\nexport function takeProfileFromGlobalCache(profile_id: string): JSSelfProfile | undefined {\n  const profile = PROFILE_MAP.get(profile_id);\n  if (profile) {\n    PROFILE_MAP.delete(profile_id);\n  }\n  return profile;\n}\n/**\n * Adds profile to global cache and evicts the oldest profile if the cache is full.\n */\nexport function addProfileToGlobalCache(profile_id: string, profile: JSSelfProfile): void {\n  PROFILE_MAP.set(profile_id, profile);\n\n  if (PROFILE_MAP.size > 30) {\n    const last: string = PROFILE_MAP.keys().next().value;\n    PROFILE_MAP.delete(last);\n  }\n}\n","import { getCurrentScope, spanToJSON } from '@sentry/core';\nimport { logger, timestampInSeconds, uuid4 } from '@sentry/core';\nimport type { Span } from '@sentry/core';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\nimport type { JSSelfProfile } from './jsSelfProfiling';\nimport { MAX_PROFILE_DURATION_MS, addProfileToGlobalCache, isAutomatedPageLoadSpan, startJSSelfProfile } from './utils';\n\n/**\n * Wraps startTransaction and stopTransaction with profiling related logic.\n * startProfileForTransaction is called after the call to startTransaction in order to avoid our own code from\n * being profiled. Because of that same reason, stopProfiling is called before the call to stopTransaction.\n */\nexport function startProfileForSpan(span: Span): void {\n  // Start the profiler and get the profiler instance.\n  let startTimestamp: number | undefined;\n  if (isAutomatedPageLoadSpan(span)) {\n    startTimestamp = timestampInSeconds() * 1000;\n  }\n\n  const profiler = startJSSelfProfile();\n\n  // We failed to construct the profiler, so we skip.\n  // No need to log anything as this has already been logged in startProfile.\n  if (!profiler) {\n    return;\n  }\n\n  if (DEBUG_BUILD) {\n    logger.log(`[Profiling] started profiling span: ${spanToJSON(span).description}`);\n  }\n\n  // We create \"unique\" span names to avoid concurrent spans with same names\n  // from being ignored by the profiler. From here on, only this span name should be used when\n  // calling the profiler methods. Note: we log the original name to the user to avoid confusion.\n  const profileId = uuid4();\n\n  // A couple of important things to note here:\n  // `CpuProfilerBindings.stopProfiling` will be scheduled to run in 30seconds in order to exceed max profile duration.\n  // Whichever of the two (span.finish/timeout) is first to run, the profiling will be stopped and the gathered profile\n  // will be processed when the original span is finished. Since onProfileHandler can be invoked multiple times in the\n  // event of an error or user mistake (calling span.finish multiple times), it is important that the behavior of onProfileHandler\n  // is idempotent as we do not want any timings or profiles to be overridden by the last call to onProfileHandler.\n  // After the original finish method is called, the event will be reported through the integration and delegated to transport.\n  const processedProfile: JSSelfProfile | null = null;\n\n  getCurrentScope().setContext('profile', {\n    profile_id: profileId,\n    start_timestamp: startTimestamp,\n  });\n\n  /**\n   * Idempotent handler for profile stop\n   */\n  async function onProfileHandler(): Promise<void> {\n    // Check if the profile exists and return it the behavior has to be idempotent as users may call span.finish multiple times.\n    if (!span) {\n      return;\n    }\n    // Satisfy the type checker, but profiler will always be defined here.\n    if (!profiler) {\n      return;\n    }\n    if (processedProfile) {\n      if (DEBUG_BUILD) {\n        logger.log('[Profiling] profile for:', spanToJSON(span).description, 'already exists, returning early');\n      }\n      return;\n    }\n\n    return profiler\n      .stop()\n      .then((profile: JSSelfProfile): void => {\n        if (maxDurationTimeoutID) {\n          WINDOW.clearTimeout(maxDurationTimeoutID);\n          maxDurationTimeoutID = undefined;\n        }\n\n        if (DEBUG_BUILD) {\n          logger.log(`[Profiling] stopped profiling of span: ${spanToJSON(span).description}`);\n        }\n\n        // In case of an overlapping span, stopProfiling may return null and silently ignore the overlapping profile.\n        if (!profile) {\n          if (DEBUG_BUILD) {\n            logger.log(\n              `[Profiling] profiler returned null profile for: ${spanToJSON(span).description}`,\n              'this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started',\n            );\n          }\n          return;\n        }\n\n        addProfileToGlobalCache(profileId, profile);\n      })\n      .catch(error => {\n        if (DEBUG_BUILD) {\n          logger.log('[Profiling] error while stopping profiler:', error);\n        }\n      });\n  }\n\n  // Enqueue a timeout to prevent profiles from running over max duration.\n  let maxDurationTimeoutID: number | undefined = WINDOW.setTimeout(() => {\n    if (DEBUG_BUILD) {\n      logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', spanToJSON(span).description);\n    }\n    // If the timeout exceeds, we want to stop profiling, but not finish the span\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    onProfileHandler();\n  }, MAX_PROFILE_DURATION_MS);\n\n  // We need to reference the original end call to avoid creating an infinite loop\n  const originalEnd = span.end.bind(span);\n\n  /**\n   * Wraps span `end()` with profiling related logic.\n   * startProfiling is called after the call to spanStart in order to avoid our own code from\n   * being profiled. Because of that same reason, stopProfiling is called before the call to spanEnd.\n   */\n  function profilingWrappedSpanEnd(): Span {\n    if (!span) {\n      return originalEnd();\n    }\n    // onProfileHandler should always return the same profile even if this is called multiple times.\n    // Always call onProfileHandler to ensure stopProfiling is called and the timeout is cleared.\n    void onProfileHandler().then(\n      () => {\n        originalEnd();\n      },\n      () => {\n        // If onProfileHandler fails, we still want to call the original finish method.\n        originalEnd();\n      },\n    );\n\n    return span;\n  }\n\n  span.end = profilingWrappedSpanEnd;\n}\n","import { defineIntegration, getActiveSpan, getRootSpan } from '@sentry/core';\nimport { logger } from '@sentry/core';\nimport type { EventEnvelope, IntegrationFn, Profile, Span } from '@sentry/core';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { startProfileForSpan } from './startProfileForSpan';\nimport type { ProfiledEvent } from './utils';\nimport { isAutomatedPageLoadSpan, shouldProfileSpan } from './utils';\nimport {\n  addProfilesToEnvelope,\n  createProfilingEvent,\n  findProfiledTransactionsFromEnvelope,\n  getActiveProfilesCount,\n  takeProfileFromGlobalCache,\n} from './utils';\n\nconst INTEGRATION_NAME = 'BrowserProfiling';\n\nconst _browserProfilingIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      const activeSpan = getActiveSpan();\n      const rootSpan = activeSpan && getRootSpan(activeSpan);\n\n      if (rootSpan && isAutomatedPageLoadSpan(rootSpan)) {\n        if (shouldProfileSpan(rootSpan)) {\n          startProfileForSpan(rootSpan);\n        }\n      }\n\n      client.on('spanStart', (span: Span) => {\n        if (span === getRootSpan(span) && shouldProfileSpan(span)) {\n          startProfileForSpan(span);\n        }\n      });\n\n      client.on('beforeEnvelope', (envelope): void => {\n        // if not profiles are in queue, there is nothing to add to the envelope.\n        if (!getActiveProfilesCount()) {\n          return;\n        }\n\n        const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);\n        if (!profiledTransactionEvents.length) {\n          return;\n        }\n\n        const profilesToAddToEnvelope: Profile[] = [];\n\n        for (const profiledTransaction of profiledTransactionEvents) {\n          const context = profiledTransaction && profiledTransaction.contexts;\n          const profile_id = context && context['profile'] && context['profile']['profile_id'];\n          const start_timestamp = context && context['profile'] && context['profile']['start_timestamp'];\n\n          if (typeof profile_id !== 'string') {\n            DEBUG_BUILD && logger.log('[Profiling] cannot find profile for a span without a profile context');\n            continue;\n          }\n\n          if (!profile_id) {\n            DEBUG_BUILD && logger.log('[Profiling] cannot find profile for a span without a profile context');\n            continue;\n          }\n\n          // Remove the profile from the span context before sending, relay will take care of the rest.\n          if (context && context['profile']) {\n            delete context.profile;\n          }\n\n          const profile = takeProfileFromGlobalCache(profile_id);\n          if (!profile) {\n            DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for span: ${profile_id}`);\n            continue;\n          }\n\n          const profileEvent = createProfilingEvent(\n            profile_id,\n            start_timestamp as number | undefined,\n            profile,\n            profiledTransaction as ProfiledEvent,\n          );\n          if (profileEvent) {\n            profilesToAddToEnvelope.push(profileEvent);\n          }\n        }\n\n        addProfilesToEnvelope(envelope as EventEnvelope, profilesToAddToEnvelope);\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const browserProfilingIntegration = defineIntegration(_browserProfilingIntegration);\n","import { getNativeImplementation } from '@sentry-internal/browser-utils';\nimport type { Client, Envelope, Event, IntegrationFn } from '@sentry/core';\nimport { defineIntegration, logger, serializeEnvelope } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { WINDOW } from '../helpers';\n\nexport type SpotlightConnectionOptions = {\n  /**\n   * Set this if the Spotlight Sidecar is not running on localhost:8969\n   * By default, the Url is set to http://localhost:8969/stream\n   */\n  sidecarUrl?: string;\n};\n\nexport const INTEGRATION_NAME = 'SpotlightBrowser';\n\nconst _spotlightIntegration = ((options: Partial<SpotlightConnectionOptions> = {}) => {\n  const sidecarUrl = options.sidecarUrl || 'http://localhost:8969/stream';\n\n  return {\n    name: INTEGRATION_NAME,\n    setup: () => {\n      DEBUG_BUILD && logger.log('Using Sidecar URL', sidecarUrl);\n    },\n    // We don't want to send interaction transactions/root spans created from\n    // clicks within Spotlight to Sentry. Neither do we want them to be sent to\n    // spotlight.\n    processEvent: event => (isSpotlightInteraction(event) ? null : event),\n    afterAllSetup: (client: Client) => {\n      setupSidecarForwarding(client, sidecarUrl);\n    },\n  };\n}) satisfies IntegrationFn;\n\nfunction setupSidecarForwarding(client: Client, sidecarUrl: string): void {\n  const makeFetch: typeof WINDOW.fetch | undefined = getNativeImplementation('fetch');\n  let failCount = 0;\n\n  client.on('beforeEnvelope', (envelope: Envelope) => {\n    if (failCount > 3) {\n      logger.warn('[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests:', failCount);\n      return;\n    }\n\n    makeFetch(sidecarUrl, {\n      method: 'POST',\n      body: serializeEnvelope(envelope),\n      headers: {\n        'Content-Type': 'application/x-sentry-envelope',\n      },\n      mode: 'cors',\n    }).then(\n      res => {\n        if (res.status >= 200 && res.status < 400) {\n          // Reset failed requests counter on success\n          failCount = 0;\n        }\n      },\n      err => {\n        failCount++;\n        logger.error(\n          \"Sentry SDK can't connect to Sidecar is it running? See: https://spotlightjs.com/sidecar/npx/\",\n          err,\n        );\n      },\n    );\n  });\n}\n\n/**\n * Use this integration to send errors and transactions to Spotlight.\n *\n * Learn more about spotlight at https://spotlightjs.com\n */\nexport const spotlightBrowserIntegration = defineIntegration(_spotlightIntegration);\n\n/**\n * Flags if the event is a transaction created from an interaction with the spotlight UI.\n */\nexport function isSpotlightInteraction(event: Event): boolean {\n  return Boolean(\n    event.type === 'transaction' &&\n      event.spans &&\n      event.contexts &&\n      event.contexts.trace &&\n      event.contexts.trace.op === 'ui.action.click' &&\n      event.spans.some(({ description }) => description && description.includes('#sentry-spotlight')),\n  );\n}\n","import type { Event, FeatureFlag } from '@sentry/core';\n\nimport { getCurrentScope, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\n\n/**\n * Ordered LRU cache for storing feature flags in the scope context. The name\n * of each flag in the buffer is unique, and the output of getAll() is ordered\n * from oldest to newest.\n */\n\n/**\n * Max size of the LRU flag buffer stored in Sentry scope and event contexts.\n */\nexport const FLAG_BUFFER_SIZE = 100;\n\n/**\n * Copies feature flags that are in current scope context to the event context\n */\nexport function copyFlagsFromScopeToEvent(event: Event): Event {\n  const scope = getCurrentScope();\n  const flagContext = scope.getScopeData().contexts.flags;\n  const flagBuffer = flagContext ? flagContext.values : [];\n\n  if (!flagBuffer.length) {\n    return event;\n  }\n\n  if (event.contexts === undefined) {\n    event.contexts = {};\n  }\n  event.contexts.flags = { values: [...flagBuffer] };\n  return event;\n}\n\n/**\n * Creates a feature flags values array in current context if it does not exist\n * and inserts the flag into a FeatureFlag array while maintaining ordered LRU\n * properties. Not thread-safe. After inserting:\n * - `flags` is sorted in order of recency, with the newest flag at the end.\n * - No other flags with the same name exist in `flags`.\n * - The length of `flags` does not exceed `maxSize`. The oldest flag is evicted\n *  as needed.\n *\n * @param name     Name of the feature flag to insert.\n * @param value    Value of the feature flag.\n * @param maxSize  Max number of flags the buffer should store. It's recommended\n *   to keep this consistent across insertions. Default is FLAG_BUFFER_SIZE\n */\nexport function insertFlagToScope(name: string, value: unknown, maxSize: number = FLAG_BUFFER_SIZE): void {\n  const scopeContexts = getCurrentScope().getScopeData().contexts;\n  if (!scopeContexts.flags) {\n    scopeContexts.flags = { values: [] };\n  }\n  const flags = scopeContexts.flags.values as FeatureFlag[];\n  insertToFlagBuffer(flags, name, value, maxSize);\n}\n\n/**\n * Exported for tests. Currently only accepts boolean values (otherwise no-op).\n */\nexport function insertToFlagBuffer(flags: FeatureFlag[], name: string, value: unknown, maxSize: number): void {\n  if (typeof value !== 'boolean') {\n    return;\n  }\n\n  if (flags.length > maxSize) {\n    DEBUG_BUILD && logger.error(`[Feature Flags] insertToFlagBuffer called on a buffer larger than maxSize=${maxSize}`);\n    return;\n  }\n\n  // Check if the flag is already in the buffer - O(n)\n  const index = flags.findIndex(f => f.flag === name);\n\n  if (index !== -1) {\n    // The flag was found, remove it from its current position - O(n)\n    flags.splice(index, 1);\n  }\n\n  if (flags.length === maxSize) {\n    // If at capacity, pop the earliest flag - O(n)\n    flags.shift();\n  }\n\n  // Push the flag to the end - O(1)\n  flags.push({\n    flag: name,\n    result: value,\n  });\n}\n","import type { Client, Event, EventHint, Integration, IntegrationFn } from '@sentry/core';\n\nimport { defineIntegration } from '@sentry/core';\nimport { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../utils/featureFlags';\n\nexport interface FeatureFlagsIntegration extends Integration {\n  addFeatureFlag: (name: string, value: unknown) => void;\n}\n\n/**\n * Sentry integration for buffering feature flags manually with an API, and\n * capturing them on error events. We recommend you do this on each flag\n * evaluation. Flags are buffered per Sentry scope and limited to 100 per event.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import * as Sentry from '@sentry/browser';\n * import { type FeatureFlagsIntegration } from '@sentry/browser';\n *\n * // Setup\n * Sentry.init(..., integrations: [Sentry.featureFlagsIntegration()])\n *\n * // Verify\n * const flagsIntegration = Sentry.getClient()?.getIntegrationByName<FeatureFlagsIntegration>('FeatureFlags');\n * if (flagsIntegration) {\n *   flagsIntegration.addFeatureFlag('my-flag', true);\n * } else {\n *   // check your setup\n * }\n * Sentry.captureException(Exception('broke')); // 'my-flag' should be captured to this Sentry event.\n * ```\n */\nexport const featureFlagsIntegration = defineIntegration(() => {\n  return {\n    name: 'FeatureFlags',\n\n    processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n      return copyFlagsFromScopeToEvent(event);\n    },\n\n    addFeatureFlag(name: string, value: unknown): void {\n      insertFlagToScope(name, value);\n    },\n  };\n}) as IntegrationFn<FeatureFlagsIntegration>;\n","import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\nimport type { LDContext, LDEvaluationDetail, LDInspectionFlagUsedHandler } from './types';\n\nimport { defineIntegration } from '@sentry/core';\nimport { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';\n\n/**\n * Sentry integration for capturing feature flags from LaunchDarkly.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import * as Sentry from '@sentry/browser';\n * import {launchDarklyIntegration, buildLaunchDarklyFlagUsedInspector} from '@sentry/browser';\n * import * as LaunchDarkly from 'launchdarkly-js-client-sdk';\n *\n * Sentry.init(..., integrations: [launchDarklyIntegration()])\n * const ldClient = LaunchDarkly.initialize(..., {inspectors: [buildLaunchDarklyFlagUsedHandler()]});\n * ```\n */\nexport const launchDarklyIntegration = defineIntegration(() => {\n  return {\n    name: 'LaunchDarkly',\n\n    processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n      return copyFlagsFromScopeToEvent(event);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * LaunchDarkly hook that listens for flag evaluations and updates the `flags`\n * context in our Sentry scope. This needs to be registered as an\n * 'inspector' in LaunchDarkly initialize() options, separately from\n * `launchDarklyIntegration`. Both are needed to collect feature flags on error.\n */\nexport function buildLaunchDarklyFlagUsedHandler(): LDInspectionFlagUsedHandler {\n  return {\n    name: 'sentry-flag-auditor',\n    type: 'flag-used',\n\n    synchronous: true,\n\n    /**\n     * Handle a flag evaluation by storing its name and value on the current scope.\n     */\n    method: (flagKey: string, flagDetail: LDEvaluationDetail, _context: LDContext) => {\n      insertFlagToScope(flagKey, flagDetail.value);\n    },\n  };\n}\n","/**\n * OpenFeature integration.\n *\n * Add the openFeatureIntegration() function call to your integration lists.\n * Add the integration hook to your OpenFeature object.\n *   - OpenFeature.getClient().addHooks(new OpenFeatureIntegrationHook());\n */\nimport type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\nimport type { EvaluationDetails, HookContext, HookHints, JsonValue, OpenFeatureHook } from './types';\n\nimport { defineIntegration } from '@sentry/core';\nimport { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';\n\nexport const openFeatureIntegration = defineIntegration(() => {\n  return {\n    name: 'OpenFeature',\n\n    processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n      return copyFlagsFromScopeToEvent(event);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * OpenFeature Hook class implementation.\n */\nexport class OpenFeatureIntegrationHook implements OpenFeatureHook {\n  /**\n   * Successful evaluation result.\n   */\n  public after(_hookContext: Readonly<HookContext<JsonValue>>, evaluationDetails: EvaluationDetails<JsonValue>): void {\n    insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);\n  }\n\n  /**\n   * On error evaluation result.\n   */\n  public error(hookContext: Readonly<HookContext<JsonValue>>, _error: unknown, _hookHints?: HookHints): void {\n    insertFlagToScope(hookContext.flagKey, hookContext.defaultValue);\n  }\n}\n","import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\n\nimport { defineIntegration, fill, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';\nimport type { UnleashClient, UnleashClientClass } from './types';\n\ntype UnleashIntegrationOptions = {\n  featureFlagClientClass?: UnleashClientClass;\n\n  /**\n   * @deprecated Use `featureFlagClientClass` instead.\n   */\n  unleashClientClass?: UnleashClientClass;\n};\n\n/**\n * Sentry integration for capturing feature flag evaluations from the Unleash SDK.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import { UnleashClient } from 'unleash-proxy-client';\n * import * as Sentry from '@sentry/browser';\n *\n * Sentry.init({\n *   dsn: '___PUBLIC_DSN___',\n *   integrations: [Sentry.unleashIntegration({featureFlagClientClass: UnleashClient})],\n * });\n *\n * const unleash = new UnleashClient(...);\n * unleash.start();\n *\n * unleash.isEnabled('my-feature');\n * Sentry.captureException(new Error('something went wrong'));\n * ```\n */\nexport const unleashIntegration = defineIntegration(\n  // eslint-disable-next-line deprecation/deprecation\n  ({ featureFlagClientClass, unleashClientClass }: UnleashIntegrationOptions) => {\n    const _unleashClientClass = featureFlagClientClass ? featureFlagClientClass : unleashClientClass;\n    if (!_unleashClientClass) {\n      throw new Error('featureFlagClientClass option is required');\n    }\n\n    return {\n      name: 'Unleash',\n\n      processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n        return copyFlagsFromScopeToEvent(event);\n      },\n\n      setupOnce() {\n        const unleashClientPrototype = _unleashClientClass.prototype as UnleashClient;\n        fill(unleashClientPrototype, 'isEnabled', _wrappedIsEnabled);\n      },\n    };\n  },\n) satisfies IntegrationFn;\n\n/**\n * Wraps the UnleashClient.isEnabled method to capture feature flag evaluations. Its only side effect is writing to Sentry scope.\n *\n * This wrapper is safe for all isEnabled signatures. If the signature does not match (this: UnleashClient, toggleName: string, ...args: unknown[]) => boolean,\n * we log an error and return the original result.\n *\n * @param original - The original method.\n * @returns Wrapped method. Results should match the original.\n */\nfunction _wrappedIsEnabled(\n  original: (this: UnleashClient, ...args: unknown[]) => unknown,\n): (this: UnleashClient, ...args: unknown[]) => unknown {\n  return function (this: UnleashClient, ...args: unknown[]): unknown {\n    const toggleName = args[0];\n    const result = original.apply(this, args);\n\n    if (typeof toggleName === 'string' && typeof result === 'boolean') {\n      insertFlagToScope(toggleName, result);\n    } else if (DEBUG_BUILD) {\n      logger.error(\n        `[Feature Flags] UnleashClient.isEnabled does not match expected signature. arg0: ${toggleName} (${typeof toggleName}), result: ${result} (${typeof result})`,\n      );\n    }\n    return result;\n  };\n}\n","import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';\n\nimport { defineIntegration } from '@sentry/core';\nimport { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';\nimport type { FeatureGate, StatsigClient } from './types';\n\n/**\n * Sentry integration for capturing feature flag evaluations from the Statsig js-client SDK.\n *\n * See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.\n *\n * @example\n * ```\n * import { StatsigClient } from '@statsig/js-client';\n * import * as Sentry from '@sentry/browser';\n *\n * const statsigClient = new StatsigClient();\n *\n * Sentry.init({\n *   dsn: '___PUBLIC_DSN___',\n *   integrations: [Sentry.statsigIntegration({featureFlagClient: statsigClient})],\n * });\n *\n * await statsigClient.initializeAsync();  // or statsigClient.initializeSync();\n *\n * const result = statsigClient.checkGate('my-feature-gate');\n * Sentry.captureException(new Error('something went wrong'));\n * ```\n */\nexport const statsigIntegration = defineIntegration(\n  ({ featureFlagClient: statsigClient }: { featureFlagClient: StatsigClient }) => {\n    return {\n      name: 'Statsig',\n\n      processEvent(event: Event, _hint: EventHint, _client: Client): Event {\n        return copyFlagsFromScopeToEvent(event);\n      },\n\n      setup() {\n        statsigClient.on('gate_evaluation', (event: { gate: FeatureGate }) => {\n          insertFlagToScope(event.gate.name, event.gate.value);\n        });\n      },\n    };\n  },\n) satisfies IntegrationFn;\n"]}