{"version":3,"file":"static/chunks/19-e9f3591d2292e565.js","mappings":"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","sources":["webpack://_N_E/../../src/hub.ts","webpack://_N_E/../../src/scope.ts","webpack://_N_E/../../src/session.ts","webpack://_N_E/../../src/browser.ts","webpack://_N_E/../../src/global.ts","webpack://_N_E/../../src/is.ts","webpack://_N_E/../../src/logger.ts","webpack://_N_E/../../src/misc.ts","webpack://_N_E/../../src/node.ts","webpack://_N_E/../../src/env.ts","webpack://_N_E/../../src/object.ts","webpack://_N_E/../../src/string.ts","webpack://_N_E/../../src/syncpromise.ts","webpack://_N_E/../../src/time.ts"],"sourcesContent":["/* eslint-disable max-lines */\nimport {\n  Breadcrumb,\n  BreadcrumbHint,\n  Client,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Hub as HubInterface,\n  Integration,\n  IntegrationClass,\n  Primitive,\n  Session,\n  SessionContext,\n  Severity,\n  SeverityLevel,\n  Transaction,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport {\n  consoleSandbox,\n  dateTimestampInSeconds,\n  getGlobalObject,\n  getGlobalSingleton,\n  isNodeEnv,\n  logger,\n  uuid4,\n} from '@sentry/utils';\n\nimport { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\nexport interface Layer {\n  client?: Client;\n  scope?: Scope;\n}\n\n/**\n * An object that contains a hub and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n  __SENTRY__?: {\n    hub?: Hub;\n    /**\n     * Extra Hub properties injected by various SDKs\n     */\n    integrations?: Integration[];\n    extensions?: {\n      /** Hack to prevent bundlers from breaking our usage of the domain package in the cross-platform Hub package */\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      domain?: { [key: string]: any };\n    } & {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n}\n\n/**\n * @inheritDoc\n */\nexport class Hub implements HubInterface {\n  /** Is a {@link Layer}[] containing the client and scope */\n  private readonly _stack: Layer[] = [{}];\n\n  /** Contains the last event id of a captured event.  */\n  private _lastEventId?: string;\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n  public constructor(client?: Client, scope: Scope = new Scope(), private readonly _version: number = API_VERSION) {\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isOlderThan(version: number): boolean {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public bindClient(client?: Client): void {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public pushScope(): Scope {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public popScope(): boolean {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public withScope(callback: (scope: Scope) => void): void {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this.getStackTop().client as C;\n  }\n\n  /** Returns the scope of the top stack. */\n  public getScope(): Scope | undefined {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n  public getStack(): Layer[] {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n  ): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== 'transaction') {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): void {\n    const scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): void {\n    const scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public setContext(name: string, context: { [key: string]: any } | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public configureScope(callback: (scope: Scope) => void): void {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public run(callback: (hub: Hub) => void): void {\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startTransaction(context: TransactionContext, customSamplingContext?: CustomSamplingContext): Transaction {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public traceHeaders(): { [key: string]: string } {\n    return this._callExtensionMethod<{ [key: string]: string }>('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureSession(endSession: boolean = false): void {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public endSession(): void {\n    const layer = this.getStackTop();\n    const scope = layer && layer.scope;\n    const session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startSession(context?: SessionContext): Session {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const global = getGlobalObject<{ navigator?: { userAgent?: string } }>();\n    const { userAgent } = global.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      const currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n  public shouldSendDefaultPii(): boolean {\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n  private _sendSessionUpdate(): void {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n  private _withClient(callback: (client: Client, scope: Scope | undefined) => void): void {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    __DEBUG_BUILD__ && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n  const carrier = getGlobalObject();\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub: Hub): Hub {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub(): Hub {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry: Carrier): Hub {\n  try {\n    const sentry = getMainCarrier().__SENTRY__;\n    const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier: Carrier): boolean {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier: Carrier): Hub {\n  return getGlobalSingleton<Hub>('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n","/* eslint-disable max-lines */\nimport {\n  Attachment,\n  Breadcrumb,\n  CaptureContext,\n  Context,\n  Contexts,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Primitive,\n  RequestSession,\n  Scope as ScopeInterface,\n  ScopeContext,\n  Session,\n  Severity,\n  SeverityLevel,\n  Span,\n  Transaction,\n  User,\n} from '@sentry/types';\nimport {\n  arrayify,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  isPlainObject,\n  isThenable,\n  logger,\n  SyncPromise,\n} from '@sentry/utils';\n\nimport { updateSession } from './session';\n\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nconst MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nexport class Scope implements ScopeInterface {\n  /** Flag if notifying is happening. */\n  protected _notifyingListeners: boolean;\n\n  /** Callback for client to receive scope changes. */\n  protected _scopeListeners: Array<(scope: Scope) => void>;\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  protected _eventProcessors: EventProcessor[];\n\n  /** Array of breadcrumbs. */\n  protected _breadcrumbs: Breadcrumb[];\n\n  /** User */\n  protected _user: User;\n\n  /** Tags */\n  protected _tags: { [key: string]: Primitive };\n\n  /** Extra */\n  protected _extra: Extras;\n\n  /** Contexts */\n  protected _contexts: Contexts;\n\n  /** Attachments */\n  protected _attachments: Attachment[];\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  protected _sdkProcessingMetadata: { [key: string]: unknown };\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n  protected _level?: Severity | SeverityLevel;\n\n  /** Transaction Name */\n  protected _transactionName?: string;\n\n  /** Span */\n  protected _span?: Span;\n\n  /** Session */\n  protected _session?: Session;\n\n  /** Request Mode Session Status */\n  protected _requestSession?: RequestSession;\n\n  public constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n  public static clone(scope?: Scope): Scope {\n    const newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n  public addScopeListener(callback: (scope: Scope) => void): void {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addEventProcessor(callback: EventProcessor): this {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): this {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getUser(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getRequestSession(): RequestSession | undefined {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setRequestSession(requestSession?: RequestSession): this {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): this {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): this {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): this {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setFingerprint(fingerprint: string[]): this {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setLevel(\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel,\n  ): this {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTransactionName(name?: string): this {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSpan(span?: Span): this {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSpan(): Span | undefined {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransaction(): Transaction | undefined {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSession(session?: Session): this {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSession(): Session | undefined {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public update(captureContext?: CaptureContext): this {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      const updatedScope = (captureContext as <T>(scope: T) => T)(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n      // eslint-disable-next-line no-param-reassign\n      captureContext = captureContext as ScopeContext;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clear(): this {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearBreadcrumbs(): this {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addAttachment(attachment: Attachment): this {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getAttachments(): Attachment[] {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearAttachments(): this {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   */\n  public applyToEvent(event: Event, hint: EventHint = {}): PromiseLike<Event | null> {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n  public setSDKProcessingMetadata(newData: { [key: string]: unknown }): this {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n  protected _notifyEventProcessors(\n    processors: EventProcessor[],\n    event: Event | null,\n    hint: EventHint,\n    index: number = 0,\n  ): PromiseLike<Event | null> {\n    return new SyncPromise<Event | null>((resolve, reject) => {\n      const processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        const result = processor({ ...event }, hint) as Event | null;\n\n        __DEBUG_BUILD__ &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n  protected _notifyScopeListeners(): void {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n  private _applyFingerprint(event: Event): void {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors(): EventProcessor[] {\n  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n  getGlobalEventProcessors().push(callback);\n}\n","import { SerializedSession, Session, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session: Session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n","import { getGlobalObject } from './global';\nimport { isString } from './is';\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem: unknown, keyAttrs?: string[]): string {\n  type SimpleNode = {\n    parentNode: SimpleNode;\n  } | null;\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem as SimpleNode;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const MAX_OUTPUT_LEN = 80;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n\n    // eslint-disable-next-line no-plusplus\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el: unknown, keyAttrs?: string[]): string {\n  const elem = el as {\n    tagName?: string;\n    id?: string;\n    className?: string;\n    getAttribute(key: string): string;\n  };\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  const global = getGlobalObject<Window>();\n  try {\n    return global.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getDomElement<E = any>(selector: string): E | null {\n  const global = getGlobalObject<Window>();\n  if (global.document && global.document.querySelector) {\n    return global.document.querySelector(selector) as unknown as E;\n  }\n  return null;\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { Integration } from '@sentry/types';\n\nimport { isNodeEnv } from './node';\n\n/** Internal */\ninterface SentryGlobal {\n  Sentry?: {\n    Integrations?: Integration[];\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n  };\n}\n\nconst fallbackGlobalObject = {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject<T>(): T & SentryGlobal {\n  return (\n    isNodeEnv()\n      ? global\n      : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals\n      ? window // eslint-disable-line no-restricted-globals\n      : typeof self !== 'undefined'\n      ? self\n      : fallbackGlobalObject\n  ) as T & SentryGlobal;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `getGlobalObject`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton<T>(name: keyof SentryGlobal['__SENTRY__'], creator: () => T, obj?: unknown): T {\n  const global = (obj || getGlobalObject()) as SentryGlobal;\n  const __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n\nimport { PolymorphicEvent, Primitive } from '@sentry/types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record<string, unknown> {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike<any> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isNaN(wat: unknown): boolean {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n","import { WrappedFunction } from '@sentry/types';\n\nimport { getGlobalObject, getGlobalSingleton } from './global';\n\n// TODO: Implement different loggers for different environments\nconst global = getGlobalObject<Window | NodeJS.Global>();\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nexport const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] as const;\nexport type ConsoleLevel = typeof CONSOLE_LEVELS[number];\n\ntype LoggerMethod = (...args: unknown[]) => void;\ntype LoggerConsoleMethods = Record<typeof CONSOLE_LEVELS[number], LoggerMethod>;\n\n/** JSDoc */\ninterface Logger extends LoggerConsoleMethods {\n  disable(): void;\n  enable(): void;\n}\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox<T>(callback: () => T): T {\n  const global = getGlobalObject<Window>();\n\n  if (!('console' in global)) {\n    return callback();\n  }\n\n  const originalConsole = global.console as Console & Record<string, unknown>;\n  const wrappedLevels: Partial<LoggerConsoleMethods> = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] as WrappedFunction).__sentry_original__;\n    if (level in global.console && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] as LoggerConsoleMethods[typeof level];\n      originalConsole[level] = originalWrappedFunc as Console[typeof level];\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level as typeof CONSOLE_LEVELS[number]];\n    });\n  }\n}\n\nfunction makeLogger(): Logger {\n  let enabled = false;\n  const logger: Partial<Logger> = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if (__DEBUG_BUILD__) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args: any[]) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            global.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger as Logger;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger: Logger;\nif (__DEBUG_BUILD__) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { logger };\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Event, Exception, Mechanism, StackFrame } from '@sentry/types';\n\nimport { getGlobalObject } from './global';\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\n\n/**\n * Extended Window interface that allows for Crypto API usage in IE browsers\n */\ninterface MsCryptoWindow extends Window {\n  msCrypto?: Crypto;\n}\n\n/** Many browser now support native uuid v4 generation */\ninterface CryptoWithRandomUUID extends Crypto {\n  randomUUID?(): string;\n}\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4(): string {\n  const global = getGlobalObject() as MsCryptoWindow;\n  const crypto = (global.crypto || global.msCrypto) as CryptoWithRandomUUID;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  const getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] as unknown as string) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c as unknown as number) ^ ((getRandomByte() & 15) >> ((c as unknown as number) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event: Event): Exception | undefined {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event: Event): string {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event: Event, value?: string, type?: string): void {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event: Event, newMechanism?: Partial<Mechanism>): void {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\ninterface SemVer {\n  major?: number;\n  minor?: number;\n  patch?: number;\n  prerelease?: string;\n  buildmetadata?: string;\n}\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input: string): SemVer {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: number = 5): void {\n  const lineno = frame.lineno || 0;\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception as any).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nexport function arrayify<T = unknown>(maybeArray: T | T[]): T[] {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\nimport { isBrowserBundle } from './env';\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv(): boolean {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nexport function dynamicRequire(mod: any, request: string): any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nexport function loadModule<T>(moduleName: string): T | undefined {\n  let mod: T | undefined;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) as T;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\ndeclare const __SENTRY_BROWSER_BUNDLE__: boolean | undefined;\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle(): boolean {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { WrappedFunction } from '@sentry/types';\n\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacementFactory(original) as WrappedFunction;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: { [key: string]: unknown }, name: string, value: unknown): void {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nexport function getOriginalFunction(func: WrappedFunction): WrappedFunction | undefined {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object: { [key: string]: any }): string {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nexport function convertToPlainObject<V extends unknown>(\n  value: V,\n):\n  | {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    }\n  | {\n      [ownProps: string]: unknown;\n      message: string;\n      name: string;\n      stack?: string;\n    }\n  | V {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj: {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    } = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps: { [key: string]: unknown } = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj as Record<string, unknown>)[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nexport function dropUndefinedKeys<T>(inputValue: T): T {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map<unknown, unknown>();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: { [key: string]: any } = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue as T;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: unknown[] = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item: unknown) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue as unknown as T;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat as any).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n","import { isRegExp, isString } from './is';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input: any[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value: string, pattern: RegExp | string): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nexport function escapeStringForRegex(regexString: string): string {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst enum States {\n  /** Pending */\n  PENDING = 0,\n  /** Resolved / OK */\n  RESOLVED = 1,\n  /** Rejected / Error */\n  REJECTED = 2,\n}\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike<void>;\nexport function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise<T> implements PromiseLike<T> {\n  private _state: States = States.PENDING;\n  private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]> = [];\n  private _value: any;\n\n  public constructor(\n    executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,\n  ) {\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n  public then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n  public catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,\n  ): PromiseLike<T | TResult> {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n  public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {\n    return new SyncPromise<TResult>((resolve, reject) => {\n      let val: TResult | any;\n      let isRejected: boolean;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val as unknown as any);\n      });\n    });\n  }\n\n  /** JSDoc */\n  private readonly _resolve = (value?: T | PromiseLike<T> | null) => {\n    this._setResult(States.RESOLVED, value);\n  };\n\n  /** JSDoc */\n  private readonly _reject = (reason?: any) => {\n    this._setResult(States.REJECTED, reason);\n  };\n\n  /** JSDoc */\n  private readonly _setResult = (state: States, value?: T | PromiseLike<T> | any) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value as PromiseLike<T>).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };\n\n  /** JSDoc */\n  private readonly _executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value as unknown as any);\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };\n}\n\nexport { SyncPromise };\n","import { getGlobalObject } from './global';\nimport { dynamicRequire, isNodeEnv } from './node';\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\ninterface TimestampSource {\n  nowSeconds(): number;\n}\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nconst dateTimestampSource: TimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\ninterface Performance {\n  /**\n   * The millisecond timestamp at which measurement began, measured in Unix time.\n   */\n  timeOrigin: number;\n  /**\n   * Returns the current millisecond timestamp, where 0 represents the start of measurement.\n   */\n  now(): number;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance(): Performance | undefined {\n  const { performance } = getGlobalObject<Window>();\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance(): Performance | undefined {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') as { performance: Performance };\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance: Performance | undefined = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource: TimestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport const dateTimestampInSeconds: () => number = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport const timestampInSeconds: () => number = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nexport const timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport const usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport let _browserPerformanceTimeOriginMode: string;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport const browserPerformanceTimeOrigin = ((): number | undefined => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = getGlobalObject<Window>();\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n"],"names":["constructor","Hub","this","getStackTop","scope","client","bindClient","isOlderThan","_version","version","setupIntegrations","getStack","push","getClient","length","pop","withScope","callback","popScope","_stack","captureException","_withClient","exception","originalException","hint","event_id","eventId","message","level","captureMessage","captureEvent","event","type","_lastEventId","addBreadcrumb","beforeBreadcrumb","maxBreadcrumbs","timestamp","consoleSandbox","mergedBreadcrumb","finalBreadcrumb","setUser","user","setTags","tags","setExtras","extras","setTag","key","value","setExtra","extra","setContext","name","context","configureScope","run","makeMain","oldHub","getIntegration","integration","startTransaction","_callExtensionMethod","customSamplingContext","endSession","_sendSessionUpdate","session","closeSession","setSession","startSession","release","environment","userAgent","currentSession","status","updateSession","Boolean","options","sendDefaultPii","captureSession","sentry","extensions","method","args","apply","carrier","__SENTRY__","hub","undefined","setHubOnCarrier","registry","hasHubOnCarrier","getHubFromCarrier","activeDomain","registryHubTopStack","getHubFromActiveDomain","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","_notifyScopeListeners","setRequestSession","requestSession","setFingerprint","fingerprint","setTransactionName","setSpan","span","transaction","update","captureContext","updatedScope","Scope","Object","keys","maxCrumbs","breadcrumb","slice","addAttachment","attachment","applyToEvent","contexts","trace","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","processors","index","processor","resolve","result","logger","then","final","reject","forEach","concat","sid","init","startingTime","started","duration","errors","ignoreDuration","toJSON","Date","toISOString","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","id","email","username","currentElem","elem","height","len","nextStr","_htmlElementAsString","keyAttrs","out","parentNode","reverse","join","el","className","classes","attr","i","tagName","toLowerCase","keyAttrPairs","keyAttrPair","split","allowedAttrs","getAttribute","global","document","location","href","querySelector","selector","isNodeEnv","self","fallbackGlobalObject","objectToString","call","wat","isInstanceOf","Error","isBuiltin","Event","Element","isPlainObject","base","CONSOLE_LEVELS","originalConsole","console","originalWrappedFunc","wrappedLevels","makeLogger","enabled","enable","disable","crypto","randomUUID","replace","getFirstException","values","firstException","mechanism","handled","newMechanism","data","mergedData","addNonEnumerableProperty","Array","isArray","maybeArray","__SENTRY_BROWSER_BUNDLE__","mod","dynamicRequire","module","moduleName","cwd","source","wrapped","markFunctionWrapped","original","defineProperty","obj","writable","configurable","prototype","proto","func","__sentry_original__","object","map","stack","getOwnProperties","target","serializeEventTarget","currentTarget","CustomEvent","newObj","detail","toString","hasOwnProperty","property","extractedProps","sort","maxLength","includedKeys","serialized","_dropUndefinedKeys","inputValue","memoVal","memoizationMap","set","returnValue","item","str","max","input","output","String","delimiter","pattern","test","indexOf","SyncPromise","_","reason","States","executor","_resolve","_reject","e","onfulfilled","onrejected","_handlers","_executeHandlers","val","finally","isRejected","cachedHandlers","handler","nowSeconds","now","performance","timeOrigin","platformPerformance","dateTimestampSource","Math","threshold","timeOriginIsReliable","timeOriginDelta","navigationStartDelta","_browserPerformanceTimeOriginMode","navigationStart","dateNow"],"sourceRoot":""}