{"version":3,"file":"webpack.vendors-84146816.f768e58492eb8038bd85.js","mappings":"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","sources":["webpack://thoughtleaderscentral/../../src/index.ts","webpack://thoughtleaderscentral/../../src/aggregate-errors.ts","webpack://thoughtleaderscentral/../../src/baggage.ts","webpack://thoughtleaderscentral/../../src/browser.ts","webpack://thoughtleaderscentral/../../src/buildPolyfills/_optionalChain.ts","webpack://thoughtleaderscentral/../../src/clientreport.ts","webpack://thoughtleaderscentral/../../src/dsn.ts","webpack://thoughtleaderscentral/../../src/env.ts","webpack://thoughtleaderscentral/../../src/envelope.ts","webpack://thoughtleaderscentral/../../src/error.ts","webpack://thoughtleaderscentral/../../src/vendor/supportsHistory.ts","webpack://thoughtleaderscentral/../../src/instrument.ts","webpack://thoughtleaderscentral/../../src/is.ts","webpack://thoughtleaderscentral/../../src/logger.ts","webpack://thoughtleaderscentral/../../src/misc.ts","webpack://thoughtleaderscentral/../../src/node.ts","webpack://thoughtleaderscentral/../../src/normalize.ts","webpack://thoughtleaderscentral/../../src/memo.ts","webpack://thoughtleaderscentral/../../src/object.ts","webpack://thoughtleaderscentral/../../src/promisebuffer.ts","webpack://thoughtleaderscentral/../../src/ratelimit.ts","webpack://thoughtleaderscentral/../../src/requestdata.ts","webpack://thoughtleaderscentral/../../src/severity.ts","webpack://thoughtleaderscentral/../../src/stacktrace.ts","webpack://thoughtleaderscentral/../../src/string.ts","webpack://thoughtleaderscentral/../../src/supports.ts","webpack://thoughtleaderscentral/../../src/syncpromise.ts","webpack://thoughtleaderscentral/../../src/time.ts","webpack://thoughtleaderscentral/../../src/tracing.ts","webpack://thoughtleaderscentral/../../src/url.ts","webpack://thoughtleaderscentral/../../src/worldwide.ts"],"sourcesContent":["import type {\n  RequestInstrumentationOptions as RequestInstrumentationOptionsT,\n  SpanStatusType as SpanStatusTypeT,\n} from '@sentry-internal/tracing';\nimport {\n  addExtensionMethods as addExtensionMethodsT,\n  Apollo,\n  BROWSER_TRACING_INTEGRATION_ID as BROWSER_TRACING_INTEGRATION_ID_T,\n  BrowserTracing as BrowserTracingT,\n  defaultRequestInstrumentationOptions as defaultRequestInstrumentationOptionsT,\n  Express,\n  extractTraceparentData as extractTraceparentDataT,\n  getActiveTransaction as getActiveTransactionT,\n  GraphQL,\n  hasTracingEnabled as hasTracingEnabledT,\n  IdleTransaction as IdleTransactionT,\n  instrumentOutgoingRequests as instrumentOutgoingRequestsT,\n  Mongo,\n  Mysql,\n  Postgres,\n  Prisma,\n  Span as SpanT,\n  // eslint-disable-next-line deprecation/deprecation\n  SpanStatus as SpanStatusT,\n  spanStatusfromHttpCode as spanStatusfromHttpCodeT,\n  startIdleTransaction as startIdleTransactionT,\n  stripUrlQueryAndFragment as stripUrlQueryAndFragmentT,\n  TRACEPARENT_REGEXP as TRACEPARENT_REGEXP_T,\n  Transaction as TransactionT,\n} from '@sentry-internal/tracing';\n\n// BrowserTracing is already exported as part of `Integrations` below (and for the moment will remain so for\n// backwards compatibility), but that interferes with treeshaking, so we also export it separately\n// here.\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n *\n * import { BrowserTracing } from '@sentry/browser';\n * new BrowserTracing()\n */\nexport const BrowserTracing = BrowserTracingT;\n\n// BrowserTracing is already exported as part of `Integrations` below (and for the moment will remain so for\n// backwards compatibility), but that interferes with treeshaking, so we also export it separately\n// here.\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n *\n * import { BrowserTracing } from '@sentry/browser';\n * new BrowserTracing()\n */\nexport type BrowserTracing = BrowserTracingT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport const addExtensionMethods = addExtensionMethodsT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `getActiveTransaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport const getActiveTransaction = getActiveTransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `extractTraceparentData` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport const extractTraceparentData = extractTraceparentDataT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `spanStatusfromHttpCode` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport const spanStatusfromHttpCode = spanStatusfromHttpCodeT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `SpanStatusType` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport type SpanStatusType = SpanStatusTypeT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Transaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport const Transaction = TransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Transaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport type Transaction = TransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Span` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport const Span = SpanT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Span` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nexport type Span = SpanT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport const BROWSER_TRACING_INTEGRATION_ID = BROWSER_TRACING_INTEGRATION_ID_T;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `defaultRequestInstrumentationOptions` can be imported from `@sentry/browser`, or your framework SDK\n */\nexport const defaultRequestInstrumentationOptions = defaultRequestInstrumentationOptionsT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `hasTracingEnabled` can be imported from `@sentry/utils`\n */\nexport const hasTracingEnabled = hasTracingEnabledT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `stripUrlQueryAndFragment` can be imported from `@sentry/utils`\n */\nexport const stripUrlQueryAndFragment = stripUrlQueryAndFragmentT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `TRACEPARENT_REGEXP` can be imported from `@sentry/utils`\n */\nexport const TRACEPARENT_REGEXP = TRACEPARENT_REGEXP_T;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport const IdleTransaction = IdleTransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport type IdleTransaction = IdleTransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport const instrumentOutgoingRequests = instrumentOutgoingRequestsT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport const startIdleTransaction = startIdleTransactionT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const SpanStatus = SpanStatusT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport type SpanStatus = SpanStatusT;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nexport type RequestInstrumentationOptions = RequestInstrumentationOptionsT;\n\nexport const Integrations = {\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n   *\n   * import { BrowserTracing } from '@sentry/browser';\n   * new BrowserTracing()\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  BrowserTracing: BrowserTracing,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Apollo` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Apollo({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Apollo: Apollo,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Express` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Express({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Express: Express,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `GraphQL` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.GraphQL({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  GraphQL: GraphQL,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Mongo` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Mongo({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Mongo: Mongo,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Mysql` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Mysql({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Mysql: Mysql,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Postgres` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Postgres({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Postgres: Postgres,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Prisma` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Prisma({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Prisma: Prisma,\n};\n\n// Treeshakable guard to remove all code related to tracing\ndeclare const __SENTRY_TRACING__: boolean;\n\n// Guard for tree\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n  // We are patching the global object with our hub extension methods\n  addExtensionMethodsT();\n}\n","import type { Event, EventHint, Exception, ExtendedError, StackParser } from '@sentry/types';\n\nimport { isInstanceOf } from './is';\nimport { truncate } from './string';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nexport function applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  maxValueLimit: number = 250,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): void {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException: Exception | undefined =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException as ExtendedError,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  prevExceptions: Exception[],\n  exception: Exception,\n  exceptionId: number,\n): Exception[] {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    is_exception_group: true,\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception: Exception,\n  source: string,\n  exceptionId: number,\n  parentId: number | undefined,\n): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions: Exception[], maxValueLength: number): Exception[] {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n","import type { DynamicSamplingContext } from '@sentry/types';\n\nimport { isString } from './is';\nimport { logger } from './logger';\n\nexport const BAGGAGE_HEADER_NAME = 'baggage';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nexport const MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nexport function baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader: string | string[] | number | null | undefined | boolean,\n): Partial<DynamicSamplingContext> | undefined {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  }\n\n  // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n  let baggageObject: Readonly<Record<string, string>> = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce<Record<string, string>>((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      return {\n        ...acc,\n        ...currBaggageObject,\n      };\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce<Record<string, string>>((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext as Partial<DynamicSamplingContext>;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nexport function dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext?: Partial<DynamicSamplingContext>,\n): string | undefined {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  }\n\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce<Record<string, string>>(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader: string): Record<string, string> {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce<Record<string, string>>((acc, [key, value]) => {\n      acc[key] = value;\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nfunction objectToBaggageHeader(object: Record<string, string>): string | undefined {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      __DEBUG_BUILD__ &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n","import { isString } from './is';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\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(\n  elem: unknown,\n  options: string[] | { keyAttrs?: string[]; maxStringLength?: number } = {},\n): 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 out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\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 maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\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 = ['aria-label', '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  try {\n    return WINDOW.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  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector) as unknown as E;\n  }\n  return null;\n}\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nimport type { GenericFunction } from './types';\n\n/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nexport function _optionalChain(ops: unknown[]): unknown {\n  let lastAccessLHS: unknown = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    const op = ops[i] as string;\n    const fn = ops[i + 1] as (intermediateValue: unknown) => unknown;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args: unknown[]) => (value as GenericFunction).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     const op = ops[i];\n//     const fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n","import type { ClientReport, ClientReportEnvelope, ClientReportItem } from '@sentry/types';\n\nimport { createEnvelope } from './envelope';\nimport { dateTimestampInSeconds } from './time';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nexport function createClientReportEnvelope(\n  discarded_events: ClientReport['discarded_events'],\n  dsn?: string,\n  timestamp?: number,\n): ClientReportEnvelope {\n  const clientReportItem: ClientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope<ClientReportEnvelope>(dsn ? { dsn } : {}, [clientReportItem]);\n}\n","import type { DsnComponents, DsnLike, DsnProtocol } from '@sentry/types';\n\nimport { logger } from './logger';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol?: string): protocol is DsnProtocol {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nexport function dsnToString(dsn: DsnComponents, withPassword: boolean = false): string {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nexport function dsnFromString(str: string): DsnComponents | undefined {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    // eslint-disable-next-line no-console\n    console.error(`Invalid Sentry Dsn: ${str}`);\n    return undefined;\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() as string;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, publicKey });\n}\n\nfunction dsnFromComponents(components: DsnComponents): DsnComponents {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn: DsnComponents): boolean {\n  if (!__DEBUG_BUILD__) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents: ReadonlyArray<keyof DsnComponents> = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nexport function makeDsn(from: DsnLike): DsnComponents | undefined {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\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 flags 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\nexport type SdkSource = 'npm' | 'cdn' | 'loader';\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\n/**\n * Get source of SDK.\n */\nexport function getSDKSource(): SdkSource {\n  // @ts-ignore __SENTRY_SDK_SOURCE__ is injected by rollup during build process\n  return __SENTRY_SDK_SOURCE__;\n}\n","import type {\n  Attachment,\n  AttachmentItem,\n  BaseEnvelopeHeaders,\n  BaseEnvelopeItemHeaders,\n  DataCategory,\n  DsnComponents,\n  Envelope,\n  EnvelopeItemType,\n  Event,\n  EventEnvelopeHeaders,\n  SdkInfo,\n  SdkMetadata,\n  TextEncoderInternal,\n} from '@sentry/types';\n\nimport { dsnToString } from './dsn';\nimport { normalize } from './normalize';\nimport { dropUndefinedKeys } from './object';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function createEnvelope<E extends Envelope>(headers: E[0], items: E[1] = []): E {\n  return [headers, items] as E;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function addItemToEnvelope<E extends Envelope>(envelope: E, newItem: E[1][number]): E {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] as unknown as E;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nexport function forEachEnvelopeItem<E extends Envelope>(\n  envelope: Envelope,\n  callback: (envelopeItem: E[1][number], envelopeItemType: E[1][number][0]['type']) => boolean | void,\n): boolean {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nexport function envelopeContainsItemType(envelope: Envelope, types: EnvelopeItemType[]): boolean {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8.\n */\nfunction encodeUTF8(input: string, textEncoder?: TextEncoderInternal): Uint8Array {\n  const utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nexport function serializeEnvelope(envelope: Envelope, textEncoder?: TextEncoderInternal): string | Uint8Array {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts: string | Uint8Array[] = JSON.stringify(envHeaders);\n\n  function append(next: string | Uint8Array): void {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload: string;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers: Uint8Array[]): Uint8Array {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\nexport interface TextDecoderInternal {\n  decode(input?: Uint8Array): string;\n}\n\n/**\n * Parses an envelope\n */\nexport function parseEnvelope(\n  env: string | Uint8Array,\n  textEncoder: TextEncoderInternal,\n  textDecoder: TextDecoderInternal,\n): Envelope {\n  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;\n\n  function readBinary(length: number): Uint8Array {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson<T>(): T {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(textDecoder.decode(readBinary(i))) as T;\n  }\n\n  const envelopeHeader = readJson<BaseEnvelopeHeaders>();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items: [any, any][] = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson<BaseEnvelopeItemHeaders>();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates attachment envelope items\n */\nexport function createAttachmentEnvelopeItem(\n  attachment: Attachment,\n  textEncoder?: TextEncoderInternal,\n): AttachmentItem {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP: Record<EnvelopeItemType, DataCategory> = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n  profile: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nexport function envelopeItemTypeToDataCategory(type: EnvelopeItemType): DataCategory {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from from the metadata or an events */\nexport function getSdkMetadataForEnvelopeHeader(metadataOrEvent?: SdkMetadata | Event): SdkInfo | undefined {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nexport function createEventEnvelopeHeaders(\n  event: Event,\n  sdkInfo: SdkInfo | undefined,\n  tunnel: string | undefined,\n  dsn: DsnComponents,\n): EventEnvelopeHeaders {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return {\n    event_id: event.event_id as string,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n","import type { ConsoleLevel } from './logger';\n\n/** An error emitted by Sentry SDKs and related utilities. */\nexport class SentryError extends Error {\n  /** Display name of this error instance. */\n  public name: string;\n\n  public logLevel: ConsoleLevel;\n\n  public constructor(public message: string, logLevel: ConsoleLevel = 'warn') {\n    super(message);\n\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n","// Based on https://github.com/angular/angular.js/pull/13945/files\n// The MIT License\n\n// Copyright (c) 2010-2016 Google, Inc. http://angularjs.org\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport { getGlobalObject } from '../worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory(): boolean {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chrome = (WINDOW as any).chrome;\n  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type {\n  HandlerDataFetch,\n  HandlerDataXhr,\n  SentryWrappedXMLHttpRequest,\n  SentryXhrData,\n  WrappedFunction,\n} from '@sentry/types';\n\nimport { isString } from './is';\nimport type { ConsoleLevel } from './logger';\nimport { CONSOLE_LEVELS, logger, originalConsoleMethods } from './logger';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nimport { getGlobalObject, GLOBAL_OBJ } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\nexport const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v2__';\n\nexport type InstrumentHandlerType =\n  | 'console'\n  | 'dom'\n  | 'fetch'\n  | 'history'\n  | 'sentry'\n  | 'xhr'\n  | 'error'\n  | 'unhandledrejection';\nexport type InstrumentHandlerCallback = (data: any) => void;\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nconst handlers: { [key in InstrumentHandlerType]?: InstrumentHandlerCallback[] } = {};\nconst instrumented: { [key in InstrumentHandlerType]?: boolean } = {};\n\n/** Instruments given API */\nfunction instrument(type: InstrumentHandlerType): void {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      __DEBUG_BUILD__ && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(type: InstrumentHandlerType, callback: InstrumentHandlerCallback): void {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] as InstrumentHandlerCallback[]).push(callback);\n  instrument(type);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nexport function resetInstrumentationHandlers(): void {\n  Object.keys(handlers).forEach(key => {\n    handlers[key as InstrumentHandlerType] = undefined;\n  });\n}\n\n/** JSDoc */\nfunction triggerHandlers(type: InstrumentHandlerType, data: any): void {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (const handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      __DEBUG_BUILD__ &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole(): void {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level: ConsoleLevel): void {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod: () => any): Function {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args: any[]): void {\n        triggerHandlers('console', { args, level });\n\n        const log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch(): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch: () => void): () => void {\n    return function (...args: any[]): void {\n      const { method, url } = parseFetchArgs(args);\n\n      const handlerData: HandlerDataFetch = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        (response: Response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error: Error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\nfunction hasProp<T extends string>(obj: unknown, prop: T): obj is Record<string, string> {\n  return !!obj && typeof obj === 'object' && !!(obj as Record<string, string>)[prop];\n}\n\ntype FetchResource = string | { toString(): string } | { url: string };\n\nfunction getUrlFromResource(resource: FetchResource): string {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request\n */\nexport function parseFetchArgs(fetchArgs: unknown[]): { method: string; url: string } {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs as [FetchResource, object];\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg as FetchResource),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n\n/** JSDoc */\nexport function instrumentXHR(): void {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (!(WINDOW as any).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen: () => void): () => void {\n    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      const url = args[1];\n      const xhrInfo: SentryXhrData = (this[SENTRY_XHR_DATA_KEY] = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n        request_headers: {},\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        this.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler: () => void = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (this.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = this.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args: args as [string, string],\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr: this,\n          } as HandlerDataXhr);\n        }\n      };\n\n      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {\n        fill(this, 'onreadystatechange', function (original: WrappedFunction): Function {\n          return function (this: SentryWrappedXMLHttpRequest, ...readyStateArgs: any[]): void {\n            onreadystatechangeHandler();\n            return original.apply(this, readyStateArgs);\n          };\n        });\n      } else {\n        this.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      fill(this, 'setRequestHeader', function (original: WrappedFunction): Function {\n        return function (this: SentryWrappedXMLHttpRequest, ...setRequestHeaderArgs: unknown[]): void {\n          const [header, value] = setRequestHeaderArgs as [string, string];\n\n          const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return original.apply(this, setRequestHeaderArgs);\n        };\n      });\n\n      return originalOpen.apply(this, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend: () => void): () => void {\n    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];\n      if (sentryXhrData && args[0] !== undefined) {\n        sentryXhrData.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref: string;\n\n/** JSDoc */\nfunction instrumentHistory(): void {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function (this: WindowEventHandlers, ...args: any[]): any {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction: () => void): () => void {\n    return function (this: History, ...args: any[]): void {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nconst debounceDuration = 1000;\nlet debounceTimerID: number | undefined;\nlet lastCapturedEvent: Event | undefined;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous: Event | undefined, current: Event): boolean {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event: Event): boolean {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    const target = event.target as HTMLElement;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler: Function, globalListener: boolean = false): (event: Event) => void {\n  return (event: Event): void => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\ntype AddEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | AddEventListenerOptions,\n) => void;\ntype RemoveEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | EventListenerOptions,\n) => void;\n\ntype InstrumentedElement = Element & {\n  __sentry_instrumentation_handlers__?: {\n    [key in 'click' | 'keypress']?: {\n      handler?: Function;\n      /** The number of custom listeners attached to this element */\n      refCount: number;\n    };\n  };\n};\n\n/** JSDoc */\nexport function instrumentDOM(): void {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target: string) => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = (WINDOW as any)[target] && (WINDOW as any)[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener: AddEventListener): AddEventListener {\n      return function (\n        this: Element,\n        type: string,\n        listener: EventListenerOrEventListenerObject,\n        options?: boolean | AddEventListenerOptions,\n      ): AddEventListener {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const el = this as InstrumentedElement;\n            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener: RemoveEventListener): RemoveEventListener {\n        return function (\n          this: Element,\n          type: string,\n          listener: EventListenerOrEventListenerObject,\n          options?: boolean | EventListenerOptions,\n        ): () => void {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const el = this as InstrumentedElement;\n              const handlers = el.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount--;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler: (typeof WINDOW)['onerror'] | null = null;\n/** JSDoc */\nfunction instrumentError(): void {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg: unknown, url: unknown, line: unknown, column: unknown, error: unknown): boolean {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n\n  WINDOW.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nlet _oldOnUnhandledRejectionHandler: (typeof WINDOW)['onunhandledrejection'] | null = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection(): void {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e: any): boolean {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n\n  WINDOW.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n\nimport type { 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 { GLOBAL_OBJ } from './worldwide';\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<ConsoleLevel, LoggerMethod>;\n\n/** This may be mutated by the console instrumentation. */\nexport const originalConsoleMethods: {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key in ConsoleLevel]?: (...args: any[]) => void;\n} = {};\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  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console as Console;\n  const wrappedFuncs: Partial<LoggerConsoleMethods> = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) as ConsoleLevel[];\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] as LoggerMethod;\n    wrappedFuncs[level] = console[level] as LoggerMethod | undefined;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] as LoggerMethod;\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_OBJ.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\nexport const logger = makeLogger();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Event, Exception, Mechanism, StackFrame } from '@sentry/types';\n\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\nimport { GLOBAL_OBJ } from './worldwide';\n\ninterface CryptoInternal {\n  getRandomValues(array: Uint8Array): Uint8Array;\n  randomUUID?(): string;\n}\n\n/** An interface for common properties on global */\ninterface CryptoGlobal {\n  msCrypto?: CryptoInternal;\n  crypto?: CryptoInternal;\n}\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4(): string {\n  const gbl = GLOBAL_OBJ as typeof GLOBAL_OBJ & CryptoGlobal;\n  const crypto = gbl.crypto || gbl.msCrypto;\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  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.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","import type { Primitive } from '@sentry/types';\n\nimport { isNaN, isSyntheticEvent } from './is';\nimport type { MemoFunc } from './memo';\nimport { memoBuilder } from './memo';\nimport { convertToPlainObject } from './object';\nimport { getFunctionName } from './stacktrace';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we\n// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this\n// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them\n// might be arrays.\ntype ObjOrArray<T> = { [key: string]: T };\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function normalize(input: unknown, depth: number = 100, maxProperties: number = +Infinity): any {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nexport function normalizeToSize<T>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object: { [key: string]: any },\n  // Default Node.js REPL depth\n  depth: number = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize: number = 100 * 1024,\n): T {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key: string,\n  value: unknown,\n  depth: number = +Infinity,\n  maxProperties: number = +Infinity,\n  memo: MemoFunc = memoBuilder(),\n): Primitive | ObjOrArray<unknown> {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))\n  ) {\n    return value as Primitive;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value as ObjOrArray<unknown>)['__sentry_skip_normalization__']) {\n    return value as ObjOrArray<unknown>;\n  }\n\n  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] as number)\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value as unknown & { toJSON?: () => unknown };\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray<unknown>;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value as ObjOrArray<unknown>);\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n// TODO remove this in v7 (this means the method will no longer be exported, under any name)\nexport { visit as walk };\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key: unknown,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value: Exclude<unknown, string | number | boolean | null>,\n): string {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value as { _events: unknown })._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value: unknown): string {\n  const prototype: Prototype | null = Object.getPrototypeOf(value);\n\n  return prototype ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value: string): number {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value: any): number {\n  return utf8Length(JSON.stringify(value));\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport type MemoFunc = [\n  // memoize\n  (obj: any) => boolean,\n  // unmemoize\n  (obj: any) => void,\n];\n\n/**\n * Helper to decycle json objects\n */\nexport function memoBuilder(): MemoFunc {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner: any = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj: any): boolean {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj: any): void {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { 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>(value: V):\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 { SentryError } from './error';\nimport { rejectedSyncPromise, resolvedSyncPromise, SyncPromise } from './syncpromise';\n\nexport interface PromiseBuffer<T> {\n  // exposes the internal array so tests can assert on the state of it.\n  // XXX: this really should not be public api.\n  $: Array<PromiseLike<T>>;\n  add(taskProducer: () => PromiseLike<T>): PromiseLike<T>;\n  drain(timeout?: number): PromiseLike<boolean>;\n}\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nexport function makePromiseBuffer<T>(limit?: number): PromiseBuffer<T> {\n  const buffer: Array<PromiseLike<T>> = [];\n\n  function isReady(): boolean {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task: PromiseLike<T>): PromiseLike<T> {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer: () => PromiseLike<T>): PromiseLike<T> {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise<boolean>((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n","import type { TransportMakeRequestResponse } from '@sentry/types';\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nexport type RateLimits = Record<string, number>;\n\nexport const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nexport function parseRetryAfterHeader(header: string, now: number = Date.now()): number {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nexport function disabledUntil(limits: RateLimits, category: string): number {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nexport function isRateLimited(limits: RateLimits, category: string, now: number = Date.now()): boolean {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nexport function updateRateLimits(\n  limits: RateLimits,\n  { statusCode, headers }: TransportMakeRequestResponse,\n  now: number = Date.now(),\n): RateLimits {\n  const updatedRateLimits: RateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n","// TODO: Remove this file once equivalent integration is used everywhere\n\n/* eslint-disable complexity */\n/**\n * The functions here, which enrich an event with request data, are mostly for use in Node, but are safe for use in a\n * browser context. They live here in `@sentry/utils` rather than in `@sentry/node` so that they can be used in\n * frameworks (like nextjs), which, because of SSR, run the same code in both Node and browser contexts.\n *\n * TODO (v8 / #5257): Remove the note below\n * Note that for now, the tests for this code have to live in `@sentry/node`, since they test both these functions and\n * the backwards-compatibility-preserving wrappers which still live in `handlers.ts` there.\n */\n\n/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type {\n  Event,\n  ExtractedNodeRequestData,\n  PolymorphicRequest,\n  Transaction,\n  TransactionSource,\n} from '@sentry/types';\n\nimport { isPlainObject, isString } from './is';\nimport { normalize } from './normalize';\nimport { stripUrlQueryAndFragment } from './url';\n\nconst DEFAULT_INCLUDES = {\n  ip: false,\n  request: true,\n  transaction: true,\n  user: true,\n};\nconst DEFAULT_REQUEST_INCLUDES = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\nconst DEFAULT_USER_INCLUDES = ['id', 'username', 'email'];\n\ntype InjectedNodeDeps = {\n  cookie: {\n    parse: (cookieStr: string) => Record<string, string>;\n  };\n  url: {\n    parse: (urlStr: string) => {\n      query: string | null;\n    };\n  };\n};\n\n/**\n * Sets parameterized route as transaction name e.g.: `GET /users/:id`\n * Also adds more context data on the transaction from the request\n */\nexport function addRequestDataToTransaction(\n  transaction: Transaction | undefined,\n  req: PolymorphicRequest,\n  deps?: InjectedNodeDeps,\n): void {\n  if (!transaction) return;\n  if (!transaction.metadata.source || transaction.metadata.source === 'url') {\n    // Attempt to grab a parameterized route off of the request\n    transaction.setName(...extractPathForTransaction(req, { path: true, method: true }));\n  }\n  transaction.setData('url', req.originalUrl || req.url);\n  if (req.baseUrl) {\n    transaction.setData('baseUrl', req.baseUrl);\n  }\n  transaction.setData('query', extractQueryParams(req, deps));\n}\n\n/**\n * Extracts a complete and parameterized path from the request object and uses it to construct transaction name.\n * If the parameterized transaction name cannot be extracted, we fall back to the raw URL.\n *\n * Additionally, this function determines and returns the transaction name source\n *\n * eg. GET /mountpoint/user/:id\n *\n * @param req A request object\n * @param options What to include in the transaction name (method, path, or a custom route name to be\n *                used instead of the request's route)\n *\n * @returns A tuple of the fully constructed transaction name [0] and its source [1] (can be either 'route' or 'url')\n */\nexport function extractPathForTransaction(\n  req: PolymorphicRequest,\n  options: { path?: boolean; method?: boolean; customRoute?: string } = {},\n): [string, TransactionSource] {\n  const method = req.method && req.method.toUpperCase();\n\n  let path = '';\n  let source: TransactionSource = 'url';\n\n  // Check to see if there's a parameterized route we can use (as there is in Express)\n  if (options.customRoute || req.route) {\n    path = options.customRoute || `${req.baseUrl || ''}${req.route && req.route.path}`;\n    source = 'route';\n  }\n\n  // Otherwise, just take the original URL\n  else if (req.originalUrl || req.url) {\n    path = stripUrlQueryAndFragment(req.originalUrl || req.url || '');\n  }\n\n  let name = '';\n  if (options.method && method) {\n    name += method;\n  }\n  if (options.method && options.path) {\n    name += ' ';\n  }\n  if (options.path && path) {\n    name += path;\n  }\n\n  return [name, source];\n}\n\ntype TransactionNamingScheme = 'path' | 'methodPath' | 'handler';\n\n/** JSDoc */\nfunction extractTransaction(req: PolymorphicRequest, type: boolean | TransactionNamingScheme): string {\n  switch (type) {\n    case 'path': {\n      return extractPathForTransaction(req, { path: true })[0];\n    }\n    case 'handler': {\n      return (req.route && req.route.stack && req.route.stack[0] && req.route.stack[0].name) || '<anonymous>';\n    }\n    case 'methodPath':\n    default: {\n      return extractPathForTransaction(req, { path: true, method: true })[0];\n    }\n  }\n}\n\n/** JSDoc */\nfunction extractUserData(\n  user: {\n    [key: string]: any;\n  },\n  keys: boolean | string[],\n): { [key: string]: any } {\n  const extractedUser: { [key: string]: any } = {};\n  const attributes = Array.isArray(keys) ? keys : DEFAULT_USER_INCLUDES;\n\n  attributes.forEach(key => {\n    if (user && key in user) {\n      extractedUser[key] = user[key];\n    }\n  });\n\n  return extractedUser;\n}\n\n/**\n * Normalize data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param options.include An optional array of keys to include in the normalized data. Defaults to\n * DEFAULT_REQUEST_INCLUDES if not provided.\n * @param options.deps Injected, platform-specific dependencies\n * @returns An object containing normalized request data\n */\nexport function extractRequestData(\n  req: PolymorphicRequest,\n  options?: {\n    include?: string[];\n    deps?: InjectedNodeDeps;\n  },\n): ExtractedNodeRequestData {\n  const { include = DEFAULT_REQUEST_INCLUDES, deps } = options || {};\n  const requestData: { [key: string]: any } = {};\n\n  // headers:\n  //   node, express, koa, nextjs: req.headers\n  const headers = (req.headers || {}) as {\n    host?: string;\n    cookie?: string;\n  };\n  // method:\n  //   node, express, koa, nextjs: req.method\n  const method = req.method;\n  // host:\n  //   express: req.hostname in > 4 and req.host in < 4\n  //   koa: req.host\n  //   node, nextjs: req.headers.host\n  const host = req.hostname || req.host || headers.host || '<no host>';\n  // protocol:\n  //   node, nextjs: <n/a>\n  //   express, koa: req.protocol\n  const protocol = req.protocol === 'https' || (req.socket && req.socket.encrypted) ? 'https' : 'http';\n  // url (including path and query string):\n  //   node, express: req.originalUrl\n  //   koa, nextjs: req.url\n  const originalUrl = req.originalUrl || req.url || '';\n  // absolute url\n  const absoluteUrl = `${protocol}://${host}${originalUrl}`;\n  include.forEach(key => {\n    switch (key) {\n      case 'headers': {\n        requestData.headers = headers;\n        break;\n      }\n      case 'method': {\n        requestData.method = method;\n        break;\n      }\n      case 'url': {\n        requestData.url = absoluteUrl;\n        break;\n      }\n      case 'cookies': {\n        // cookies:\n        //   node, express, koa: req.headers.cookie\n        //   vercel, sails.js, express (w/ cookie middleware), nextjs: req.cookies\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        requestData.cookies =\n          // TODO (v8 / #5257): We're only sending the empty object for backwards compatibility, so the last bit can\n          // come off in v8\n          req.cookies || (headers.cookie && deps && deps.cookie && deps.cookie.parse(headers.cookie)) || {};\n        break;\n      }\n      case 'query_string': {\n        // query string:\n        //   node: req.url (raw)\n        //   express, koa, nextjs: req.query\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        requestData.query_string = extractQueryParams(req, deps);\n        break;\n      }\n      case 'data': {\n        if (method === 'GET' || method === 'HEAD') {\n          break;\n        }\n        // body data:\n        //   express, koa, nextjs: req.body\n        //\n        //   when using node by itself, you have to read the incoming stream(see\n        //   https://nodejs.dev/learn/get-http-request-body-data-using-nodejs); if a user is doing that, we can't know\n        //   where they're going to store the final result, so they'll have to capture this data themselves\n        if (req.body !== undefined) {\n          requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));\n        }\n        break;\n      }\n      default: {\n        if ({}.hasOwnProperty.call(req, key)) {\n          requestData[key] = (req as { [key: string]: any })[key];\n        }\n      }\n    }\n  });\n\n  return requestData;\n}\n\n/**\n * Options deciding what parts of the request to use when enhancing an event\n */\nexport interface AddRequestDataToEventOptions {\n  /** Flags controlling whether each type of data should be added to the event */\n  include?: {\n    ip?: boolean;\n    request?: boolean | string[];\n    transaction?: boolean | TransactionNamingScheme;\n    user?: boolean | string[];\n  };\n\n  /** Injected platform-specific dependencies */\n  deps?: {\n    cookie: {\n      parse: (cookieStr: string) => Record<string, string>;\n    };\n    url: {\n      parse: (urlStr: string) => {\n        query: string | null;\n      };\n    };\n  };\n}\n\n/**\n * Add data from the given request to the given event\n *\n * @param event The event to which the request data will be added\n * @param req Request object\n * @param options.include Flags to control what data is included\n * @param options.deps Injected platform-specific dependencies\n * @hidden\n */\nexport function addRequestDataToEvent(\n  event: Event,\n  req: PolymorphicRequest,\n  options?: AddRequestDataToEventOptions,\n): Event {\n  const include = {\n    ...DEFAULT_INCLUDES,\n    ...(options && options.include),\n  };\n\n  if (include.request) {\n    const extractedRequestData = Array.isArray(include.request)\n      ? extractRequestData(req, { include: include.request, deps: options && options.deps })\n      : extractRequestData(req, { deps: options && options.deps });\n\n    event.request = {\n      ...event.request,\n      ...extractedRequestData,\n    };\n  }\n\n  if (include.user) {\n    const extractedUser = req.user && isPlainObject(req.user) ? extractUserData(req.user, include.user) : {};\n\n    if (Object.keys(extractedUser).length) {\n      event.user = {\n        ...event.user,\n        ...extractedUser,\n      };\n    }\n  }\n\n  // client ip:\n  //   node, nextjs: req.socket.remoteAddress\n  //   express, koa: req.ip\n  if (include.ip) {\n    const ip = req.ip || (req.socket && req.socket.remoteAddress);\n    if (ip) {\n      event.user = {\n        ...event.user,\n        ip_address: ip,\n      };\n    }\n  }\n\n  if (include.transaction && !event.transaction) {\n    // TODO do we even need this anymore?\n    // TODO make this work for nextjs\n    event.transaction = extractTransaction(req, include.transaction);\n  }\n\n  return event;\n}\n\nfunction extractQueryParams(\n  req: PolymorphicRequest,\n  deps?: InjectedNodeDeps,\n): string | Record<string, unknown> | undefined {\n  // url (including path and query string):\n  //   node, express: req.originalUrl\n  //   koa, nextjs: req.url\n  let originalUrl = req.originalUrl || req.url || '';\n\n  if (!originalUrl) {\n    return;\n  }\n\n  // The `URL` constructor can't handle internal URLs of the form `/some/path/here`, so stick a dummy protocol and\n  // hostname on the beginning. Since the point here is just to grab the query string, it doesn't matter what we use.\n  if (originalUrl.startsWith('/')) {\n    originalUrl = `http://dogs.are.great${originalUrl}`;\n  }\n\n  return (\n    req.query ||\n    (typeof URL !== undefined && new URL(originalUrl).search.replace('?', '')) ||\n    // In Node 8, `URL` isn't in the global scope, so we have to use the built-in module from Node\n    (deps && deps.url && deps.url.parse(originalUrl).query) ||\n    undefined\n  );\n}\n","/* eslint-disable deprecation/deprecation */\nimport type { Severity, SeverityLevel } from '@sentry/types';\n\n// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nexport const validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nexport function severityFromString(level: Severity | SeverityLevel | string): Severity {\n  return severityLevelFromString(level) as Severity;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nexport function severityLevelFromString(level: SeverityLevel | string): SeverityLevel {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') as SeverityLevel;\n}\n","import type { StackFrame, StackLineParser, StackParser } from '@sentry/types';\n\nimport type { GetModuleFn } from './node-stack-trace';\nimport { node } from './node-stack-trace';\n\nconst STACKTRACE_FRAME_LIMIT = 50;\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nexport function createStackParser(...parsers: StackLineParser[]): StackParser {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack: string, skipFirst: number = 0): StackFrame[] => {\n    const frames: StackFrame[] = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirst; i < lines.length; i++) {\n      const line = lines[i];\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nexport function stackParserFromStackParserOptions(stackParser: StackParser | StackLineParser[]): StackParser {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: ReadonlyArray<StackFrame>): StackFrame[] {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the hub itself, making it:\n    //\n    //   Sentry.captureException()\n    //   getCurrentHub().captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || localStack[localStack.length - 1].filename,\n    function: frame.function || '?',\n  }));\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn: unknown): string {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nexport function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {\n  return [90, node(getModule)];\n}\n","import { isRegExp, isString } from './is';\n\nexport { escapeStringForRegex } from './vendor/escapeStringForRegex';\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.slice(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 given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nexport function isMatchingPattern(\n  value: string,\n  pattern: RegExp | string,\n  requireExactStringMatch: boolean = false,\n): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nexport function stringMatchesSomePattern(\n  testString: string,\n  patterns: Array<string | RegExp> = [],\n  requireExactStringMatch: boolean = false,\n): boolean {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n","import { logger } from './logger';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\nexport { supportsHistory } from './vendor/supportsHistory';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent(): boolean {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError(): boolean {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException(): boolean {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch(): boolean {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFetch(func: Function): boolean {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch(): boolean {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement as unknown) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      __DEBUG_BUILD__ &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver(): boolean {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy(): boolean {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' as ReferrerPolicy,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\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;\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    this._state = States.PENDING;\n    this._handlers = [];\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 { dynamicRequire, isNodeEnv } from './node';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\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 } = 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/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\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 } = 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","import type { DynamicSamplingContext, PropagationContext, TraceparentData } from '@sentry/types';\n\nimport { baggageHeaderToDynamicSamplingContext } from './baggage';\nimport { uuid4 } from './misc';\n\nexport const TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nexport function extractTraceparentData(traceparent?: string): TraceparentData | undefined {\n  if (!traceparent) {\n    return undefined;\n  }\n\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (!matches) {\n    return undefined;\n  }\n\n  let parentSampled: boolean | undefined;\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled,\n    parentSpanId: matches[2],\n  };\n}\n\n/**\n * Create tracing context from incoming headers.\n */\nexport function tracingContextFromHeaders(\n  sentryTrace: Parameters<typeof extractTraceparentData>[0],\n  baggage: Parameters<typeof baggageHeaderToDynamicSamplingContext>[0],\n): {\n  traceparentData: ReturnType<typeof extractTraceparentData>;\n  dynamicSamplingContext: ReturnType<typeof baggageHeaderToDynamicSamplingContext>;\n  propagationContext: PropagationContext;\n} {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData || {};\n\n  const propagationContext: PropagationContext = {\n    traceId: traceId || uuid4(),\n    spanId: uuid4().substring(16),\n    sampled: parentSampled,\n  };\n\n  if (parentSpanId) {\n    propagationContext.parentSpanId = parentSpanId;\n  }\n\n  if (dynamicSamplingContext) {\n    propagationContext.dsc = dynamicSamplingContext as DynamicSamplingContext;\n  }\n\n  return {\n    traceparentData,\n    dynamicSamplingContext,\n    propagationContext,\n  };\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nexport function generateSentryTraceHeader(\n  traceId: string = uuid4(),\n  spanId: string = uuid4().substring(16),\n  sampled?: boolean,\n): string {\n  let sampledString = '';\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n  return `${traceId}-${spanId}${sampledString}`;\n}\n","type PartialURL = {\n  host?: string;\n  path?: string;\n  protocol?: string;\n  relative?: string;\n  search?: string;\n  hash?: string;\n};\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url: string): PartialURL {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    search: query,\n    hash: fragment,\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath: string): string {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nexport function getNumberOfUrlSegments(url: string): number {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span description\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nexport function getSanitizedUrlString(url: PartialURL): string {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    (host &&\n      host\n        // Always filter out authority\n        .replace(/^.*@/, '[filtered]:[filtered]@')\n        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n        .replace(':80', '')\n        .replace(':443', '')) ||\n    '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\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 * Note: This file was originally called `global.ts`, but was changed to unblock users which might be doing\n * string replaces with bundlers like Vite for `global` (would break imports that rely on importing from utils/src/global).\n *\n * Why worldwide?\n *\n * Why not?\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Integration } from '@sentry/types';\n\nimport type { SdkSource } from './env';\n\n/** Internal global with common properties and Sentry extensions  */\nexport interface InternalGlobal {\n  navigator?: { userAgent?: string };\n  console: Console;\n  Sentry?: {\n    Integrations?: Integration[];\n  };\n  onerror?: {\n    (msg: unknown, url: unknown, line: unknown, column: unknown, error: unknown): boolean;\n    __SENTRY_INSTRUMENTED__?: true;\n    __SENTRY_LOADER__?: true;\n  };\n  onunhandledrejection?: {\n    (event: unknown): boolean;\n    __SENTRY_INSTRUMENTED__?: true;\n    __SENTRY_LOADER__?: true;\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  SENTRY_SDK_SOURCE?: SdkSource;\n  /**\n   * Debug IDs are indirectly injected by Sentry CLI or bundler plugins to directly reference a particular source map\n   * for resolving of a source file. The injected code will place an entry into the record for each loaded bundle/JS\n   * file.\n   */\n  _sentryDebugIds?: Record<string, string>;\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n    extensions?: {\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   * Raw module metadata that is injected by bundler plugins.\n   *\n   * Keys are `error.stack` strings, values are the metadata.\n   */\n  _sentryModuleMetadata?: Record<string, any>;\n}\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj: { Math?: Math }): any | undefined {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nexport const GLOBAL_OBJ: InternalGlobal =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function (this: any) {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nexport function getGlobalObject<T>(): T & InternalGlobal {\n  return GLOBAL_OBJ as T & InternalGlobal;\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 `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton<T>(name: keyof InternalGlobal['__SENTRY__'], creator: () => T, obj?: unknown): T {\n  const gbl = (obj || GLOBAL_OBJ) as InternalGlobal;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n"],"names":["BrowserTracing","BrowserTracing$1","Apollo","Express","GraphQL","Mongo","Mysql","Postgres","Prisma","__SENTRY_TRACING__","addExtensionMethods$1","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","key","limit","event","hint","exception","values","isInstanceOf","originalException","Error","length","undefined","exceptions","maxValueLength","aggregateExceptionsFromError","map","value","truncate","error","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","Array","isArray","errors","forEach","childError","i","mechanism","type","handled","is_exception_group","exception_id","source","parentId","parent_id","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","isString","baggageObject","reduce","acc","curr","baggageHeaderToObject","dynamicSamplingContext","Object","entries","match","slice","keys","dynamicSamplingContextToSentryBaggageHeader","object","objectKey","objectValue","currentIndex","baggageEntry","encodeURIComponent","newBaggageHeader","objectToBaggageHeader","dscKey","dscValue","split","keyOrValue","decodeURIComponent","trim","WINDOW","getGlobalObject","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","options","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","push","parentNode","reverse","join","_oO","el","className","classes","attr","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","id","allowedAttrs","getLocationHref","document","location","href","oO","getDomElement","selector","querySelector","_optionalChain","ops","lastAccessLHS","op","fn","args","call","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","dateTimestampInSeconds","createEnvelope","DSN_REGEX","dsnToString","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","exec","console","lastPath","pop","projectMatch","dsnFromString","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","normalize","buffers","totalLength","buf","merged","offset","buffer","set","concatBuffers","createAttachmentEnvelopeItem","attachment","data","dropUndefinedKeys","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","profile","replay_event","replay_recording","check_in","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","name","version","createEventEnvelopeHeaders","sdkInfo","tunnel","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","SentryError","constructor","message","logLevel","prototype","setPrototypeOf","SENTRY_XHR_DATA_KEY","handlers","instrumented","addInstrumentationHandler","CONSOLE_LEVELS","level","GLOBAL_OBJ","fill","originalConsoleMethod","originalConsoleMethods","triggerHandlers","log","apply","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","addEventListener","target","proto","hasOwnProperty","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","handler","originalRemoveEventListener","instrumentDOM","XMLHttpRequest","xhrproto","originalOpen","url","xhrInfo","method","toUpperCase","request_headers","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","endTimestamp","now","startTimestamp","xhr","onreadystatechange","original","readyStateArgs","setRequestHeaderArgs","header","originalSend","sentryXhrData","body","instrumentXHR","supportsNativeFetch","originalFetch","fetchArgs","getUrlFromResource","hasProp","String","arg","parseFetchArgs","handlerData","fetchData","then","response","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","lastHref","to","instrumentHistory","_oldOnErrorHandler","onerror","msg","line","column","__SENTRY_LOADER__","arguments","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","onunhandledrejection","instrument","obj","prop","resource","toString","debounceDuration","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","current","shouldShortcircuitPreviousDebounce","global","clearTimeout","setTimeout","objectToString","isError","wat","isBuiltin","isErrorEvent","isDOMError","isDOMException","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","isNaN","base","_e","consoleSandbox","wrappedFuncs","wrappedLevels","logger","enabled","enable","disable","makeLogger","uuid4","gbl","crypto","msCrypto","randomUUID","replace","getRandomByte","getRandomValues","Math","random","c","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","addNonEnumerableProperty","err","arrayify","maybeArray","isNodeEnv","process","dynamicRequire","mod","request","require","loadModule","moduleName","module","cwd","depth","maxProperties","visit","ERROR","normalizeToSize","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","has","add","delete","splice","memoBuilder","memoize","unmemoize","includes","stringified","_events","window","getFunctionName","objName","getPrototypeOf","getConstructorName","test","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","numAdded","visitable","convertToPlainObject","visitKey","visitValue","replacementFactory","wrapped","markFunctionWrapped","_Oo","defineProperty","writable","configurable","getOriginalFunction","func","__sentry_original__","urlEncode","stack","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","get","returnValue","makePromiseBuffer","remove","task","indexOf","$","taskProducer","rejectedSyncPromise","drain","timeout","SyncPromise","resolve","reject","counter","capturedSetTimeout","resolvedSyncPromise","DEFAULT_RETRY_AFTER","isRateLimited","limits","category","all","disabledUntil","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","headerDelay","parseInt","delay","headerDate","parse","parseRetryAfterHeader","extractPathForTransaction","req","customRoute","route","baseUrl","originalUrl","stripUrlQueryAndFragment","validSeverityLevels","severityLevelFromString","STACKTRACE_FRAME_LIMIT","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","frames","lines","cleanedLine","frame","localStack","function","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","defaultFunctionName","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","isMatchingPattern","supportsFetch","Headers","Request","Response","isNativeFetch","fetch","result","doc","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","States","reason","_","executor","__init","__init2","__init3","__init4","_state","PENDING","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","timestampInSeconds","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","TRACEPARENT_REGEXP","RegExp","tracingContextFromHeaders","sentryTrace","baggage","traceparentData","traceparent","matches","parentSampled","traceId","parentSpanId","extractTraceparentData","propagationContext","spanId","substring","sampled","dsc","generateSentryTraceHeader","sampledString","parseUrl","query","fragment","search","hash","relative","urlPath","getNumberOfUrlSegments","s","isGlobalObj","globalThis","self","getGlobalSingleton","creator","__SENTRY__"],"sourceRoot":""}