{"version":3,"sources":["webpack:///../../../src/utils.ts?643f","../../src/promisebuffer.ts","../../src/ratelimit.ts","../../src/transports/base.ts","../../src/envelope.ts","../../src/baseclient.ts","../../src/env.ts","../../src/browser.ts","../../src/errors.ts","../../src/normalize.ts","../../src/memo.ts","../../src/baggage.ts","../../src/browser/types.ts","../../src/browser/web-vitals/lib/bindReporter.ts","../../src/browser/web-vitals/lib/getNavigationEntry.ts","../../src/browser/web-vitals/lib/getActivationStart.ts","../../src/browser/web-vitals/lib/initMetric.ts","../../src/browser/web-vitals/lib/generateUniqueID.ts","../../src/browser/web-vitals/lib/observe.ts","../../src/browser/web-vitals/lib/onHidden.ts","../../src/browser/web-vitals/lib/getVisibilityWatcher.ts","../../src/browser/web-vitals/getLCP.ts","../../src/browser/metrics/utils.ts","../../src/browser/metrics/index.ts","../../src/browser/web-vitals/getCLS.ts","../../src/browser/web-vitals/getFID.ts","../../src/browser/request.ts","../../src/browser/browsertracing.ts","../../src/browser/router.ts","../../src/browser/backgroundtab.ts","webpack:///../../../src/index.ts?5f3d","../../src/instrument.ts","../../src/buildPolyfills/_optionalChain.ts","../../src/dsn.ts","../../src/hub.ts","../../src/is.ts","../../src/url.ts","../../src/object.ts","../../src/worldwide.ts","../../src/integrations/functiontostring.ts","../../src/integrations/inboundfilters.ts","../../src/exports.ts","../../src/eventbuilder.ts","webpack:///../../../src/helpers.ts?2d75","../../src/severity.ts","../../src/integrations/breadcrumbs.ts","webpack:///../../../src/client.ts?a2de","../../src/clientreport.ts","../../src/stack-parsers.ts","../../src/integrations/trycatch.ts","../../src/integrations/globalhandlers.ts","../../src/integrations/linkederrors.ts","../../src/integrations/dedupe.ts","../../src/integrations/httpcontext.ts","../../src/transports/utils.ts","../../src/transports/fetch.ts","../../src/transports/xhr.ts","webpack:///../../../src/sdk.ts?f3a3","../../src/sdk.ts","../../src/session.ts","../../src/time.ts","../../src/scope.ts","../../src/node.ts","../../src/span.ts","../../src/idletransaction.ts","../../src/error.ts","../../src/hubextensions.ts","../../src/string.ts","../../src/transaction.ts","../../src/misc.ts","../../src/buildPolyfills/_nullishCoalesce.ts","../../src/api.ts","../../src/syncpromise.ts","../../src/integration.ts","../../src/stacktrace.ts","../../src/supports.ts","../../src/logger.ts","../../src/tracing.ts","webpack:///../../src/version.ts?281e"],"names":["options","scope","time","remove","task","buffer","splice","indexOf","$","add","taskProducer","undefined","limit","length","push","drain","timeout","counter","resolve","forEach","clearTimeout","capturedSetTimeout","isNaN","headerDelay","headerDate","now","limits","category","all","disabledUntil","rateLimitHeader","updatedRateLimits","parseRetryAfterHeader","retryAfterHeader","send","envelope","isRateLimited","rateLimits","envelopeItemDataCategory","recordDroppedEvent","filteredEnvelopeItems","item","reason","then","flush","this","_options","dsn","_dsn","_transport","transport","bind","url","level","eventId","result","breadcrumbs","event","map","data","user","contexts","extra","finalEvent","event_id","sentryError","logLevel","logger","prepared","beforeSendProcessor","beforeSendResult","_validateBeforeSendResult","beforeSendProcessorName","processedEvent","isTransaction","session","transactionInfo","transaction","transaction_info","source","changes","__sentry__","originalException","value","__SENTRY_BROWSER_BUNDLE__","currentElem","height","nextStr","_htmlElementAsString","keyAttrs","out","len","parentNode","reverse","join","el","elem","tagName","toLowerCase","keyAttrPairs","id","className","classes","split","i","allowedAttrs","key","attr","getAttribute","WINDOW","document","location","href","querySelector","selector","errorCallback","activeTransaction","setStatus","status","visit","input","depth","maxProperties","jsonSize","normalized","maxSize","normalizeToSize","object","stringified","startsWith","replace","memoize","valueWithToJSON","toJSON","jsonValue","memo","Object","prototype","hasOwnProperty","call","visitable","visitKey","numAdded","visitValue","unmemoize","stringifyValue","global","window","encodeURI","utf8Length","JSON","stringify","obj","hasWeakSet","inner","has","delete","headers","items","callback","envelopeItem","envelopeItemType","encodeUTF8","encode","append","next","parts","textEncoder","e","buffers","f","merged","concatBuffers","sessions","attachment","client_report","user_report","ITEM_TYPE_TO_DATA_CATEGORY_MAP","type","keys","entries","reduce","newBaggageHeader","baggageHeader","objectToBaggageHeader","baggageHeaderToObject","metric","forceReport","reportAllChanges","delta","prevValue","__WEB_VITALS_POLYFILL__","entryType","startTime","navigationEntry","Math","max","performance","getEntriesByType","navEntry","navigationType","prerendering","name","rating","PerformanceObserver","supportedEntryTypes","includes","list","getEntries","po","observe","visibilityState","cb","once","removeEventListener","onHiddenOrPageHide","addEventListener","firstHiddenTime","Infinity","timeStamp","isFinite","startTimestamp","startChild","getBrowserPerformanceAPI","_trackCLS","entry","hadRecentInput","sessionValue","sessionEntries","report","bindReporter","onReport","opts","handleEntries","takeRecords","_measurements","_clsEntry","_trackLCP","lastEntry","visibilityWatcher","reportedMetricIDs","disconnect","stopListening","_trackFID","processingStart","performanceEntries","slice","_performanceCursor","op","timeOrigin","_addPerformanceNavigationTiming","_startChild","description","endTimestamp","_addRequest","measureEndTimestamp","measureStartTimestamp","initiatorType","transferSize","encodedBodySize","decodedBodySize","resourceName","navigator","connection","effectiveType","setTag","isMeasurementValue","rtt","deviceMemory","hardwareConcurrency","String","_trackNavigator","responseStartTimestamp","unit","requestStartTimestamp","normalizedValue","fidMark","cls","setMeasurement","_lcpEntry","element","trim","size","sources","_tagMetricInfo","start","end","traceFetch","traceXHR","tracingOrigins","DEFAULT_TRACE_PROPAGATION_TARGETS","tracePropagationTargets","defaultRequestInstrumentationOptions","handlerData","spanId","span","response","setHttpStatus","finish","spans","fetchData","__span","args","shouldAttachHeaders","newHeaders","sentryTraceHeader","sentryBaggageHeader","BAGGAGE_HEADER_NAME","Array","isArray","existingBaggageHeader","newBaggageHeaders","baggage","addTracingHeadersToFetchRequest","metadata","propagations","fetchCallback","shouldCreateSpan","shouldAttachHeadersWithTargets","xhr","status_code","method","__sentry_xhr_span_id__","setRequestHeader","__sentry_xhr__","xhrCallback","idleTimeout","finalTimeout","heartbeatInterval","markBackgroundTransactions","routingInstrumentation","startTransactionOnPageLoad","customStartTransaction","pathname","startTransactionOnLocationChange","from","startingUrl","to","_experiments","mark","startTrackingWebVitals","_metricOptions","_reportAllChanges","hidden","statusType","baggageObject","match","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","acc","dynamicSamplingContext","metaTag","__SENTRY_TRACING__","instrument","instrumented","console","triggerHandlers","originalConsoleMethod","apply","instrumentConsole","globalDOMEventHandler","proto","handlerForType","handler","originalAddEventListener","refCount","listener","instrumentDOM","__sentry_own_request__","readyState","xhrInfo","Date","onreadystatechange","onreadystatechangeHandler","original","readyStateArgs","originalOpen","body","originalSend","instrumentXHR","getFetchMethod","getFetchUrl","originalFetch","instrumentFetch","historyReplacementFunction","originalHistoryFunction","lastHref","onpopstate","oldOnPopState","instrumentHistory","_oldOnErrorHandler","onerror","msg","column","error","line","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","handlers","fetchArgs","toUpperCase","shouldShortcircuitPreviousDebounce","previous","current","target","shouldSkipDOMEvent","isContentEditable","makeDOMEventHandler","lastCapturedEvent","debounceTimerID","globalListener","setTimeout","ops","lastAccessLHS","fn","dsnFromComponents","components","protocol","publicKey","pass","host","port","path","projectId","pop","projectMatch","component","isValidProtocol","parseInt","validateDsn","getStackTop","client","bindClient","captureException","captureMessage","captureEvent","extensions","hub","setHubOnCarrier","registry","oldHub","hasHubOnCarrier","getHubFromCarrier","isOlderThan","Hub","activeDomain","registryHubTopStack","getHubFromActiveDomain","carrier","__SENTRY__","objectToString","wat","isInstanceOf","Error","isBuiltin","Event","Element","Boolean","isPlainObject","base","relative","query","fragment","wrapped","markFunctionWrapped","defineProperty","writable","configurable","addNonEnumerableProperty","func","__sentry_original__","message","stack","serializeEventTarget","currentTarget","CustomEvent","newObj","detail","getOwnProperties","property","extractedProps","sort","maxLength","serialized","includedKeys","_dropUndefinedKeys","inputValue","memoVal","memoizationMap","set","returnValue","isGlobalObj","GLOBAL_OBJ","ignoreInternal","exception","values","_isSentryError","ignoreErrors","_getPossibleEventMessages","some","_isIgnoredError","denyUrls","_isDeniedUrl","allowUrls","_isAllowedUrl","internalOptions","_getEventFilterUrl","frames","stacktrace","frame","filename","_getLastValidUrl","ex","extractMessage","exceptionFromError","stackParser","framesToPop","reactMinifiedRegexp","test","popSize","hint","eventFromError","eventFromString","syntheticException","attachStacktrace","domException","tags","__serialized__","eventFromPlainObject","isUnhandledRejection","synthetic","ignoreOnError","wrapper","before","wrappedArguments","ignoreNextOnError","addEventProcessor","mechanism","sentryWrapped","descriptor","get","dom","fetch","history","sentry","_innerDomBreadcrumb","_consoleBreadcrumb","severityLevelFromString","breadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","parsedFrom","parsedLoc","parsedTo","_metadata","sdk","packages","version","sendClientReports","breadcrumbIntegration","createFrame","function","in_app","lineno","colno","subMatch","isSafariExtension","isSafariWebExtension","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","wrap","originalCallback","handled","_wrapRAF","_wrapXHR","xmlHttpRequestProps","prop","originalFunction","wrapOptions","_wrapEventTarget","handleEvent","_installGlobalOnErrorHandler","groups","_enhanceEventWithInitialFrame","_installGlobalOnUnhandledRejectionHandler","ev0sf","addMechanismAndCapture","getHubAndOptions","_key","DEFAULT_KEY","_limit","_walkErrorTree","parser","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","currentException","_isSameExceptionEvent","currentFrames","previousFrames","currentFingerprint","previousFingerprint","_getExceptionFromEvent","_getFramesFromEvent","cachedFetchImpl","createElement","sandbox","head","appendChild","contentWindow","fetchImpl","removeChild","makeRequest","request","referrerPolicy","keepalive","nativeFetch","requestOptions","clearCachedFetchImplementation","reject","statusCode","getResponseHeader","open","header","startSessionOnHub","startSession","captureSession","startSessionTracking","defaultIntegrations","release","SENTRY_RELEASE","autoSessionTracking","integrations","sid","init","timestamp","startingTime","started","duration","errors","ignoreDuration","toISOString","did","attrs","environment","ip_address","ipAddress","user_agent","userAgent","context","updateSession","email","username","nowSeconds","timeOriginIsReliable","timeOriginDelta","navigationStartDelta","navigationStart","dateNow","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","getGlobalEventProcessors","mod","require","dynamicRequire","module","moduleName","_maxlen","maxlen","spanContext","traceId","parentSpanId","sampled","instrumenter","httpStatus","_onScope","clearActiveTransaction","_idleHub","configureScope","setSpan","setPrototypeOf","traceHeaders","toTraceparent","sample","setMetadata","sampleRate","Number","tracesSampler","samplingContext","parentSampled","tracesSampleRate","rate","isValidSampleRate","random","_startTransaction","configInstrumenter","transactionInstrumenter","transactionContext","initSpanRecorder","startTransaction","_addTracingExtensions","mongodb","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","_autoloadDatabaseIntegrations","str","lineLength","newLine","output","delimiter","pattern","requireExactStringMatch","patterns","spanMetadata","incomingDynamicSamplingContext","crypto","randomUUID","getFirstException","firstException","newMechanism","mergedData","maybeArray","lhs","rhsFn","getBaseApiEndpoint","_getIngestEndpoint","_encodedAuth","sentry_key","sentry_version","tunnel","encodedOptions","SyncPromise","executor","_resolve","_reject","onfulfilled","onrejected","isRejected","val","onfinally","integration","isDefaultInstance","existingInstance","currentInstance","integrationsByName","userIntegrations","debugIndex","finalIntegrations","debugInstance","integrationIndex","installedIntegrations","setupOnce","stripSentryFramesAndReverse","createStackParser","firstFrameFunction","localStack","lastFrameFunction","defaultFunctionName","Headers","Request","Response","toString","supportsFetch","isNativeFetch","doc","isChromePackagedApp","hasHistoryApi","CONSOLE_LEVELS","originalConsole","originalWrappedFunc","wrappedLevels","makeLogger","enable","enabled","disable","consoleSandbox","traceparent","matches","debug","warn","update","initialScope"],"mappings":"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","file":"static/js/sentry-lib.220ce731.chunk.js","sourcesContent":["import { getCurrentHub, Hub } from '@sentry/core';\nimport { Options, Transaction } from '@sentry/types';\n\n/**\n * The `extractTraceparentData` function and `TRACEPARENT_REGEXP` constant used\n * to be declared in this file. It was later moved into `@sentry/utils` as part of a\n * move to remove `@sentry/tracing` dependencies from `@sentry/node` (`extractTraceparentData`\n * is the only tracing function used by `@sentry/node`).\n *\n * These exports are kept here for backwards compatability's sake.\n *\n * TODO(v7): Reorganize these exports\n *\n * See https://github.com/getsentry/sentry-javascript/issues/4642 for more details.\n */\nexport { TRACEPARENT_REGEXP, extractTraceparentData } from '@sentry/utils';\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nexport function hasTracingEnabled(\n  maybeOptions?: Pick<Options, 'tracesSampleRate' | 'tracesSampler'> | undefined,\n): boolean {\n  const client = getCurrentHub().getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\n/** Grabs active transaction off scope, if any */\nexport function getActiveTransaction<T extends Transaction>(maybeHub?: Hub): T | undefined {\n  const hub = maybeHub || getCurrentHub();\n  const scope = hub.getScope();\n  return scope && (scope.getTransaction() as T | undefined);\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nexport function msToSec(time: number): number {\n  return time / 1000;\n}\n\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\nexport function secToMs(time: number): number {\n  return time * 1000;\n}\n\n// so it can be used in manual instrumentation without necessitating a hard dependency on @sentry/utils\nexport { stripUrlQueryAndFragment } from '@sentry/utils';\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          // eslint-disable-next-line no-plusplus\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 { 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 given category is disabled until for rate limiting\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 * Returns true if headers contains a non-empty rate limiting header.\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","import {\n  Envelope,\n  EnvelopeItem,\n  EventDropReason,\n  InternalBaseTransportOptions,\n  Transport,\n  TransportRequestExecutor,\n} from '@sentry/types';\nimport {\n  createEnvelope,\n  envelopeItemTypeToDataCategory,\n  forEachEnvelopeItem,\n  isRateLimited,\n  logger,\n  makePromiseBuffer,\n  PromiseBuffer,\n  RateLimits,\n  resolvedSyncPromise,\n  SentryError,\n  serializeEnvelope,\n  updateRateLimits,\n} from '@sentry/utils';\n\nexport const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nexport function createTransport(\n  options: InternalBaseTransportOptions,\n  makeRequest: TransportRequestExecutor,\n  buffer: PromiseBuffer<void> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n): Transport {\n  let rateLimits: RateLimits = {};\n\n  const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);\n\n  function send(envelope: Envelope): PromiseLike<void> {\n    const filteredEnvelopeItems: EnvelopeItem[] = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as any);\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason: EventDropReason): void => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    const requestTask = (): PromiseLike<void> =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            __DEBUG_BUILD__ && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          __DEBUG_BUILD__ && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          __DEBUG_BUILD__ && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n","import {\n  Attachment,\n  AttachmentItem,\n  DataCategory,\n  Envelope,\n  EnvelopeItem,\n  EnvelopeItemType,\n  TextEncoderInternal,\n} from '@sentry/types';\n\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 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 */\nexport function forEachEnvelopeItem<E extends Envelope>(\n  envelope: Envelope,\n  callback: (envelopeItem: E[1][number], envelopeItemType: E[1][number][0]['type']) => void,\n): void {\n  const envelopeItems = envelope[1];\n  envelopeItems.forEach((envelopeItem: EnvelopeItem) => {\n    const envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\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\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};\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","/* eslint-disable max-lines */\nimport {\n  Client,\n  ClientOptions,\n  DataCategory,\n  DsnComponents,\n  Envelope,\n  Event,\n  EventDropReason,\n  EventHint,\n  Integration,\n  IntegrationClass,\n  Outcome,\n  Session,\n  SessionAggregates,\n  Severity,\n  SeverityLevel,\n  Transport,\n} from '@sentry/types';\nimport {\n  addItemToEnvelope,\n  checkOrSetAlreadyCaught,\n  createAttachmentEnvelopeItem,\n  dateTimestampInSeconds,\n  isPlainObject,\n  isPrimitive,\n  isThenable,\n  logger,\n  makeDsn,\n  normalize,\n  rejectedSyncPromise,\n  resolvedSyncPromise,\n  SentryError,\n  SyncPromise,\n  truncate,\n  uuid4,\n} from '@sentry/utils';\n\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope';\nimport { IntegrationIndex, setupIntegrations } from './integration';\nimport { Scope } from './scope';\nimport { updateSession } from './session';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nexport abstract class BaseClient<O extends ClientOptions> implements Client<O> {\n  /** Options passed to the SDK. */\n  protected readonly _options: O;\n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  protected readonly _dsn?: DsnComponents;\n\n  protected readonly _transport?: Transport;\n\n  /** Array of set up integrations. */\n  protected _integrations: IntegrationIndex = {};\n\n  /** Indicates whether this client's integrations have been set up. */\n  protected _integrationsInitialized: boolean = false;\n\n  /** Number of calls being processed */\n  protected _numProcessing: number = 0;\n\n  /** Holds flushable  */\n  private _outcomes: { [key: string]: number } = {};\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n  protected constructor(options: O) {\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      __DEBUG_BUILD__ && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined;\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n    scope?: Scope,\n  ): string | undefined {\n    let eventId: string | undefined;\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined;\n\n    this._process(\n      this._captureEvent(event, hint, scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureSession(session: Session): void {\n    if (!this._isEnabled()) {\n      __DEBUG_BUILD__ && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      __DEBUG_BUILD__ && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getDsn(): DsnComponents | undefined {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getOptions(): O {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransport(): Transport | undefined {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public flush(timeout?: number): PromiseLike<boolean> {\n    const transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n  public setupIntegrations(): void {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n  public getIntegrationById(integrationId: string): Integration | undefined {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    try {\n      return (this._integrations[integration.id] as T) || null;\n    } catch (_oO) {\n      __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event, hint: EventHint = {}): void {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (const attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(\n            attachment,\n            this._options.transportOptions && this._options.transportOptions.textEncoder,\n          ),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session | SessionAggregates): void {\n    if (this._dsn) {\n      const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public recordDroppedEvent(reason: EventDropReason, category: DataCategory): void {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      __DEBUG_BUILD__ && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n  protected _updateSessionFromEvent(session: Session, event: Event): void {\n    let crashed = false;\n    let errored = false;\n    const exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n  protected _isClientDoneProcessing(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise(resolve => {\n      let ticked: number = 0;\n      const tick: number = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n  protected _isEnabled(): boolean {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = this.getOptions();\n    const prepared: Event = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\n\n    // If we have scope given to us, use it as the base for further modifications.\n    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise<Event | null>(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    //\n    // We need to check for the existence of `finalScope.getAttachments`\n    // because `getAttachments` can be undefined if users are using an older version\n    // of `@sentry/core` that does not have the `getAttachments` method.\n    // See: https://github.com/getsentry/sentry-javascript/issues/5229\n    if (finalScope && finalScope.getAttachments) {\n      // Collect attachments from the hint and scope\n      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n   * Normalized keys:\n   * - `breadcrumbs.data`\n   * - `user`\n   * - `contexts`\n   * - `extra`\n   * @param event Event\n   * @returns Normalized event\n   */\n  protected _normalizeEvent(event: Event | null, depth: number, maxBreadth: number): Event | null {\n    if (!event) {\n      return null;\n    }\n\n    const normalized: Event = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth, maxBreadth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth, maxBreadth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth),\n      }),\n    };\n\n    // event.contexts.trace stores information about a Transaction. Similarly,\n    // event.spans[] stores information about child Spans. Given that a\n    // Transaction is conceptually a Span, normalization should apply to both\n    // Transactions and Spans consistently.\n    // For now the decision is to skip normalization of Transactions and Spans,\n    // so this block overwrites the normalized event to add back the original\n    // Transaction information prior to normalization.\n    if (event.contexts && event.contexts.trace && normalized.contexts) {\n      normalized.contexts.trace = event.contexts.trace;\n\n      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n      if (event.contexts.trace.data) {\n        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n      }\n    }\n\n    // event.spans[].data may contain circular/dangerous data so we need to normalize it\n    if (event.spans) {\n      normalized.spans = event.spans.map(span => {\n        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\n  }\n\n  /**\n   *  Enhances event using the client configuration.\n   *  It takes care of all \"static\" values like environment, release and `dist`,\n   *  as well as truncating overly long values.\n   * @param event event instance to be enhanced\n   */\n  protected _applyClientOptions(event: Event): void {\n    const options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    const exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    const request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n  }\n\n  /**\n   * This function adds all used integrations to the SDK info in the event.\n   * @param event The event that will be filled with all integrations.\n   */\n  protected _applyIntegrationsMetadata(event: Event): void {\n    const integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n  protected _captureEvent(event: Event, hint: EventHint = {}, scope?: Scope): PromiseLike<string | undefined> {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if (__DEBUG_BUILD__) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          const sentryError = reason as SentryError;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n  protected _processEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event> {\n    const options = this.getOptions();\n    const { sampleRate } = options;\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));\n    }\n\n    const isTransaction = event.type === 'transaction';\n    const beforeSendProcessorName = isTransaction ? 'beforeSendTransaction' : 'beforeSend';\n    const beforeSendProcessor = options[beforeSendProcessorName];\n\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned `null`, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n        if (isInternalException || !beforeSendProcessor) {\n          return prepared;\n        }\n\n        const beforeSendResult = beforeSendProcessor(prepared, hint);\n        return _validateBeforeSendResult(beforeSendResult, beforeSendProcessorName);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError(`\\`${beforeSendProcessorName}\\` returned \\`null\\`, will not send event.`, 'log');\n        }\n\n        const session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n            changes: [\n              ...transactionInfo.changes,\n              {\n                source,\n                // use the same timestamp as the processed event.\n                timestamp: processedEvent.timestamp as number,\n                propagations: transactionInfo.propagations,\n              },\n            ],\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason as Error,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n  protected _process<T>(promise: PromiseLike<T>): void {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected _sendEnvelope(envelope: Envelope): void {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        __DEBUG_BUILD__ && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      __DEBUG_BUILD__ && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n  protected _clearOutcomes(): Outcome[] {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') as [EventDropReason, DataCategory];\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public abstract eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event>;\n\n  /**\n   * @inheritDoc\n   */\n  public abstract eventFromMessage(\n    _message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    _level?: Severity | SeverityLevel,\n    _hint?: EventHint,\n  ): PromiseLike<Event>;\n}\n\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\nfunction _validateBeforeSendResult(\n  beforeSendResult: PromiseLike<Event | null> | Event | null,\n  beforeSendProcessorName: 'beforeSend' | 'beforeSendTransaction',\n): PromiseLike<Event | null> | Event | null {\n  const invalidValueError = `\\`${beforeSendProcessorName}\\` must return \\`null\\` or a valid event.`;\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(\n      event => {\n        if (!isPlainObject(event) && event !== null) {\n          throw new SentryError(invalidValueError);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`\\`${beforeSendProcessorName}\\` rejected with ${e}`);\n      },\n    );\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n  return beforeSendResult;\n}\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\ndeclare const __SENTRY_BROWSER_BUNDLE__: boolean | undefined;\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle(): boolean {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n","import { isString } from './is';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem: unknown, keyAttrs?: string[]): string {\n  type SimpleNode = {\n    parentNode: SimpleNode;\n  } | null;\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem as SimpleNode;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const MAX_OUTPUT_LEN = 80;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n\n    // eslint-disable-next-line no-plusplus\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el: unknown, keyAttrs?: string[]): string {\n  const elem = el as {\n    tagName?: string;\n    id?: string;\n    className?: string;\n    getAttribute(key: string): string;\n  };\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  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","import { addInstrumentationHandler, logger } from '@sentry/utils';\n\nimport { SpanStatusType } from './span';\nimport { getActiveTransaction } from './utils';\n\n/**\n * Configures global error listeners\n */\nexport function registerErrorInstrumentation(): void {\n  addInstrumentationHandler('error', errorCallback);\n  addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\nfunction errorCallback(): void {\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const status: SpanStatusType = 'internal_error';\n    __DEBUG_BUILD__ && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n    activeTransaction.setStatus(status);\n  }\n}\n","import { Primitive } from '@sentry/types';\n\nimport { isNaN, isSyntheticEvent } from './is';\nimport { memoBuilder, MemoFunc } 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 = +Infinity, 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 (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\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're also done if we've reached the max depth\n  if (depth === 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, depth - 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, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\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/**\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    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\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    return `[object ${(Object.getPrototypeOf(value) as Prototype).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\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","import { 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  // 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 { GLOBAL_OBJ } from '@sentry/utils';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Metric, ReportCallback } from '../types';\n\nexport const bindReporter = (\n  callback: ReportCallback,\n  metric: Metric,\n  reportAllChanges?: boolean,\n): ((forceReport?: boolean) => void) => {\n  let prevValue: number;\n  let delta: number;\n  return (forceReport?: boolean) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n","/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { WINDOW } from '../../types';\nimport { NavigationTimingPolyfillEntry } from '../types';\n\nconst getNavigationEntryFromPerformanceTiming = (): NavigationTimingPolyfillEntry => {\n  // eslint-disable-next-line deprecation/deprecation\n  const timing = WINDOW.performance.timing;\n  // eslint-disable-next-line deprecation/deprecation\n  const type = WINDOW.performance.navigation.type;\n\n  const navigationEntry: { [key: string]: number | string } = {\n    entryType: 'navigation',\n    startTime: 0,\n    type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate',\n  };\n\n  for (const key in timing) {\n    if (key !== 'navigationStart' && key !== 'toJSON') {\n      navigationEntry[key] = Math.max((timing[key as keyof PerformanceTiming] as number) - timing.navigationStart, 0);\n    }\n  }\n  return navigationEntry as unknown as NavigationTimingPolyfillEntry;\n};\n\nexport const getNavigationEntry = (): PerformanceNavigationTiming | NavigationTimingPolyfillEntry | undefined => {\n  if (WINDOW.__WEB_VITALS_POLYFILL__) {\n    return (\n      WINDOW.performance &&\n      ((performance.getEntriesByType && performance.getEntriesByType('navigation')[0]) ||\n        getNavigationEntryFromPerformanceTiming())\n    );\n  } else {\n    return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];\n  }\n};\n","/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getNavigationEntry } from './getNavigationEntry';\n\nexport const getActivationStart = (): number => {\n  const navEntry = getNavigationEntry();\n  return (navEntry && navEntry.activationStart) || 0;\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { WINDOW } from '../../types';\nimport { Metric } from '../types';\nimport { generateUniqueID } from './generateUniqueID';\nimport { getActivationStart } from './getActivationStart';\nimport { getNavigationEntry } from './getNavigationEntry';\n\nexport const initMetric = (name: Metric['name'], value?: number): Metric => {\n  const navEntry = getNavigationEntry();\n  let navigationType: Metric['navigationType'] = 'navigate';\n\n  if (navEntry) {\n    if (WINDOW.document.prerendering || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else {\n      navigationType = navEntry.type.replace(/_/g, '-') as Metric['navigationType'];\n    }\n  }\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good', // Will be updated if the value changes.\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nexport const generateUniqueID = (): string => {\n  return `v3-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirstInputPolyfillEntry, NavigationTimingPolyfillEntry, PerformancePaintTiming } from '../types';\n\nexport interface PerformanceEntryHandler {\n  (entry: PerformanceEntry): void;\n}\n\ninterface PerformanceEntryMap {\n  event: PerformanceEventTiming[];\n  paint: PerformancePaintTiming[];\n  'layout-shift': LayoutShift[];\n  'largest-contentful-paint': LargestContentfulPaint[];\n  'first-input': PerformanceEventTiming[] | FirstInputPolyfillEntry[];\n  navigation: PerformanceNavigationTiming[] | NavigationTimingPolyfillEntry[];\n  resource: PerformanceResourceTiming[];\n  longtask: PerformanceEntry[];\n}\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nexport const observe = <K extends keyof PerformanceEntryMap>(\n  type: K,\n  callback: (entries: PerformanceEntryMap[K]) => void,\n  opts?: PerformanceObserverInit,\n): PerformanceObserver | undefined => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        callback(list.getEntries() as PerformanceEntryMap[K]);\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) as PerformanceObserverInit,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { WINDOW } from '../../types';\n\nexport interface OnHiddenCallback {\n  (event: Event): void;\n}\n\nexport const onHidden = (cb: OnHiddenCallback, once?: boolean): void => {\n  const onHiddenOrPageHide = (event: Event): void => {\n    if (event.type === 'pagehide' || WINDOW.document.visibilityState === 'hidden') {\n      cb(event);\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n  addEventListener('visibilitychange', onHiddenOrPageHide, true);\n  // Some browsers have buggy implementations of visibilitychange,\n  // so we use pagehide in addition, just to be safe.\n  addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { WINDOW } from '../../types';\nimport { onHidden } from './onHidden';\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = (): number => {\n  // If the document is hidden and not prerendering, assume it was always\n  // hidden and the page was loaded in the background.\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nconst trackChanges = (): void => {\n  // Update the time if/when the document becomes hidden.\n  onHidden(({ timeStamp }) => {\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nexport const getVisibilityWatcher = (): {\n  readonly firstHiddenTime: number;\n} => {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    trackChanges();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { getActivationStart } from './lib/getActivationStart';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { LCPMetric, ReportCallback, ReportOpts } from './types';\n\nconst reportedMetricIDs: Record<string, boolean> = {};\n\n/**\n * Calculates the [LCP](https://web.dev/lcp/) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called any time a new `largest-contentful-paint`\n * performance entry is dispatched, or once the final value of the metric has\n * been determined.\n */\nexport const onLCP = (onReport: ReportCallback, opts: ReportOpts = {}): void => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('LCP');\n  let report: ReturnType<typeof bindReporter>;\n\n  const handleEntries = (entries: LCPMetric['entries']): void => {\n    const lastEntry = entries[entries.length - 1] as LargestContentfulPaint;\n    if (lastEntry) {\n      // The startTime attribute returns the value of the renderTime if it is\n      // not 0, and the value of the loadTime otherwise. The activationStart\n      // reference is used because LCP should be relative to page activation\n      // rather than navigation start if the page was prerendered.\n      const value = Math.max(lastEntry.startTime - getActivationStart(), 0);\n\n      // Only report if the page wasn't hidden prior to LCP.\n      if (value < visibilityWatcher.firstHiddenTime) {\n        metric.value = value;\n        metric.entries = [lastEntry];\n        report();\n      }\n    }\n  };\n\n  const po = observe('largest-contentful-paint', handleEntries);\n\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n    const stopListening = (): void => {\n      if (!reportedMetricIDs[metric.id]) {\n        handleEntries(po.takeRecords() as LCPMetric['entries']);\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    };\n\n    // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n    ['keydown', 'click'].forEach(type => {\n      addEventListener(type, stopListening, { once: true, capture: true });\n    });\n\n    onHidden(stopListening, true);\n  }\n};\n","import { Span, SpanContext } from '@sentry/types';\n\nimport { Transaction } from '../../transaction';\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nexport function isMeasurementValue(value: unknown): value is number {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nexport function _startChild(transaction: Transaction, { startTimestamp, ...ctx }: SpanContext): Span {\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild({\n    startTimestamp,\n    ...ctx,\n  });\n}\n","/* eslint-disable max-lines */\nimport { Measurements } from '@sentry/types';\nimport { browserPerformanceTimeOrigin, htmlTreeAsString, logger } from '@sentry/utils';\n\nimport { IdleTransaction } from '../../idletransaction';\nimport { Transaction } from '../../transaction';\nimport { getActiveTransaction, msToSec } from '../../utils';\nimport { WINDOW } from '../types';\nimport { onCLS } from '../web-vitals/getCLS';\nimport { onFID } from '../web-vitals/getFID';\nimport { onLCP } from '../web-vitals/getLCP';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher';\nimport { observe } from '../web-vitals/lib/observe';\nimport { NavigatorDeviceMemory, NavigatorNetworkInformation } from '../web-vitals/types';\nimport { _startChild, isMeasurementValue } from './utils';\n\nfunction getBrowserPerformanceAPI(): Performance | undefined {\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\nlet _performanceCursor: number = 0;\n\nlet _measurements: Measurements = {};\nlet _lcpEntry: LargestContentfulPaint | undefined;\nlet _clsEntry: LayoutShift | undefined;\n\n/**\n * Start tracking web vitals\n */\nexport function startTrackingWebVitals(reportAllChanges: boolean = false): void {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n    _trackCLS();\n    _trackLCP(reportAllChanges);\n    _trackFID();\n  }\n}\n\n/**\n * Start tracking long tasks.\n */\nexport function startTrackingLongTasks(): void {\n  const entryHandler = (entries: PerformanceEntry[]): void => {\n    for (const entry of entries) {\n      const transaction = getActiveTransaction() as IdleTransaction | undefined;\n      if (!transaction) {\n        return;\n      }\n      const startTime = msToSec((browserPerformanceTimeOrigin as number) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      transaction.startChild({\n        description: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        startTimestamp: startTime,\n        endTimestamp: startTime + duration,\n      });\n    }\n  };\n\n  observe('longtask', entryHandler);\n}\n\n/** Starts tracking the Cumulative Layout Shift on the current page. */\nfunction _trackCLS(): void {\n  // See:\n  // https://web.dev/evolving-cls/\n  // https://web.dev/cls-web-tooling/\n  onCLS(metric => {\n    const entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    __DEBUG_BUILD__ && logger.log('[Measurements] Adding CLS');\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry as LayoutShift;\n  });\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP(reportAllChanges: boolean): void {\n  onLCP(\n    metric => {\n      const entry = metric.entries.pop();\n      if (!entry) {\n        return;\n      }\n\n      __DEBUG_BUILD__ && logger.log('[Measurements] Adding LCP');\n      _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n      _lcpEntry = entry as LargestContentfulPaint;\n    },\n    { reportAllChanges },\n  );\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID(): void {\n  onFID(metric => {\n    const entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin as number);\n    const startTime = msToSec(entry.startTime);\n    __DEBUG_BUILD__ && logger.log('[Measurements] Adding FID');\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nexport function addPerformanceEntries(transaction: Transaction): void {\n  const performance = getBrowserPerformanceAPI();\n  if (!performance || !WINDOW.performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  __DEBUG_BUILD__ && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n  const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  const performanceEntries = performance.getEntries();\n\n  let responseStartTimestamp: number | undefined;\n  let requestStartTimestamp: number | undefined;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  performanceEntries.slice(_performanceCursor).forEach((entry: Record<string, any>) => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(entry.duration);\n\n    if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(transaction, entry, timeOrigin);\n        responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);\n        requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          __DEBUG_BUILD__ && logger.log('[Measurements] Adding FP');\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          __DEBUG_BUILD__ && logger.log('[Measurements] Adding FCP');\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        const resourceName = (entry.name as string).replace(WINDOW.location.origin, '');\n        _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n        break;\n      }\n      default:\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(transaction);\n\n  // Measurements are only available for pageload transactions\n  if (transaction.op === 'pageload') {\n    // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n    // start of the response in milliseconds\n    if (typeof responseStartTimestamp === 'number') {\n      __DEBUG_BUILD__ && logger.log('[Measurements] Adding TTFB');\n      _measurements['ttfb'] = {\n        value: (responseStartTimestamp - transaction.startTimestamp) * 1000,\n        unit: 'millisecond',\n      };\n\n      if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n        // Capture the time spent making the request and receiving the first byte of the response.\n        // This is the time between the start of the request and the start of the response in milliseconds.\n        _measurements['ttfb.requestTime'] = {\n          value: (responseStartTimestamp - requestStartTimestamp) * 1000,\n          unit: 'millisecond',\n        };\n      }\n    }\n\n    ['fcp', 'fp', 'lcp'].forEach(name => {\n      if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {\n        return;\n      }\n      // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n      // to be adjusted to be relative to transaction.startTimestamp.\n      const oldValue = _measurements[name].value;\n      const measurementTimestamp = timeOrigin + msToSec(oldValue);\n\n      // normalizedValue should be in milliseconds\n      const normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n      const delta = normalizedValue - oldValue;\n\n      __DEBUG_BUILD__ &&\n        logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n      _measurements[name].value = normalizedValue;\n    });\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      _startChild(transaction, {\n        description: 'first input delay',\n        endTimestamp: fidMark.value + msToSec(_measurements['fid'].value),\n        op: 'ui.action',\n        startTimestamp: fidMark.value,\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    if (!('fcp' in _measurements)) {\n      delete _measurements.cls;\n    }\n\n    Object.keys(_measurements).forEach(measurementName => {\n      transaction.setMeasurement(\n        measurementName,\n        _measurements[measurementName].value,\n        _measurements[measurementName].unit,\n      );\n    });\n\n    _tagMetricInfo(transaction);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/** Create measure related spans */\nexport function _addMeasureSpans(\n  transaction: Transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry: Record<string, any>,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): number {\n  const measureStartTimestamp = timeOrigin + startTime;\n  const measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name as string,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType as string,\n    startTimestamp: measureStartTimestamp,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addNavigationSpans(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n  _addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  transaction: Transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry: Record<string, any>,\n  event: string,\n  timeOrigin: number,\n  description?: string,\n  eventEnd?: string,\n): void {\n  const end = eventEnd ? (entry[eventEnd] as number | undefined) : (entry[`${event}End`] as number | undefined);\n  const start = entry[`${event}Start`] as number | undefined;\n  if (!start || !end) {\n    return;\n  }\n  _startChild(transaction, {\n    op: 'browser',\n    description: description ?? event,\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end),\n  });\n}\n\n/** Create request and response related spans */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addRequest(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'request',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart as number),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n  });\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'response',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart as number),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n  });\n}\n\nexport interface ResourceEntry extends Record<string, unknown> {\n  initiatorType?: string;\n  transferSize?: number;\n  encodedBodySize?: number;\n  decodedBodySize?: number;\n}\n\n/** Create resource-related spans */\nexport function _addResourceSpans(\n  transaction: Transaction,\n  entry: ResourceEntry,\n  resourceName: string,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): void {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const data: Record<string, any> = {};\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp,\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    startTimestamp,\n    data,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(transaction: Transaction): void {\n  const navigator = WINDOW.navigator as null | (Navigator & NavigatorNetworkInformation & NavigatorDeviceMemory);\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      transaction.setTag('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      transaction.setTag('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction _tagMetricInfo(transaction: Transaction): void {\n  if (_lcpEntry) {\n    __DEBUG_BUILD__ && logger.log('[Measurements] Adding LCP Data');\n\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      transaction.setTag('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    transaction.setTag('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    __DEBUG_BUILD__ && logger.log('[Measurements] Adding CLS Data');\n    _clsEntry.sources.forEach((source, index) =>\n      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { CLSMetric, ReportCallback, ReportOpts } from './types';\n\n/**\n * Calculates the [CLS](https://web.dev/cls/) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/cls/#layout-shift-score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nexport const onCLS = (onReport: ReportCallback, opts: ReportOpts = {}): void => {\n  const metric = initMetric('CLS', 0);\n  let report: ReturnType<typeof bindReporter>;\n\n  let sessionValue = 0;\n  let sessionEntries: PerformanceEntry[] = [];\n\n  // const handleEntries = (entries: Metric['entries']) => {\n  const handleEntries = (entries: LayoutShift[]): void => {\n    entries.forEach(entry => {\n      // Only count layout shifts without recent user input.\n      if (!entry.hadRecentInput) {\n        const firstSessionEntry = sessionEntries[0];\n        const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n        // If the entry occurred less than 1 second after the previous entry and\n        // less than 5 seconds after the first entry in the session, include the\n        // entry in the current session. Otherwise, start a new session.\n        if (\n          sessionValue &&\n          sessionEntries.length !== 0 &&\n          entry.startTime - lastSessionEntry.startTime < 1000 &&\n          entry.startTime - firstSessionEntry.startTime < 5000\n        ) {\n          sessionValue += entry.value;\n          sessionEntries.push(entry);\n        } else {\n          sessionValue = entry.value;\n          sessionEntries = [entry];\n        }\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          if (report) {\n            report();\n          }\n        }\n      }\n    });\n  };\n\n  const po = observe('layout-shift', handleEntries);\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n    onHidden(() => {\n      handleEntries(po.takeRecords() as CLSMetric['entries']);\n      report(true);\n    });\n  }\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { FIDMetric, PerformanceEventTiming, ReportCallback, ReportOpts } from './types';\n\n/**\n * Calculates the [FID](https://web.dev/fid/) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\nexport const onFID = (onReport: ReportCallback, opts: ReportOpts = {}): void => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('FID');\n  // eslint-disable-next-line prefer-const\n  let report: ReturnType<typeof bindReporter>;\n\n  const handleEntry = (entry: PerformanceEventTiming): void => {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  const handleEntries = (entries: FIDMetric['entries']): void => {\n    (entries as PerformanceEventTiming[]).forEach(handleEntry);\n  };\n\n  const po = observe('first-input', handleEntries);\n  report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n  if (po) {\n    onHidden(() => {\n      handleEntries(po.takeRecords() as FIDMetric['entries']);\n      po.disconnect();\n    }, true);\n  }\n};\n","/* eslint-disable max-lines */\nimport type { DynamicSamplingContext, Span } from '@sentry/types';\nimport {\n  addInstrumentationHandler,\n  BAGGAGE_HEADER_NAME,\n  dynamicSamplingContextToSentryBaggageHeader,\n  isInstanceOf,\n  stringMatchesSomePattern,\n} from '@sentry/utils';\n\nimport { getActiveTransaction, hasTracingEnabled } from '../utils';\n\nexport const DEFAULT_TRACE_PROPAGATION_TARGETS = ['localhost', /^\\//];\n\n/** Options for Request Instrumentation */\nexport interface RequestInstrumentationOptions {\n  /**\n   * @deprecated Will be removed in v8.\n   * Use `shouldCreateSpanForRequest` to control span creation and `tracePropagationTargets` to control\n   * trace header attachment.\n   */\n  tracingOrigins: Array<string | RegExp>;\n\n  /**\n   * List of strings and/or regexes used to determine which outgoing requests will have `sentry-trace` and `baggage`\n   * headers attached.\n   *\n   * Default: ['localhost', /^\\//] {@see DEFAULT_TRACE_PROPAGATION_TARGETS}\n   */\n  tracePropagationTargets: Array<string | RegExp>;\n\n  /**\n   * Flag to disable patching all together for fetch requests.\n   *\n   * Default: true\n   */\n  traceFetch: boolean;\n\n  /**\n   * Flag to disable patching all together for xhr requests.\n   *\n   * Default: true\n   */\n  traceXHR: boolean;\n\n  /**\n   * This function will be called before creating a span for a request with the given url.\n   * Return false if you don't want a span for the given url.\n   *\n   * Default: (url: string) => true\n   */\n  shouldCreateSpanForRequest?(url: string): boolean;\n}\n\n/** Data returned from fetch callback */\nexport interface FetchData {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  args: any[]; // the arguments passed to the fetch call itself\n  fetchData?: {\n    method: string;\n    url: string;\n    // span_id\n    __span?: string;\n  };\n\n  // TODO Should this be unknown instead? If we vendor types, make it a Response\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  response?: any;\n  error?: unknown;\n\n  startTimestamp: number;\n  endTimestamp?: number;\n}\n\n/** Data returned from XHR request */\nexport interface XHRData {\n  xhr?: {\n    __sentry_xhr__?: {\n      method: string;\n      url: string;\n      status_code: number;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      data: Record<string, any>;\n    };\n    __sentry_xhr_span_id__?: string;\n    setRequestHeader?: (key: string, val: string) => void;\n    getRequestHeader?: (key: string) => string;\n    __sentry_own_request__?: boolean;\n  };\n  startTimestamp: number;\n  endTimestamp?: number;\n}\n\ntype PolymorphicRequestHeaders =\n  | Record<string, string | undefined>\n  | Array<[string, string]>\n  // the below is not preicsely the Header type used in Request, but it'll pass duck-typing\n  | {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      [key: string]: any;\n      append: (key: string, value: string) => void;\n      get: (key: string) => string;\n    };\n\nexport const defaultRequestInstrumentationOptions: RequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  // TODO (v8): Remove this property\n  tracingOrigins: DEFAULT_TRACE_PROPAGATION_TARGETS,\n  tracePropagationTargets: DEFAULT_TRACE_PROPAGATION_TARGETS,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nexport function instrumentOutgoingRequests(_options?: Partial<RequestInstrumentationOptions>): void {\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceFetch, traceXHR, tracePropagationTargets, tracingOrigins, shouldCreateSpanForRequest } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_: string) => true;\n\n  // TODO(v8) Remove tracingOrigins here\n  // The only reason we're passing it in here is because this instrumentOutgoingRequests function is publicly exported\n  // and we don't want to break the API. We can remove it in v8.\n  const shouldAttachHeadersWithTargets = (url: string): boolean =>\n    shouldAttachHeaders(url, tracePropagationTargets || tracingOrigins);\n\n  const spans: Record<string, Span> = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', (handlerData: FetchData) => {\n      fetchCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', (handlerData: XHRData) => {\n      xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n    });\n  }\n}\n\n/**\n * A function that determines whether to attach tracing headers to a request.\n * This was extracted from `instrumentOutgoingRequests` to make it easier to test shouldAttachHeaders.\n * We only export this fuction for testing purposes.\n */\nexport function shouldAttachHeaders(url: string, tracePropagationTargets: (string | RegExp)[] | undefined): boolean {\n  return stringMatchesSomePattern(url, tracePropagationTargets || DEFAULT_TRACE_PROPAGATION_TARGETS);\n}\n\n/**\n * Create and track fetch request spans\n */\nexport function fetchCallback(\n  handlerData: FetchData,\n  shouldCreateSpan: (url: string) => boolean,\n  shouldAttachHeaders: (url: string) => boolean,\n  spans: Record<string, Span>,\n): void {\n  if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      if (handlerData.response) {\n        // TODO (kmclb) remove this once types PR goes through\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        span.setHttpStatus(handlerData.response.status);\n      } else if (handlerData.error) {\n        span.setStatus('internal_error');\n      }\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...handlerData.fetchData,\n        type: 'fetch',\n      },\n      description: `${handlerData.fetchData.method} ${handlerData.fetchData.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.fetchData.__span = span.spanId;\n    spans[span.spanId] = span;\n\n    const request: string | Request = handlerData.args[0];\n\n    // In case the user hasn't set the second argument of a fetch call we default it to `{}`.\n    handlerData.args[1] = handlerData.args[1] || {};\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const options: { [key: string]: any } = handlerData.args[1];\n\n    if (shouldAttachHeaders(handlerData.fetchData.url)) {\n      options.headers = addTracingHeadersToFetchRequest(\n        request,\n        activeTransaction.getDynamicSamplingContext(),\n        span,\n        options,\n      );\n\n      activeTransaction.metadata.propagations += 1;\n    }\n  }\n}\n\nfunction addTracingHeadersToFetchRequest(\n  request: string | Request,\n  dynamicSamplingContext: Partial<DynamicSamplingContext>,\n  span: Span,\n  options: {\n    headers?:\n      | {\n          [key: string]: string[] | string | undefined;\n        }\n      | Request['headers'];\n  },\n): PolymorphicRequestHeaders {\n  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n  const sentryTraceHeader = span.toTraceparent();\n\n  const headers =\n    typeof Request !== 'undefined' && isInstanceOf(request, Request) ? (request as Request).headers : options.headers;\n\n  if (!headers) {\n    return { 'sentry-trace': sentryTraceHeader, baggage: sentryBaggageHeader };\n  } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {\n    const newHeaders = new Headers(headers as Headers);\n\n    newHeaders.append('sentry-trace', sentryTraceHeader);\n\n    if (sentryBaggageHeader) {\n      // If the same header is appended miultiple times the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.append(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n    }\n\n    return newHeaders as PolymorphicRequestHeaders;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [...headers, ['sentry-trace', sentryTraceHeader]];\n\n    if (sentryBaggageHeader) {\n      // If there are multiple entries with the same key, the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);\n    }\n\n    return newHeaders;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    const newBaggageHeaders: string[] = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders.push(...existingBaggageHeader);\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(existingBaggageHeader);\n    }\n\n    if (sentryBaggageHeader) {\n      newBaggageHeaders.push(sentryBaggageHeader);\n    }\n\n    return {\n      ...(headers as Exclude<typeof headers, Headers>),\n      'sentry-trace': sentryTraceHeader,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\n/**\n * Create and track xhr request spans\n */\nexport function xhrCallback(\n  handlerData: XHRData,\n  shouldCreateSpan: (url: string) => boolean,\n  shouldAttachHeaders: (url: string) => boolean,\n  spans: Record<string, Span>,\n): void {\n  if (\n    !hasTracingEnabled() ||\n    (handlerData.xhr && handlerData.xhr.__sentry_own_request__) ||\n    !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))\n  ) {\n    return;\n  }\n\n  const xhr = handlerData.xhr.__sentry_xhr__;\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  // if not, create a new span to track it\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...xhr.data,\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url,\n      },\n      description: `${xhr.method} ${xhr.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n    if (handlerData.xhr.setRequestHeader && shouldAttachHeaders(handlerData.xhr.__sentry_xhr__.url)) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n\n        const dynamicSamplingContext = activeTransaction.getDynamicSamplingContext();\n        const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n\n        if (sentryBaggageHeader) {\n          // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n          // We can therefore simply set a baggage header without checking what was there before\n          // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n          handlerData.xhr.setRequestHeader(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n        }\n\n        activeTransaction.metadata.propagations += 1;\n      } catch (_) {\n        // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}\n","/* eslint-disable max-lines */\nimport { Hub } from '@sentry/core';\nimport { EventProcessor, Integration, Transaction, TransactionContext } from '@sentry/types';\nimport { baggageHeaderToDynamicSamplingContext, getDomElement, logger } from '@sentry/utils';\n\nimport { startIdleTransaction } from '../hubextensions';\nimport { DEFAULT_FINAL_TIMEOUT, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_IDLE_TIMEOUT } from '../idletransaction';\nimport { extractTraceparentData } from '../utils';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { addPerformanceEntries, startTrackingLongTasks, startTrackingWebVitals } from './metrics';\nimport {\n  defaultRequestInstrumentationOptions,\n  instrumentOutgoingRequests,\n  RequestInstrumentationOptions,\n} from './request';\nimport { instrumentRoutingWithDefaults } from './router';\nimport { WINDOW } from './types';\n\nexport const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/** Options for Browser Tracing integration */\nexport interface BrowserTracingOptions extends RequestInstrumentationOptions {\n  /**\n   * The time to wait in ms until the transaction will be finished during an idle state. An idle state is defined\n   * by a moment where there are no in-progress spans.\n   *\n   * The transaction will use the end timestamp of the last finished span as the endtime for the transaction.\n   * If there are still active spans when this the `idleTimeout` is set, the `idleTimeout` will get reset.\n   * Time is in ms.\n   *\n   * Default: 1000\n   */\n  idleTimeout: number;\n\n  /**\n   * The max duration for a transaction. If a transaction duration hits the `finalTimeout` value, it\n   * will be finished.\n   * Time is in ms.\n   *\n   * Default: 30000\n   */\n  finalTimeout: number;\n\n  /**\n   * The heartbeat interval. If no new spans are started or open spans are finished within 3 heartbeats,\n   * the transaction will be finished.\n   * Time is in ms.\n   *\n   * Default: 5000\n   */\n  heartbeatInterval: number;\n\n  /**\n   * Flag to enable/disable creation of `navigation` transaction on history changes.\n   *\n   * Default: true\n   */\n  startTransactionOnLocationChange: boolean;\n\n  /**\n   * Flag to enable/disable creation of `pageload` transaction on first pageload.\n   *\n   * Default: true\n   */\n  startTransactionOnPageLoad: boolean;\n\n  /**\n   * Flag Transactions where tabs moved to background with \"cancelled\". Browser background tab timing is\n   * not suited towards doing precise measurements of operations. By default, we recommend that this option\n   * be enabled as background transactions can mess up your statistics in nondeterministic ways.\n   *\n   * Default: true\n   */\n  markBackgroundTransactions: boolean;\n\n  /**\n   * _metricOptions allows the user to send options to change how metrics are collected.\n   *\n   * _metricOptions is currently experimental.\n   *\n   * Default: undefined\n   */\n  _metricOptions?: Partial<{ _reportAllChanges: boolean }>;\n\n  /**\n   * _experiments allows the user to send options to define how this integration works.\n   *\n   * Default: undefined\n   */\n  _experiments?: Partial<{ enableLongTask: boolean }>;\n\n  /**\n   * beforeNavigate is called before a pageload/navigation transaction is created and allows users to modify transaction\n   * context data, or drop the transaction entirely (by setting `sampled = false` in the context).\n   *\n   * Note: For legacy reasons, transactions can also be dropped by returning `undefined`.\n   *\n   * @param context: The context data which will be passed to `startTransaction` by default\n   *\n   * @returns A (potentially) modified context object, with `sampled = false` if the transaction should be dropped.\n   */\n  beforeNavigate?(context: TransactionContext): TransactionContext | undefined;\n\n  /**\n   * Instrumentation that creates routing change transactions. By default creates\n   * pageload and navigation transactions.\n   */\n  routingInstrumentation<T extends Transaction>(\n    customStartTransaction: (context: TransactionContext) => T | undefined,\n    startTransactionOnPageLoad?: boolean,\n    startTransactionOnLocationChange?: boolean,\n  ): void;\n}\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  finalTimeout: DEFAULT_FINAL_TIMEOUT,\n  heartbeatInterval: DEFAULT_HEARTBEAT_INTERVAL,\n  markBackgroundTransactions: true,\n  routingInstrumentation: instrumentRoutingWithDefaults,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true,\n  _experiments: { enableLongTask: true },\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\nexport class BrowserTracing implements Integration {\n  // This class currently doesn't have a static `id` field like the other integration classes, because it prevented\n  // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.\n  // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all\n  // integrations.\n\n  /** Browser Tracing integration options */\n  public options: BrowserTracingOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = BROWSER_TRACING_INTEGRATION_ID;\n\n  private _getCurrentHub?: () => Hub;\n\n  public constructor(_options?: Partial<BrowserTracingOptions>) {\n    this.options = {\n      ...DEFAULT_BROWSER_TRACING_OPTIONS,\n      ..._options,\n    };\n\n    // TODO (v8): remove this block after tracingOrigins is removed\n    // Set tracePropagationTargets to tracingOrigins if specified by the user\n    // In case both are specified, tracePropagationTargets takes precedence\n    // eslint-disable-next-line deprecation/deprecation\n    if (_options && !_options.tracePropagationTargets && _options.tracingOrigins) {\n      // eslint-disable-next-line deprecation/deprecation\n      this.options.tracePropagationTargets = _options.tracingOrigins;\n    }\n\n    const { _metricOptions } = this.options;\n    startTrackingWebVitals(_metricOptions && _metricOptions._reportAllChanges);\n    if (this.options._experiments?.enableLongTask) {\n      startTrackingLongTasks();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    this._getCurrentHub = getCurrentHub;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const {\n      routingInstrumentation: instrumentRouting,\n      startTransactionOnLocationChange,\n      startTransactionOnPageLoad,\n      markBackgroundTransactions,\n      traceFetch,\n      traceXHR,\n      tracePropagationTargets,\n      shouldCreateSpanForRequest,\n    } = this.options;\n\n    instrumentRouting(\n      (context: TransactionContext) => this._createRouteTransaction(context),\n      startTransactionOnPageLoad,\n      startTransactionOnLocationChange,\n    );\n\n    if (markBackgroundTransactions) {\n      registerBackgroundTabDetection();\n    }\n\n    instrumentOutgoingRequests({\n      traceFetch,\n      traceXHR,\n      tracePropagationTargets,\n      shouldCreateSpanForRequest,\n    });\n  }\n\n  /** Create routing idle transaction. */\n  private _createRouteTransaction(context: TransactionContext): Transaction | undefined {\n    if (!this._getCurrentHub) {\n      __DEBUG_BUILD__ &&\n        logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);\n      return undefined;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeNavigate, idleTimeout, finalTimeout, heartbeatInterval } = this.options;\n\n    const isPageloadTransaction = context.op === 'pageload';\n\n    const sentryTraceMetaTagValue = isPageloadTransaction ? getMetaContent('sentry-trace') : null;\n    const baggageMetaTagValue = isPageloadTransaction ? getMetaContent('baggage') : null;\n\n    const traceParentData = sentryTraceMetaTagValue ? extractTraceparentData(sentryTraceMetaTagValue) : undefined;\n    const dynamicSamplingContext = baggageMetaTagValue\n      ? baggageHeaderToDynamicSamplingContext(baggageMetaTagValue)\n      : undefined;\n\n    const expandedContext: TransactionContext = {\n      ...context,\n      ...traceParentData,\n      metadata: {\n        ...context.metadata,\n        dynamicSamplingContext: traceParentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,\n      },\n      trimEnd: true,\n    };\n\n    const modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;\n\n    // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n    // from being sent to Sentry).\n    const finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;\n\n    // If `beforeNavigate` set a custom name, record that fact\n    finalContext.metadata =\n      finalContext.name !== expandedContext.name\n        ? { ...finalContext.metadata, source: 'custom' }\n        : finalContext.metadata;\n\n    if (finalContext.sampled === false) {\n      __DEBUG_BUILD__ &&\n        logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n    }\n\n    __DEBUG_BUILD__ && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n    const hub = this._getCurrentHub();\n    const { location } = WINDOW;\n\n    const idleTransaction = startIdleTransaction(\n      hub,\n      finalContext,\n      idleTimeout,\n      finalTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n      heartbeatInterval,\n    );\n    idleTransaction.registerBeforeFinishCallback(transaction => {\n      addPerformanceEntries(transaction);\n      transaction.setTag(\n        'sentry_reportAllChanges',\n        Boolean(this.options._metricOptions && this.options._metricOptions._reportAllChanges),\n      );\n    });\n\n    return idleTransaction as Transaction;\n  }\n}\n\n/** Returns the value of a meta tag */\nexport function getMetaContent(metaName: string): string | null {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : null;\n}\n","import { Transaction, TransactionContext } from '@sentry/types';\nimport { addInstrumentationHandler, logger } from '@sentry/utils';\n\nimport { WINDOW } from './types';\n\n/**\n * Default function implementing pageload and navigation transactions\n */\nexport function instrumentRoutingWithDefaults<T extends Transaction>(\n  customStartTransaction: (context: TransactionContext) => T | undefined,\n  startTransactionOnPageLoad: boolean = true,\n  startTransactionOnLocationChange: boolean = true,\n): void {\n  if (!WINDOW || !WINDOW.location) {\n    __DEBUG_BUILD__ && logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  let startingUrl: string | undefined = WINDOW.location.href;\n\n  let activeTransaction: T | undefined;\n  if (startTransactionOnPageLoad) {\n    activeTransaction = customStartTransaction({\n      name: WINDOW.location.pathname,\n      op: 'pageload',\n      metadata: { source: 'url' },\n    });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler('history', ({ to, from }: { to: string; from?: string }) => {\n      /**\n       * This early return is there to account for some cases where a navigation transaction starts right after\n       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n       * create an uneccessary navigation transaction.\n       *\n       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n       * only be caused in certain development environments where the usage of a hot module reloader is causing\n       * errors.\n       */\n      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n        startingUrl = undefined;\n        return;\n      }\n\n      if (from !== to) {\n        startingUrl = undefined;\n        if (activeTransaction) {\n          __DEBUG_BUILD__ && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);\n          // If there's an open transaction on the scope, we need to finish it before creating an new one.\n          activeTransaction.finish();\n        }\n        activeTransaction = customStartTransaction({\n          name: WINDOW.location.pathname,\n          op: 'navigation',\n          metadata: { source: 'url' },\n        });\n      }\n    });\n  }\n}\n","import { logger } from '@sentry/utils';\n\nimport { IdleTransaction } from '../idletransaction';\nimport { SpanStatusType } from '../span';\nimport { getActiveTransaction } from '../utils';\nimport { WINDOW } from './types';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nexport function registerBackgroundTabDetection(): void {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeTransaction = getActiveTransaction() as IdleTransaction;\n      if (WINDOW.document.hidden && activeTransaction) {\n        const statusType: SpanStatusType = 'cancelled';\n\n        __DEBUG_BUILD__ &&\n          logger.log(\n            `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,\n          );\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(statusType);\n        }\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    __DEBUG_BUILD__ &&\n      logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n","import { addExtensionMethods } from './hubextensions';\nimport * as Integrations from './integrations';\n\nexport type { RequestInstrumentationOptions } from './browser';\nexport type { SpanStatusType } from './span';\n\nexport { Integrations };\n\n// This is already exported as part of `Integrations` above (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// Previously we expected users to import tracing integrations like\n//\n// import { Integrations } from '@sentry/tracing';\n// const instance = new Integrations.BrowserTracing();\n//\n// This makes the integrations unable to be treeshaken though. To address this, we now have\n// this individual export. We now expect users to consume BrowserTracing like so:\n//\n// import { BrowserTracing } from '@sentry/tracing';\n// const instance = new BrowserTracing();\n//\n// For an example of of the new usage of BrowserTracing, see @sentry/nextjs index.client.ts\nexport { BrowserTracing, BROWSER_TRACING_INTEGRATION_ID } from './browser';\n\nexport { Span, spanStatusfromHttpCode } from './span';\n// eslint-disable-next-line deprecation/deprecation\nexport { SpanStatus } from './spanstatus';\nexport { Transaction } from './transaction';\nexport { instrumentOutgoingRequests, defaultRequestInstrumentationOptions } from './browser';\nexport { IdleTransaction } from './idletransaction';\nexport { startIdleTransaction } from './hubextensions';\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  addExtensionMethods();\n}\n\nexport { addExtensionMethods };\n\nexport {\n  extractTraceparentData,\n  getActiveTransaction,\n  hasTracingEnabled,\n  stripUrlQueryAndFragment,\n  TRACEPARENT_REGEXP,\n} from './utils';\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport { WrappedFunction } from '@sentry/types';\n\nimport { isInstanceOf, isString } from './is';\nimport { CONSOLE_LEVELS, logger } from './logger';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\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/** 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 WINDOW)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level: string): void {\n    if (!(level in WINDOW.console)) {\n      return;\n    }\n\n    fill(WINDOW.console, level, function (originalConsoleMethod: () => any): Function {\n      return function (...args: any[]): void {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(WINDOW.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch(): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(WINDOW, 'fetch', function (originalFetch: () => void): () => void {\n    return function (...args: any[]): void {\n      const handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\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(WINDOW, 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\ntype XHRSendInput = null | Blob | BufferSource | FormData | URLSearchParams | string;\n\n/** JSDoc */\ninterface SentryWrappedXMLHttpRequest extends XMLHttpRequest {\n  [key: string]: any;\n  __sentry_xhr__?: {\n    method?: string;\n    url?: string;\n    status_code?: number;\n    body?: XHRSendInput;\n  };\n}\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs: any[] = []): string {\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs: any[] = []): string {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\nfunction instrumentXHR(): void {\n  if (!('XMLHttpRequest' in WINDOW)) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen: () => void): () => void {\n    return function (this: SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const xhr = this;\n      const url = args[1];\n      const xhrInfo: SentryWrappedXMLHttpRequest['__sentry_xhr__'] = (xhr.__sentry_xhr__ = {\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      });\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        xhr.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = function (): void {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original: WrappedFunction): Function {\n          return function (...readyStateArgs: any[]): void {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend: () => void): () => void {\n    return function (this: SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.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 */\nfunction instrumentDOM(): void {\n  if (!('document' in WINDOW)) {\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 += 1;\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 -= 1;\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: OnErrorEventHandler = null;\n/** JSDoc */\nfunction instrumentError(): void {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg: any, url: any, line: any, column: any, error: any): boolean {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler: ((e: any) => void) | 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) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n","import { 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 { DsnComponents, DsnLike, DsnProtocol } from '@sentry/types';\n\nimport { SentryError } from './error';\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\n */\nexport function dsnFromString(str: string): DsnComponents {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\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 | void {\n  if (!__DEBUG_BUILD__) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents: ReadonlyArray<keyof DsnComponents> = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nexport function makeDsn(from: DsnLike): DsnComponents {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n","/* eslint-disable max-lines */\nimport {\n  Breadcrumb,\n  BreadcrumbHint,\n  Client,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Hub as HubInterface,\n  Integration,\n  IntegrationClass,\n  Primitive,\n  Session,\n  SessionContext,\n  Severity,\n  SeverityLevel,\n  Transaction,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport {\n  consoleSandbox,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  GLOBAL_OBJ,\n  isNodeEnv,\n  logger,\n} from '@sentry/utils';\n\nimport { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\n\nconst NIL_EVENT_ID = '00000000000000000000000000000000';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\nexport interface Layer {\n  client?: Client;\n  scope?: Scope;\n}\n\n/**\n * An object that contains a hub and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n  __SENTRY__?: {\n    hub?: Hub;\n    /**\n     * Extra Hub properties injected by various SDKs\n     */\n    integrations?: Integration[];\n    extensions?: {\n      /** Hack to prevent bundlers from breaking our usage of the domain package in the cross-platform Hub package */\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      domain?: { [key: string]: any };\n    } & {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n}\n\n/**\n * @inheritDoc\n */\nexport class Hub implements HubInterface {\n  /** Is a {@link Layer}[] containing the client and scope */\n  private readonly _stack: Layer[] = [{}];\n\n  /** Contains the last event id of a captured event.  */\n  private _lastEventId?: string;\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n  public constructor(client?: Client, scope: Scope = new Scope(), private readonly _version: number = API_VERSION) {\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isOlderThan(version: number): boolean {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public bindClient(client?: Client): void {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public pushScope(): Scope {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public popScope(): boolean {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public withScope(callback: (scope: Scope) => void): void {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this.getStackTop().client as C;\n  }\n\n  /** Returns the scope of the top stack. */\n  public getScope(): Scope | undefined {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n  public getStack(): Layer[] {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint): string {\n    const syntheticException = new Error('Sentry syntheticException');\n    this._lastEventId =\n      this._withClient((client, scope) => {\n        return client.captureException(\n          exception,\n          {\n            originalException: exception,\n            syntheticException,\n            ...hint,\n          },\n          scope,\n        );\n      }) || NIL_EVENT_ID;\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n  ): string {\n    const syntheticException = new Error(message);\n    this._lastEventId =\n      this._withClient((client, scope) => {\n        return client.captureMessage(\n          message,\n          level,\n          {\n            originalException: message,\n            syntheticException,\n            ...hint,\n          },\n          scope,\n        );\n      }) || NIL_EVENT_ID;\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const clientId =\n      this._withClient((client, scope) => {\n        return client.captureEvent(event, { ...hint }, scope);\n      }) || NIL_EVENT_ID;\n\n    if (event.type !== 'transaction') {\n      this._lastEventId = clientId;\n    }\n\n    return clientId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): void {\n    const scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): void {\n    const scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public setContext(name: string, context: { [key: string]: any } | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public configureScope(callback: (scope: Scope) => void): void {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public run(callback: (hub: Hub) => void): void {\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startTransaction(context: TransactionContext, customSamplingContext?: CustomSamplingContext): Transaction {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public traceHeaders(): { [key: string]: string } {\n    return this._callExtensionMethod<{ [key: string]: string }>('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureSession(endSession: boolean = false): void {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public endSession(): void {\n    const layer = this.getStackTop();\n    const scope = layer && layer.scope;\n    const session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startSession(context?: SessionContext): Session {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      const currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n  public shouldSendDefaultPii(): boolean {\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n  private _sendSessionUpdate(): void {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n  private _withClient<T>(callback: (client: Client, scope: Scope | undefined) => T): T | undefined {\n    const { scope, client } = this.getStackTop();\n    return client && callback(client, scope);\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    __DEBUG_BUILD__ && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return GLOBAL_OBJ;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub: Hub): Hub {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub(): Hub {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry: Carrier): Hub {\n  try {\n    const sentry = getMainCarrier().__SENTRY__;\n    const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier: Carrier): boolean {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier: Carrier): Hub {\n  return getGlobalSingleton<Hub>('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n\nimport { PolymorphicEvent, Primitive } from '@sentry/types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record<string, unknown> {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike<any> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isNaN(wat: unknown): boolean {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n","/**\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): {\n  host?: string;\n  path?: string;\n  protocol?: string;\n  relative?: string;\n} {\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    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","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { WrappedFunction } from '@sentry/types';\n\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacementFactory(original) as WrappedFunction;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: { [key: string]: unknown }, name: string, value: unknown): void {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nexport function getOriginalFunction(func: WrappedFunction): WrappedFunction | undefined {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object: { [key: string]: any }): string {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nexport function convertToPlainObject<V extends unknown>(\n  value: V,\n):\n  | {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    }\n  | {\n      [ownProps: string]: unknown;\n      message: string;\n      name: string;\n      stack?: string;\n    }\n  | V {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj: {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    } = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps: { [key: string]: unknown } = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj as Record<string, unknown>)[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nexport function dropUndefinedKeys<T>(inputValue: T): T {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map<unknown, unknown>();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: { [key: string]: any } = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue as T;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: unknown[] = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item: unknown) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue as unknown as T;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat as any).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n","/**\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 { Integration } from '@sentry/types';\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  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n    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\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","import { Integration, WrappedFunction } from '@sentry/types';\nimport { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString: () => void;\n\n/** Patch toString calls to return proper name for wrapped functions */\nexport class FunctionToString implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'FunctionToString';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = FunctionToString.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    originalFunctionToString = Function.prototype.toString;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Function.prototype.toString = function (this: WrappedFunction, ...args: any[]): string {\n      const context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n}\n","import { Event, EventProcessor, Hub, Integration, StackFrame } from '@sentry/types';\nimport { getEventDescription, logger, stringMatchesSomePattern } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\nexport interface InboundFiltersOptions {\n  allowUrls: Array<string | RegExp>;\n  denyUrls: Array<string | RegExp>;\n  ignoreErrors: Array<string | RegExp>;\n  ignoreInternal: boolean;\n}\n\n/** Inbound filters configurable by the user */\nexport class InboundFilters implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'InboundFilters';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = InboundFilters.id;\n\n  public constructor(private readonly _options: Partial<InboundFiltersOptions> = {}) {}\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (processor: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const eventProcess: EventProcessor = (event: Event) => {\n      const hub = getCurrentHub();\n      if (hub) {\n        const self = hub.getIntegration(InboundFilters);\n        if (self) {\n          const client = hub.getClient();\n          const clientOptions = client ? client.getOptions() : {};\n          const options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n}\n\n/** JSDoc */\nexport function _mergeOptions(\n  internalOptions: Partial<InboundFiltersOptions> = {},\n  clientOptions: Partial<InboundFiltersOptions> = {},\n): Partial<InboundFiltersOptions> {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nexport function _shouldDropEvent(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): boolean {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));\n}\n\nfunction _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : stringMatchesSomePattern(url, denyUrls);\n}\n\nfunction _isAllowedUrl(event: Event, allowUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : stringMatchesSomePattern(url, allowUrls);\n}\n\nfunction _getPossibleEventMessages(event: Event): string[] {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      __DEBUG_BUILD__ && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event: Event): boolean {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames: StackFrame[] = []): string | null {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event: Event): string | null {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    __DEBUG_BUILD__ && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n","import {\n  Breadcrumb,\n  CaptureContext,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Primitive,\n  Severity,\n  SeverityLevel,\n  TransactionContext,\n  User,\n} from '@sentry/types';\n\nimport { getCurrentHub, Hub } from './hub';\nimport { Scope } from './scope';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception: any, captureContext?: CaptureContext): ReturnType<Hub['captureException']> {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(\n  message: string,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext?: CaptureContext | Severity | SeverityLevel,\n): ReturnType<Hub['captureMessage']> {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event: Event, hint?: EventHint): ReturnType<Hub['captureEvent']> {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']> {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb: Breadcrumb): ReturnType<Hub['addBreadcrumb']> {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name: string, context: { [key: string]: any } | null): ReturnType<Hub['setContext']> {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']> {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['setTags']> {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']> {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user: User | null): ReturnType<Hub['setUser']> {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback: (scope: Scope) => void): ReturnType<Hub['withScope']> {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(\n  context: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n): ReturnType<Hub['startTransaction']> {\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n","import { getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, Severity, SeverityLevel, StackFrame, StackParser } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nexport function eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const hub = getCurrentHub();\n  const client = hub.getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  const event: Event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception, normalizeDepth),\n    },\n  };\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception as { values: Exception[] }).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nexport function parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex: Error & { framesToPop?: number }): number {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  stackParser: StackParser,\n  message: string,\n  // eslint-disable-next-line deprecation/deprecation\n  level: Severity | SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  stackParser: StackParser,\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(stackParser, errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception as DOMError) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromString(\n  stackParser: StackParser,\n  input: string,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n","import { captureException, withScope } from '@sentry/core';\nimport { DsnLike, Event as SentryEvent, Mechanism, Scope, WrappedFunction } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  getOriginalFunction,\n  GLOBAL_OBJ,\n  markFunctionWrapped,\n} from '@sentry/utils';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(\n  fn: WrappedFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n  before?: WrappedFunction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  /* eslint-disable prefer-rest-params */\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped: WrappedFunction = function (this: unknown): void {\n    const args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n      const wrappedArguments = args.map((arg: any) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope: Scope) => {\n        scope.addEventProcessor((event: SentryEvent) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} // eslint-disable-line no-empty\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') as PropertyDescriptor;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n    // eslint-disable-next-line no-empty\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\nexport interface ReportDialogOptions {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n  eventId?: string;\n  dsn?: DsnLike;\n  user?: {\n    email?: string;\n    name?: string;\n  };\n  lang?: string;\n  title?: string;\n  subtitle?: string;\n  subtitle2?: string;\n  labelName?: string;\n  labelEmail?: string;\n  labelComments?: string;\n  labelClose?: string;\n  labelSubmit?: string;\n  errorGeneric?: string;\n  errorFormEntry?: string;\n  successMessage?: string;\n  /** Callback after reportDialog showed up */\n  onLoad?(): void;\n}\n","/* eslint-disable deprecation/deprecation */\nimport { 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","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Integration } from '@sentry/types';\nimport {\n  addInstrumentationHandler,\n  htmlTreeAsString,\n  parseUrl,\n  safeJoin,\n  severityLevelFromString,\n} from '@sentry/utils';\n\nimport { WINDOW } from '../helpers';\n\n/** JSDoc */\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom: boolean | { serializeAttribute: string | string[] };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\nexport const BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nexport class Breadcrumbs implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = BREADCRUMB_INTEGRATION_ID;\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Breadcrumbs.id;\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n  public readonly options: Readonly<BreadcrumbsOptions>;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: Partial<BreadcrumbsOptions>) {\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n  public setupOnce(): void {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n}\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom: BreadcrumbsOptions['dom']): (handlerData: { [key: string]: any }) => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function _innerDomBreadcrumb(handlerData: { [key: string]: any }): void {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target as Node, keyAttrs)\n        : htmlTreeAsString(handlerData.event as unknown as Node, keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData: { [key: string]: any }): void {\n  // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n  // console warnings. This happens when a Vue template is rendered with\n  // an undeclared variable, which we try to stringify, ultimately causing\n  // Vue to issue another warning which repeats indefinitely.\n  // see: https://github.com/getsentry/sentry-javascript/pull/6010\n  // see: https://github.com/getsentry/sentry-javascript/issues/5916\n  for (let i = 0; i < handlerData.args.length; i++) {\n    if (handlerData.args[i] === 'ref=Ref<') {\n      handlerData.args[i + 1] = 'viewRef';\n      break;\n    }\n  }\n  const breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData: { [key: string]: any }): void {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData: { [key: string]: any }): void {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData: { [key: string]: any }): void {\n  let from = handlerData.from;\n  let to = handlerData.to;\n  const parsedLoc = parseUrl(WINDOW.location.href);\n  let parsedFrom = parseUrl(from);\n  const parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n","import { BaseClient, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth, Scope, SDK_VERSION } from '@sentry/core';\nimport { ClientOptions, Event, EventHint, Options, Severity, SeverityLevel } from '@sentry/types';\nimport { createClientReportEnvelope, dsnToString, getEventDescription, logger, serializeEnvelope } from '@sentry/utils';\n\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { WINDOW } from './helpers';\nimport { Breadcrumbs } from './integrations';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs';\nimport { BrowserTransportOptions } from './transports/types';\n\nexport interface BaseBrowserOptions {\n  /**\n   * A pattern for error URLs which should exclusively be sent to Sentry.\n   * This is the opposite of {@link Options.denyUrls}.\n   * By default, all errors will be sent.\n   */\n  allowUrls?: Array<string | RegExp>;\n\n  /**\n   * A pattern for error URLs which should not be sent to Sentry.\n   * To allow certain errors instead, use {@link Options.allowUrls}.\n   * By default, all errors will be sent.\n   */\n  denyUrls?: Array<string | RegExp>;\n}\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/types Options for more information.\n */\nexport interface BrowserOptions extends Options<BrowserTransportOptions>, BaseBrowserOptions {}\n\n/**\n * Configuration options for the Sentry Browser SDK Client class\n * @see BrowserClient for more information.\n */\nexport interface BrowserClientOptions extends ClientOptions<BrowserTransportOptions>, BaseBrowserOptions {}\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nexport class BrowserClient extends BaseClient<BrowserClientOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserClientOptions) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel = 'info',\n    hint?: EventHint,\n  ): PromiseLike<Event> {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event, hint?: EventHint): void {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    const breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) as Breadcrumbs | null;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n  private _flushOutcomes(): void {\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      __DEBUG_BUILD__ && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      __DEBUG_BUILD__ && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    __DEBUG_BUILD__ && logger.log('Sending outcomes:', outcomes);\n\n    const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      const isRealNavigator = Object.prototype.toString.call(WINDOW && WINDOW.navigator) === '[object Navigator]';\n      const hasSendBeacon = isRealNavigator && typeof WINDOW.navigator.sendBeacon === 'function';\n      // Make sure beacon is not used if user configures custom transport options\n      if (hasSendBeacon && !this._options.transportOptions) {\n        // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n        const sendBeacon = WINDOW.navigator.sendBeacon.bind(WINDOW.navigator);\n        sendBeacon(url, serializeEnvelope(envelope));\n      } else {\n        // If beacon is not supported or if they are using the tunnel option\n        // use our regular transport to send client reports to Sentry.\n        this._sendEnvelope(envelope);\n      }\n    } catch (e) {\n      __DEBUG_BUILD__ && logger.error(e);\n    }\n  }\n}\n","import { 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 { StackFrame, StackLineParser, StackLineParserFn } from '@sentry/types';\nimport { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {\n  const frame: StackFrame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n  /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nconst chrome: StackLineParserFn = line => {\n  const parts = chromeRegex.exec(line);\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nexport const chromeStackLineParser: StackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko: StackLineParserFn = line => {\n  const parts = geckoREgex.exec(line);\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nexport const geckoStackLineParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nexport const winjsStackLineParser: StackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10: StackLineParserFn = line => {\n  const parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackLineParser: StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11: StackLineParserFn = line => {\n  const parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackLineParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\nexport const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nexport const defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\n\nimport { WINDOW, wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\n/** JSDoc */\ninterface TryCatchOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n}\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nexport class TryCatch implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'TryCatch';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = TryCatch.id;\n\n  /** JSDoc */\n  private readonly _options: TryCatchOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: Partial<TryCatchOptions>) {\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n  public setupOnce(): void {\n    if (this._options.setTimeout) {\n      fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(WINDOW, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    const eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n}\n\n/** JSDoc */\nfunction _wrapTimeFunction(original: () => void): () => number {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, ...args: any[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original: any): (callback: () => void) => any {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, callback: () => void): () => void {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend: () => void): () => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: XMLHttpRequest, ...args: any[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        fill(xhr, prop, function (original: WrappedFunction): () => any {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target: string): void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObject = WINDOW as { [key: string]: any };\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const proto = globalObject[target] && globalObject[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: () => void): (\n    eventName: string,\n    fn: EventListenerObject,\n    options?: boolean | AddEventListenerOptions,\n  ) => void {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this: any,\n      eventName: string,\n      fn: EventListenerObject,\n      options?: boolean | AddEventListenerOptions,\n    ): (eventName: string, fn: EventListenerObject, capture?: boolean, secure?: boolean) => void {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        wrap(fn as any as WrappedFunction, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener: () => void,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): (this: any, eventName: string, fn: EventListenerObject, options?: boolean | EventListenerOptions) => () => void {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this: any,\n        eventName: string,\n        fn: EventListenerObject,\n        options?: boolean | EventListenerOptions,\n      ): () => void {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        const wrappedEventHandler = fn as unknown as WrappedFunction;\n        try {\n          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Hub, Integration, Primitive, StackParser } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addInstrumentationHandler,\n  getLocationHref,\n  isErrorEvent,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\n/** JSDoc */\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\n/** Global handlers */\nexport class GlobalHandlers implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'GlobalHandlers';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = GlobalHandlers.id;\n\n  /** JSDoc */\n  private readonly _options: GlobalHandlersIntegrations;\n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n  private _installFunc: Record<GlobalHandlersIntegrationsOptionKeys, (() => void) | undefined> = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };\n\n  /** JSDoc */\n  public constructor(options?: GlobalHandlersIntegrations) {\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    Error.stackTraceLimit = 50;\n    const options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n    // eslint-disable-next-line guard-for-in\n    for (const key in options) {\n      const installFunc = this._installFunc[key as GlobalHandlersIntegrationsOptionKeys];\n      if (installFunc && options[key as GlobalHandlersIntegrationsOptionKeys]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key as GlobalHandlersIntegrationsOptionKeys] = undefined;\n      }\n    }\n  }\n}\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler(): void {\n  addInstrumentationHandler(\n    'error',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (data: { msg: any; url: any; line: any; column: any; error: any }) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      const event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler(): void {\n  addInstrumentationHandler(\n    'unhandledrejection',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (e: any) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      const event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason: Primitive): Event {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg: any, url: any, line: any, column: any): Event {\n  const ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  const groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event: Event, url: any, line: any, column: any): Event {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  __DEBUG_BUILD__ && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub: Hub, error: EventHint['originalException'], event: Event, type: string): void {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions(): [Hub, StackParser, boolean | undefined] {\n  const hub = getCurrentHub();\n  const client = hub.getClient<BrowserClient>();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { exceptionFromError } from '../eventbuilder';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\ninterface LinkedErrorsOptions {\n  key: string;\n  limit: number;\n}\n\n/** Adds SDK info to an event. */\nexport class LinkedErrors implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'LinkedErrors';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = LinkedErrors.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _key: LinkedErrorsOptions['key'];\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: LinkedErrorsOptions['limit'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: Partial<LinkedErrorsOptions> = {}) {\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    const client = getCurrentHub().getClient<BrowserClient>();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n}\n\n/**\n * @inheritDoc\n */\nexport function _handler(\n  parser: StackParser,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): Event | null {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(parser, limit, hint.originalException as ExtendedError, key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nexport function _walkErrorTree(\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  stack: Exception[] = [],\n): Exception[] {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n","import { Event, EventProcessor, Exception, Hub, Integration, StackFrame } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nexport class Dedupe implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Dedupe';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Dedupe.id;\n\n  /**\n   * @inheritDoc\n   */\n  private _previousEvent?: Event;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const eventProcessor: EventProcessor = currentEvent => {\n      const self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            __DEBUG_BUILD__ && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames as StackFrame[];\n  previousFrames = previousFrames as StackFrame[];\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    const frameA = previousFrames[i];\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint as string[];\n  previousFingerprint = previousFingerprint as string[];\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event: Event): Exception | undefined {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event: Event): StackFrame[] | undefined {\n  const exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, Integration } from '@sentry/types';\n\nimport { WINDOW } from '../helpers';\n\n/** HttpContext integration collects information about HTTP request headers */\nexport class HttpContext implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'HttpContext';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = HttpContext.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    addGlobalEventProcessor((event: Event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n        const { referrer } = WINDOW.document || {};\n        const { userAgent } = WINDOW.navigator || {};\n\n        const headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        const request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n}\n","import { isNativeFetch, logger } from '@sentry/utils';\n\nimport { WINDOW } from '../helpers';\n\nlet cachedFetchImpl: FetchImpl | undefined = undefined;\n\nexport type FetchImpl = typeof fetch;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nexport function getNativeFetchImplementation(): FetchImpl {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  /* eslint-disable @typescript-eslint/unbound-method */\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(WINDOW.fetch)) {\n    return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));\n  }\n\n  const document = WINDOW.document;\n  let fetchImpl = WINDOW.fetch;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      __DEBUG_BUILD__ &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(WINDOW));\n  /* eslint-enable @typescript-eslint/unbound-method */\n}\n\n/** Clears cached fetch impl */\nexport function clearCachedFetchImplementation(): void {\n  cachedFetchImpl = undefined;\n}\n","import { createTransport } from '@sentry/core';\nimport { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\nimport { rejectedSyncPromise } from '@sentry/utils';\n\nimport { BrowserTransportOptions } from './types';\nimport { clearCachedFetchImplementation, FetchImpl, getNativeFetchImplementation } from './utils';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeFetchTransport(\n  options: BrowserTransportOptions,\n  nativeFetch: FetchImpl = getNativeFetchImplementation(),\n): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch), a request with `keepalive: true`\n      //   and a content length of > 64 kibibytes returns a network error. We will therefore only activate the flag when\n      //   we're below that limit.\n      keepalive: request.body.length <= 65536,\n      ...options.fetchOptions,\n    };\n\n    try {\n      return nativeFetch(options.url, requestOptions).then(response => ({\n        statusCode: response.status,\n        headers: {\n          'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n          'retry-after': response.headers.get('Retry-After'),\n        },\n      }));\n    } catch (e) {\n      clearCachedFetchImplementation();\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import { createTransport } from '@sentry/core';\nimport { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n\nimport { BrowserTransportOptions } from './types';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nexport function makeXHRTransport(options: BrowserTransportOptions): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    return new SyncPromise((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = (): void => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (const header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import {\n  getCurrentHub,\n  getIntegrationsToSetup,\n  getReportDialogEndpoint,\n  Hub,\n  initAndBind,\n  Integrations as CoreIntegrations,\n} from '@sentry/core';\nimport {\n  addInstrumentationHandler,\n  logger,\n  resolvedSyncPromise,\n  stackParserFromStackParserOptions,\n  supportsFetch,\n} from '@sentry/utils';\n\nimport { BrowserClient, BrowserClientOptions, BrowserOptions } from './client';\nimport { ReportDialogOptions, WINDOW, wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, Dedupe, GlobalHandlers, HttpContext, LinkedErrors, TryCatch } from './integrations';\nimport { defaultStackParser } from './stack-parsers';\nimport { makeFetchTransport, makeXHRTransport } from './transports';\n\nexport const defaultIntegrations = [\n  new CoreIntegrations.InboundFilters(),\n  new CoreIntegrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options: BrowserOptions = {}): void {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    // This supports the variable that sentry-webpack-plugin injects\n    if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {\n      options.release = WINDOW.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  const clientOptions: BrowserClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options: ReportDialogOptions = {}, hub: Hub = getCurrentHub()): void {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    __DEBUG_BUILD__ && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  const dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    __DEBUG_BUILD__ && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    script.onload = options.onLoad;\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    __DEBUG_BUILD__ && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId(): string | undefined {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad(): void {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback: () => void): void {\n  callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function flush(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.flush(timeout);\n  }\n  __DEBUG_BUILD__ && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function close(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.close(timeout);\n  }\n  __DEBUG_BUILD__ && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn: (...args: any) => any): any {\n  return internalWrap(fn)();\n}\n\nfunction startSessionOnHub(hub: Hub): void {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  if (typeof WINDOW.document === 'undefined') {\n    __DEBUG_BUILD__ &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  const hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n","import { Client, ClientOptions } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { getCurrentHub } from './hub';\n\n/** A class object that can instantiate Client objects. */\nexport type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind<F extends Client, O extends ClientOptions>(\n  clientClass: ClientClass<F, O>,\n  options: O,\n): void {\n  if (options.debug === true) {\n    if (__DEBUG_BUILD__) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      // eslint-disable-next-line no-console\n      console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  const hub = getCurrentHub();\n  const scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  const client = new clientClass(options);\n  hub.bindClient(client);\n}\n","import { SerializedSession, Session, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session: Session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n","import { 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// Re-exported with an old name for backwards-compatibility.\nexport const timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport const usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport let _browserPerformanceTimeOriginMode: string;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport const browserPerformanceTimeOrigin = ((): number | undefined => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = 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","/* eslint-disable max-lines */\nimport {\n  Attachment,\n  Breadcrumb,\n  CaptureContext,\n  Context,\n  Contexts,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Primitive,\n  RequestSession,\n  Scope as ScopeInterface,\n  ScopeContext,\n  Session,\n  Severity,\n  SeverityLevel,\n  Span,\n  Transaction,\n  User,\n} from '@sentry/types';\nimport {\n  arrayify,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  isPlainObject,\n  isThenable,\n  logger,\n  SyncPromise,\n} from '@sentry/utils';\n\nimport { updateSession } from './session';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nexport class Scope implements ScopeInterface {\n  /** Flag if notifying is happening. */\n  protected _notifyingListeners: boolean;\n\n  /** Callback for client to receive scope changes. */\n  protected _scopeListeners: Array<(scope: Scope) => void>;\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  protected _eventProcessors: EventProcessor[];\n\n  /** Array of breadcrumbs. */\n  protected _breadcrumbs: Breadcrumb[];\n\n  /** User */\n  protected _user: User;\n\n  /** Tags */\n  protected _tags: { [key: string]: Primitive };\n\n  /** Extra */\n  protected _extra: Extras;\n\n  /** Contexts */\n  protected _contexts: Contexts;\n\n  /** Attachments */\n  protected _attachments: Attachment[];\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  protected _sdkProcessingMetadata: { [key: string]: unknown };\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n  protected _level?: Severity | SeverityLevel;\n\n  /** Transaction Name */\n  protected _transactionName?: string;\n\n  /** Span */\n  protected _span?: Span;\n\n  /** Session */\n  protected _session?: Session;\n\n  /** Request Mode Session Status */\n  protected _requestSession?: RequestSession;\n\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n\n  public constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n  public static clone(scope?: Scope): Scope {\n    const newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n      newScope._sdkProcessingMetadata = { ...scope._sdkProcessingMetadata };\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n  public addScopeListener(callback: (scope: Scope) => void): void {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addEventProcessor(callback: EventProcessor): this {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): this {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getUser(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getRequestSession(): RequestSession | undefined {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setRequestSession(requestSession?: RequestSession): this {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): this {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): this {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): this {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setFingerprint(fingerprint: string[]): this {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setLevel(\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel,\n  ): this {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTransactionName(name?: string): this {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSpan(span?: Span): this {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSpan(): Span | undefined {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransaction(): Transaction | undefined {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSession(session?: Session): this {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSession(): Session | undefined {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public update(captureContext?: CaptureContext): this {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      const updatedScope = (captureContext as <T>(scope: T) => T)(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n      // eslint-disable-next-line no-param-reassign\n      captureContext = captureContext as ScopeContext;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clear(): this {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearBreadcrumbs(): this {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addAttachment(attachment: Attachment): this {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getAttachments(): Attachment[] {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearAttachments(): this {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   */\n  public applyToEvent(event: Event, hint: EventHint = {}): PromiseLike<Event | null> {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n  public setSDKProcessingMetadata(newData: { [key: string]: unknown }): this {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n  protected _notifyEventProcessors(\n    processors: EventProcessor[],\n    event: Event | null,\n    hint: EventHint,\n    index: number = 0,\n  ): PromiseLike<Event | null> {\n    return new SyncPromise<Event | null>((resolve, reject) => {\n      const processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        const result = processor({ ...event }, hint) as Event | null;\n\n        __DEBUG_BUILD__ &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n  protected _notifyScopeListeners(): void {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n  private _applyFingerprint(event: Event): void {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors(): EventProcessor[] {\n  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n  getGlobalEventProcessors().push(callback);\n}\n","/**\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","/* eslint-disable max-lines */\nimport { Instrumenter, Primitive, Span as SpanInterface, SpanContext, Transaction } from '@sentry/types';\nimport { dropUndefinedKeys, logger, timestampWithMs, uuid4 } from '@sentry/utils';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nexport class SpanRecorder {\n  public spans: Span[] = [];\n\n  private readonly _maxlen: number;\n\n  public constructor(maxlen: number = 1000) {\n    this._maxlen = maxlen;\n  }\n\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n  public add(span: Span): void {\n    if (this.spans.length > this._maxlen) {\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  }\n}\n\n/**\n * Span contains all data about a span\n */\nexport class Span implements SpanInterface {\n  /**\n   * @inheritDoc\n   */\n  public traceId: string = uuid4();\n\n  /**\n   * @inheritDoc\n   */\n  public spanId: string = uuid4().substring(16);\n\n  /**\n   * @inheritDoc\n   */\n  public parentSpanId?: string;\n\n  /**\n   * Internal keeper of the status\n   */\n  public status?: SpanStatusType | string;\n\n  /**\n   * @inheritDoc\n   */\n  public sampled?: boolean;\n\n  /**\n   * Timestamp in seconds when the span was created.\n   */\n  public startTimestamp: number = timestampWithMs();\n\n  /**\n   * Timestamp in seconds when the span ended.\n   */\n  public endTimestamp?: number;\n\n  /**\n   * @inheritDoc\n   */\n  public op?: string;\n\n  /**\n   * @inheritDoc\n   */\n  public description?: string;\n\n  /**\n   * @inheritDoc\n   */\n  public tags: { [key: string]: Primitive } = {};\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public data: { [key: string]: any } = {};\n\n  /**\n   * List of spans that were finalized\n   */\n  public spanRecorder?: SpanRecorder;\n\n  /**\n   * @inheritDoc\n   */\n  public transaction?: Transaction;\n\n  /**\n   * The instrumenter that created this span.\n   */\n  public instrumenter: Instrumenter = 'sentry';\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  public constructor(spanContext?: SpanContext) {\n    if (!spanContext) {\n      return this;\n    }\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n    if (spanContext.instrumenter) {\n      this.instrumenter = spanContext.instrumenter;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startChild(\n    spanContext?: Pick<SpanContext, Exclude<keyof SpanContext, 'sampled' | 'traceId' | 'parentSpanId'>>,\n  ): Span {\n    const childSpan = new Span({\n      ...spanContext,\n      parentSpanId: this.spanId,\n      sampled: this.sampled,\n      traceId: this.traceId,\n    });\n\n    childSpan.spanRecorder = this.spanRecorder;\n    if (childSpan.spanRecorder) {\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    childSpan.transaction = this.transaction;\n\n    if (__DEBUG_BUILD__ && childSpan.transaction) {\n      const opStr = (spanContext && spanContext.op) || '< unknown op >';\n      const nameStr = childSpan.transaction.name || '< unknown name >';\n      const idStr = childSpan.transaction.spanId;\n\n      const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;\n      childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = { logMessage };\n      logger.log(logMessage);\n    }\n\n    return childSpan;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this.tags = { ...this.tags, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public setData(key: string, value: any): this {\n    this.data = { ...this.data, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setStatus(value: SpanStatusType): this {\n    this.status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setHttpStatus(httpStatus: number): this {\n    this.setTag('http.status_code', String(httpStatus));\n    const spanStatus = spanStatusfromHttpCode(httpStatus);\n    if (spanStatus !== 'unknown_error') {\n      this.setStatus(spanStatus);\n    }\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isSuccess(): boolean {\n    return this.status === 'ok';\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public finish(endTimestamp?: number): void {\n    if (\n      __DEBUG_BUILD__ &&\n      // Don't call this for transactions\n      this.transaction &&\n      this.transaction.spanId !== this.spanId\n    ) {\n      const { logMessage } = this.transaction.metadata.spanMetadata[this.spanId];\n      if (logMessage) {\n        logger.log((logMessage as string).replace('Starting', 'Finishing'));\n      }\n    }\n\n    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toTraceparent(): string {\n    let sampledString = '';\n    if (this.sampled !== undefined) {\n      sampledString = this.sampled ? '-1' : '-0';\n    }\n    return `${this.traceId}-${this.spanId}${sampledString}`;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toContext(): SpanContext {\n    return dropUndefinedKeys({\n      data: this.data,\n      description: this.description,\n      endTimestamp: this.endTimestamp,\n      op: this.op,\n      parentSpanId: this.parentSpanId,\n      sampled: this.sampled,\n      spanId: this.spanId,\n      startTimestamp: this.startTimestamp,\n      status: this.status,\n      tags: this.tags,\n      traceId: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateWithContext(spanContext: SpanContext): this {\n    this.data = spanContext.data ?? {};\n    this.description = spanContext.description;\n    this.endTimestamp = spanContext.endTimestamp;\n    this.op = spanContext.op;\n    this.parentSpanId = spanContext.parentSpanId;\n    this.sampled = spanContext.sampled;\n    this.spanId = spanContext.spanId ?? this.spanId;\n    this.startTimestamp = spanContext.startTimestamp ?? this.startTimestamp;\n    this.status = spanContext.status;\n    this.tags = spanContext.tags ?? {};\n    this.traceId = spanContext.traceId ?? this.traceId;\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTraceContext(): {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    data?: { [key: string]: any };\n    description?: string;\n    op?: string;\n    parent_span_id?: string;\n    span_id: string;\n    status?: string;\n    tags?: { [key: string]: Primitive };\n    trace_id: string;\n  } {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      trace_id: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toJSON(): {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    data?: { [key: string]: any };\n    description?: string;\n    op?: string;\n    parent_span_id?: string;\n    span_id: string;\n    start_timestamp: number;\n    status?: string;\n    tags?: { [key: string]: Primitive };\n    timestamp?: number;\n    trace_id: string;\n  } {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      start_timestamp: this.startTimestamp,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this.endTimestamp,\n      trace_id: this.traceId,\n    });\n  }\n}\n\nexport type SpanStatusType =\n  /** The operation completed successfully. */\n  | 'ok'\n  /** Deadline expired before operation could complete. */\n  | 'deadline_exceeded'\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n  | 'unauthenticated'\n  /** 403 Forbidden */\n  | 'permission_denied'\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n  | 'not_found'\n  /** 429 Too Many Requests */\n  | 'resource_exhausted'\n  /** Client specified an invalid argument. 4xx. */\n  | 'invalid_argument'\n  /** 501 Not Implemented */\n  | 'unimplemented'\n  /** 503 Service Unavailable */\n  | 'unavailable'\n  /** Other/generic 5xx. */\n  | 'internal_error'\n  /** Unknown. Any non-standard HTTP status code. */\n  | 'unknown_error'\n  /** The operation was cancelled (typically by the user). */\n  | 'cancelled'\n  /** Already exists (409) */\n  | 'already_exists'\n  /** Operation was rejected because the system is not in a state required for the operation's */\n  | 'failed_precondition'\n  /** The operation was aborted, typically due to a concurrency issue. */\n  | 'aborted'\n  /** Operation was attempted past the valid range. */\n  | 'out_of_range'\n  /** Unrecoverable data loss or corruption */\n  | 'data_loss';\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nexport function spanStatusfromHttpCode(httpStatus: number): SpanStatusType {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n      case 403:\n        return 'permission_denied';\n      case 404:\n        return 'not_found';\n      case 409:\n        return 'already_exists';\n      case 413:\n        return 'failed_precondition';\n      case 429:\n        return 'resource_exhausted';\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n      case 503:\n        return 'unavailable';\n      case 504:\n        return 'deadline_exceeded';\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n","/* eslint-disable max-lines */\nimport { Hub } from '@sentry/core';\nimport { TransactionContext } from '@sentry/types';\nimport { logger, timestampWithMs } from '@sentry/utils';\n\nimport { Span, SpanRecorder } from './span';\nimport { Transaction } from './transaction';\n\nexport const DEFAULT_IDLE_TIMEOUT = 1000;\nexport const DEFAULT_FINAL_TIMEOUT = 30000;\nexport const DEFAULT_HEARTBEAT_INTERVAL = 5000;\n\n/**\n * @inheritDoc\n */\nexport class IdleTransactionSpanRecorder extends SpanRecorder {\n  public constructor(\n    private readonly _pushActivity: (id: string) => void,\n    private readonly _popActivity: (id: string) => void,\n    public transactionSpanId: string,\n    maxlen?: number,\n  ) {\n    super(maxlen);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public add(span: Span): void {\n    // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n    if (span.spanId !== this.transactionSpanId) {\n      // We patch span.finish() to pop an activity after setting an endTimestamp.\n      span.finish = (endTimestamp?: number) => {\n        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n        this._popActivity(span.spanId);\n      };\n\n      // We should only push new activities if the span does not have an end timestamp.\n      if (span.endTimestamp === undefined) {\n        this._pushActivity(span.spanId);\n      }\n    }\n\n    super.add(span);\n  }\n}\n\nexport type BeforeFinishCallback = (transactionSpan: IdleTransaction, endTimestamp: number) => void;\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nexport class IdleTransaction extends Transaction {\n  // Activities store a list of active spans\n  public activities: Record<string, boolean> = {};\n\n  // Track state of activities in previous heartbeat\n  private _prevHeartbeatString: string | undefined;\n\n  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n  private _heartbeatCounter: number = 0;\n\n  // We should not use heartbeat if we finished a transaction\n  private _finished: boolean = false;\n\n  private readonly _beforeFinishCallbacks: BeforeFinishCallback[] = [];\n\n  /**\n   * Timer that tracks Transaction idleTimeout\n   */\n  private _idleTimeoutID: ReturnType<typeof setTimeout> | undefined;\n\n  public constructor(\n    transactionContext: TransactionContext,\n    private readonly _idleHub: Hub,\n    /**\n     * The time to wait in ms until the idle transaction will be finished. This timer is started each time\n     * there are no active spans on this transaction.\n     */\n    private readonly _idleTimeout: number = DEFAULT_IDLE_TIMEOUT,\n    /**\n     * The final value in ms that a transaction cannot exceed\n     */\n    private readonly _finalTimeout: number = DEFAULT_FINAL_TIMEOUT,\n    private readonly _heartbeatInterval: number = DEFAULT_HEARTBEAT_INTERVAL,\n    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n    private readonly _onScope: boolean = false,\n  ) {\n    super(transactionContext, _idleHub);\n\n    if (_onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub);\n\n      // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n      __DEBUG_BUILD__ && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);\n      _idleHub.configureScope(scope => scope.setSpan(this));\n    }\n\n    this._startIdleTimeout();\n    setTimeout(() => {\n      if (!this._finished) {\n        this.setStatus('deadline_exceeded');\n        this.finish();\n      }\n    }, this._finalTimeout);\n  }\n\n  /** {@inheritDoc} */\n  public finish(endTimestamp: number = timestampWithMs()): string | undefined {\n    this._finished = true;\n    this.activities = {};\n\n    if (this.spanRecorder) {\n      __DEBUG_BUILD__ &&\n        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n      for (const callback of this._beforeFinishCallbacks) {\n        callback(this, endTimestamp);\n      }\n\n      this.spanRecorder.spans = this.spanRecorder.spans.filter((span: Span) => {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanId === this.spanId) {\n          return true;\n        }\n\n        // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n        if (!span.endTimestamp) {\n          span.endTimestamp = endTimestamp;\n          span.setStatus('cancelled');\n          __DEBUG_BUILD__ &&\n            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        const keepSpan = span.startTimestamp < endTimestamp;\n        if (!keepSpan) {\n          __DEBUG_BUILD__ &&\n            logger.log(\n              '[Tracing] discarding Span since it happened after Transaction was finished',\n              JSON.stringify(span, undefined, 2),\n            );\n        }\n        return keepSpan;\n      });\n\n      __DEBUG_BUILD__ && logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      __DEBUG_BUILD__ && logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n    if (this._onScope) {\n      clearActiveTransaction(this._idleHub);\n    }\n\n    return super.finish(endTimestamp);\n  }\n\n  /**\n   * Register a callback function that gets excecuted before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n  public registerBeforeFinishCallback(callback: BeforeFinishCallback): void {\n    this._beforeFinishCallbacks.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public initSpanRecorder(maxlen?: number): void {\n    if (!this.spanRecorder) {\n      const pushActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._pushActivity(id);\n      };\n      const popActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._popActivity(id);\n      };\n\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);\n\n      // Start heartbeat so that transactions do not run forever.\n      __DEBUG_BUILD__ && logger.log('Starting heartbeat');\n      this._pingHeartbeat();\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Cancels the existing idletimeout, if there is one\n   */\n  private _cancelIdleTimeout(): void {\n    if (this._idleTimeoutID) {\n      clearTimeout(this._idleTimeoutID);\n      this._idleTimeoutID = undefined;\n    }\n  }\n\n  /**\n   * Creates an idletimeout\n   */\n  private _startIdleTimeout(endTimestamp?: Parameters<IdleTransaction['finish']>[0]): void {\n    this._cancelIdleTimeout();\n    this._idleTimeoutID = setTimeout(() => {\n      if (!this._finished && Object.keys(this.activities).length === 0) {\n        this.finish(endTimestamp);\n      }\n    }, this._idleTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n  private _pushActivity(spanId: string): void {\n    this._cancelIdleTimeout();\n    __DEBUG_BUILD__ && logger.log(`[Tracing] pushActivity: ${spanId}`);\n    this.activities[spanId] = true;\n    __DEBUG_BUILD__ && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n  private _popActivity(spanId: string): void {\n    if (this.activities[spanId]) {\n      __DEBUG_BUILD__ && logger.log(`[Tracing] popActivity ${spanId}`);\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this.activities[spanId];\n      __DEBUG_BUILD__ && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      // We need to add the timeout here to have the real endtimestamp of the transaction\n      // Remember timestampWithMs is in seconds, timeout is in ms\n      const endTimestamp = timestampWithMs() + this._idleTimeout / 1000;\n      this._startIdleTimeout(endTimestamp);\n    }\n  }\n\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n  private _beat(): void {\n    // We should not be running heartbeat if the idle transaction is finished.\n    if (this._finished) {\n      return;\n    }\n\n    const heartbeatString = Object.keys(this.activities).join('');\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter += 1;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      __DEBUG_BUILD__ && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n      this.setStatus('deadline_exceeded');\n      this.finish();\n    } else {\n      this._pingHeartbeat();\n    }\n  }\n\n  /**\n   * Pings the heartbeat\n   */\n  private _pingHeartbeat(): void {\n    __DEBUG_BUILD__ && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n    setTimeout(() => {\n      this._beat();\n    }, this._heartbeatInterval);\n  }\n}\n\n/**\n * Reset transaction on scope to `undefined`\n */\nfunction clearActiveTransaction(hub: Hub): void {\n  const scope = hub.getScope();\n  if (scope) {\n    const transaction = scope.getTransaction();\n    if (transaction) {\n      scope.setSpan(undefined);\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","import { getMainCarrier, Hub } from '@sentry/core';\nimport {\n  ClientOptions,\n  CustomSamplingContext,\n  Integration,\n  IntegrationClass,\n  Options,\n  SamplingContext,\n  TransactionContext,\n} from '@sentry/types';\nimport { dynamicRequire, isNaN, isNodeEnv, loadModule, logger } from '@sentry/utils';\n\nimport { registerErrorInstrumentation } from './errors';\nimport { IdleTransaction } from './idletransaction';\nimport { Transaction } from './transaction';\nimport { hasTracingEnabled } from './utils';\n\n/** Returns all trace headers that are currently on the top scope. */\nfunction traceHeaders(this: Hub): { [key: string]: string } {\n  const scope = this.getScope();\n  if (scope) {\n    const span = scope.getSpan();\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent(),\n      };\n    }\n  }\n  return {};\n}\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\nfunction sample<T extends Transaction>(\n  transaction: T,\n  options: Pick<Options, 'tracesSampleRate' | 'tracesSampler'>,\n  samplingContext: SamplingContext,\n): T {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n  if (transaction.sampled !== undefined) {\n    transaction.setMetadata({\n      sampleRate: Number(transaction.sampled),\n    });\n    return transaction;\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate),\n    });\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else {\n    sampleRate = options.tracesSampleRate;\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate),\n    });\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(sampleRate)) {\n    __DEBUG_BUILD__ && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!sampleRate) {\n    __DEBUG_BUILD__ &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  transaction.sampled = Math.random() < (sampleRate as number | boolean);\n\n  // if we're not going to keep it, we're done\n  if (!transaction.sampled) {\n    __DEBUG_BUILD__ &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return transaction;\n  }\n\n  __DEBUG_BUILD__ && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);\n  return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nfunction isValidSampleRate(rate: unknown): boolean {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    __DEBUG_BUILD__ &&\n      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n  this: Hub,\n  transactionContext: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n): Transaction {\n  const client = this.getClient();\n  const options: Partial<ClientOptions> = (client && client.getOptions()) || {};\n\n  const configInstrumenter = options.instrumenter || 'sentry';\n  const transactionInstrumenter = transactionContext.instrumenter || 'sentry';\n\n  if (configInstrumenter !== transactionInstrumenter) {\n    __DEBUG_BUILD__ &&\n      logger.error(\n        `A transaction was started with instrumenter=\\`${transactionInstrumenter}\\`, but the SDK is configured with the \\`${configInstrumenter}\\` instrumenter.\nThe transaction will not be sampled. Please use the ${configInstrumenter} instrumentation to start transactions.`,\n      );\n\n    transactionContext.sampled = false;\n  }\n\n  let transaction = new Transaction(transactionContext, this);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nexport function startIdleTransaction(\n  hub: Hub,\n  transactionContext: TransactionContext,\n  idleTimeout: number,\n  finalTimeout: number,\n  onScope?: boolean,\n  customSamplingContext?: CustomSamplingContext,\n  heartbeatInterval?: number,\n): IdleTransaction {\n  const client = hub.getClient();\n  const options: Partial<ClientOptions> = (client && client.getOptions()) || {};\n\n  let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, heartbeatInterval, onScope);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  return transaction;\n}\n\n/**\n * @private\n */\nexport function _addTracingExtensions(): void {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n}\n\n/**\n * @private\n */\nfunction _autoloadDatabaseIntegrations(): void {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  const packageToIntegrationMapping: Record<string, () => Integration> = {\n    mongodb() {\n      const integration = dynamicRequire(module, './integrations/node/mongo') as {\n        Mongo: IntegrationClass<Integration>;\n      };\n      return new integration.Mongo();\n    },\n    mongoose() {\n      const integration = dynamicRequire(module, './integrations/node/mongo') as {\n        Mongo: IntegrationClass<Integration>;\n      };\n      return new integration.Mongo({ mongoose: true });\n    },\n    mysql() {\n      const integration = dynamicRequire(module, './integrations/node/mysql') as {\n        Mysql: IntegrationClass<Integration>;\n      };\n      return new integration.Mysql();\n    },\n    pg() {\n      const integration = dynamicRequire(module, './integrations/node/postgres') as {\n        Postgres: IntegrationClass<Integration>;\n      };\n      return new integration.Postgres();\n    },\n  };\n\n  const mappedPackages = Object.keys(packageToIntegrationMapping)\n    .filter(moduleName => !!loadModule(moduleName))\n    .map(pkg => {\n      try {\n        return packageToIntegrationMapping[pkg]();\n      } catch (e) {\n        return undefined;\n      }\n    })\n    .filter(p => p) as Integration[];\n\n  if (mappedPackages.length > 0) {\n    carrier.__SENTRY__.integrations = [...(carrier.__SENTRY__.integrations || []), ...mappedPackages];\n  }\n}\n\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\nexport function addExtensionMethods(): void {\n  _addTracingExtensions();\n\n  // Detect and automatically load specified integrations.\n  if (isNodeEnv()) {\n    _autoloadDatabaseIntegrations();\n  }\n\n  // If an error happens globally, we should make sure transaction status is set to error.\n  registerErrorInstrumentation();\n}\n","import { isRegExp, isString } from './is';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input: any[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the 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\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nexport function escapeStringForRegex(regexString: string): string {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n","import { getCurrentHub, Hub } from '@sentry/core';\nimport {\n  Context,\n  Contexts,\n  DynamicSamplingContext,\n  Event,\n  Measurements,\n  MeasurementUnit,\n  Transaction as TransactionInterface,\n  TransactionContext,\n  TransactionMetadata,\n} from '@sentry/types';\nimport { dropUndefinedKeys, logger, timestampInSeconds } from '@sentry/utils';\n\nimport { Span as SpanClass, SpanRecorder } from './span';\n\n/** JSDoc */\nexport class Transaction extends SpanClass implements TransactionInterface {\n  public metadata: TransactionMetadata;\n\n  /**\n   * The reference to the current hub.\n   */\n  public readonly _hub: Hub;\n\n  private _name: string;\n\n  private _measurements: Measurements = {};\n\n  private _contexts: Contexts = {};\n\n  private _trimEnd?: boolean;\n\n  private _frozenDynamicSamplingContext: Readonly<Partial<DynamicSamplingContext>> | undefined = undefined;\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  public constructor(transactionContext: TransactionContext, hub?: Hub) {\n    super(transactionContext);\n\n    this._hub = hub || getCurrentHub();\n\n    this._name = transactionContext.name || '';\n\n    this.metadata = {\n      source: 'custom',\n      ...transactionContext.metadata,\n      spanMetadata: {},\n      changes: [],\n      propagations: 0,\n    };\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    // this is because transactions are also spans, and spans have a transaction pointer\n    this.transaction = this;\n\n    // If Dynamic Sampling Context is provided during the creation of the transaction, we freeze it as it usually means\n    // there is incoming Dynamic Sampling Context. (Either through an incoming request, a baggage meta-tag, or other means)\n    const incomingDynamicSamplingContext = this.metadata.dynamicSamplingContext;\n    if (incomingDynamicSamplingContext) {\n      // We shallow copy this in case anything writes to the original reference of the passed in `dynamicSamplingContext`\n      this._frozenDynamicSamplingContext = { ...incomingDynamicSamplingContext };\n    }\n  }\n\n  /** Getter for `name` property */\n  public get name(): string {\n    return this._name;\n  }\n\n  /** Setter for `name` property, which also sets `source` as custom */\n  public set name(newName: string) {\n    this.setName(newName);\n  }\n\n  /**\n   * JSDoc\n   */\n  public setName(name: string, source: TransactionMetadata['source'] = 'custom'): void {\n    // `source` could change without the name changing if we discover that an unparameterized route is actually\n    // parameterized by virtue of having no parameters in its path\n    if (name !== this.name || source !== this.metadata.source) {\n      this.metadata.changes.push({\n        // log previous source\n        source: this.metadata.source,\n        timestamp: timestampInSeconds(),\n        propagations: this.metadata.propagations,\n      });\n    }\n\n    this._name = name;\n    this.metadata.source = source;\n  }\n\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n  public initSpanRecorder(maxlen: number = 1000): void {\n    if (!this.spanRecorder) {\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): void {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setMeasurement(name: string, value: number, unit: MeasurementUnit = ''): void {\n    this._measurements[name] = { value, unit };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setMetadata(newMetadata: Partial<TransactionMetadata>): void {\n    this.metadata = { ...this.metadata, ...newMetadata };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public finish(endTimestamp?: number): string | undefined {\n    // This transaction is already finished, so we should not flush it again.\n    if (this.endTimestamp !== undefined) {\n      return undefined;\n    }\n\n    if (!this.name) {\n      __DEBUG_BUILD__ && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this.name = '<unlabeled transaction>';\n    }\n\n    // just sets the end timestamp\n    super.finish(endTimestamp);\n\n    if (this.sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      __DEBUG_BUILD__ && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      const client = this._hub.getClient();\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    const finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      this.endTimestamp = finishedSpans.reduce((prev: SpanClass, current: SpanClass) => {\n        if (prev.endTimestamp && current.endTimestamp) {\n          return prev.endTimestamp > current.endTimestamp ? prev : current;\n        }\n        return prev;\n      }).endTimestamp;\n    }\n\n    const metadata = this.metadata;\n\n    const transaction: Event = {\n      contexts: {\n        ...this._contexts,\n        // We don't want to override trace context\n        trace: this.getTraceContext(),\n      },\n      spans: finishedSpans,\n      start_timestamp: this.startTimestamp,\n      tags: this.tags,\n      timestamp: this.endTimestamp,\n      transaction: this.name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        ...metadata,\n        dynamicSamplingContext: this.getDynamicSamplingContext(),\n      },\n      ...(metadata.source && {\n        transaction_info: {\n          source: metadata.source,\n          changes: metadata.changes,\n          propagations: metadata.propagations,\n        },\n      }),\n    };\n\n    const hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      __DEBUG_BUILD__ &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction',\n          JSON.stringify(this._measurements, undefined, 2),\n        );\n      transaction.measurements = this._measurements;\n    }\n\n    __DEBUG_BUILD__ && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);\n\n    return this._hub.captureEvent(transaction);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toContext(): TransactionContext {\n    const spanContext = super.toContext();\n\n    return dropUndefinedKeys({\n      ...spanContext,\n      name: this.name,\n      trimEnd: this._trimEnd,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateWithContext(transactionContext: TransactionContext): this {\n    super.updateWithContext(transactionContext);\n\n    this.name = transactionContext.name ?? '';\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @experimental\n   */\n  public getDynamicSamplingContext(): Readonly<Partial<DynamicSamplingContext>> {\n    if (this._frozenDynamicSamplingContext) {\n      return this._frozenDynamicSamplingContext;\n    }\n\n    const hub: Hub = this._hub || getCurrentHub();\n    const client = hub && hub.getClient();\n\n    if (!client) return {};\n\n    const { environment, release } = client.getOptions() || {};\n    const { publicKey: public_key } = client.getDsn() || {};\n\n    const maybeSampleRate = this.metadata.sampleRate;\n    const sample_rate = maybeSampleRate !== undefined ? maybeSampleRate.toString() : undefined;\n\n    const scope = hub.getScope();\n    const { segment: user_segment } = (scope && scope.getUser()) || {};\n\n    const source = this.metadata.source;\n\n    // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n    const transaction = source && source !== 'url' ? this.name : undefined;\n\n    const dsc = dropUndefinedKeys({\n      environment,\n      release,\n      transaction,\n      user_segment,\n      public_key,\n      trace_id: this.traceId,\n      sample_rate,\n    });\n\n    // Uncomment if we want to make DSC immutable\n    // this._frozenDynamicSamplingContext = dsc;\n\n    return dsc;\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { 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  const lineno = frame.lineno || 0;\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception as any).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nexport function arrayify<T = unknown>(maybeArray: T | T[]): T[] {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n","/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nexport function _nullishCoalesce(lhs: unknown, rhsFn: () => unknown): unknown {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n","import { ClientOptions, DsnComponents, DsnLike, SdkInfo } from '@sentry/types';\nimport { dsnToString, makeDsn, urlEncode } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn: DsnComponents): string {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn: DsnComponents): string {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nexport function getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn: DsnComponents,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions: string | ClientOptions = {} as ClientOptions,\n): string {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  const sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nexport function getReportDialogEndpoint(\n  dsnLike: DsnLike,\n  dialogOptions: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n    user?: { name?: string; email?: string };\n  },\n): string {\n  const dsn = makeDsn(dsnLike);\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst enum States {\n  /** Pending */\n  PENDING = 0,\n  /** Resolved / OK */\n  RESOLVED = 1,\n  /** Rejected / Error */\n  REJECTED = 2,\n}\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike<void>;\nexport function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise<T> implements PromiseLike<T> {\n  private _state: States = States.PENDING;\n  private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]> = [];\n  private _value: any;\n\n  public constructor(\n    executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,\n  ) {\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n  public then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n  public catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,\n  ): PromiseLike<T | TResult> {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n  public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {\n    return new SyncPromise<TResult>((resolve, reject) => {\n      let val: TResult | any;\n      let isRejected: boolean;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val as unknown as any);\n      });\n    });\n  }\n\n  /** JSDoc */\n  private readonly _resolve = (value?: T | PromiseLike<T> | null) => {\n    this._setResult(States.RESOLVED, value);\n  };\n\n  /** JSDoc */\n  private readonly _reject = (reason?: any) => {\n    this._setResult(States.REJECTED, reason);\n  };\n\n  /** JSDoc */\n  private readonly _setResult = (state: States, value?: T | PromiseLike<T> | any) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value as PromiseLike<T>).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };\n\n  /** JSDoc */\n  private readonly _executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value as unknown as any);\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };\n}\n\nexport { SyncPromise };\n","import { Integration, Options } from '@sentry/types';\nimport { arrayify, logger } from '@sentry/utils';\n\nimport { getCurrentHub } from './hub';\nimport { addGlobalEventProcessor } from './scope';\n\ndeclare module '@sentry/types' {\n  interface Integration {\n    isDefaultInstance?: boolean;\n  }\n}\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport type IntegrationIndex = {\n  [key: string]: Integration;\n};\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations: Integration[]): Integration[] {\n  const integrationsByName: { [key: string]: Integration } = {};\n\n  integrations.forEach(currentInstance => {\n    const { name } = currentInstance;\n\n    const existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nexport function getIntegrationsToSetup(options: Options): Integration[] {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach(integration => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations: Integration[];\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  const finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend` or\n  // `beforeSendTransaction`. It therefore has to run after all other integrations, so that the changes of all event\n  // processors will be reflected in the printed values. For lack of a more elegant way to guarantee that, we therefore\n  // locate it and, assuming it exists, pop it out of its current spot and shove it onto the end of the array.\n  const debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n  if (debugIndex !== -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(integrations: Integration[]): IntegrationIndex {\n  const integrationIndex: IntegrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      __DEBUG_BUILD__ && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n","import { StackFrame, StackLineParser, StackLineParserFn, StackParser } from '@sentry/types';\n\nconst STACKTRACE_LIMIT = 50;\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\n    for (const line of stack.split('\\n').slice(skipFirst)) {\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = line.replace(/\\(error: (.*)\\)/, '$1');\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\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 * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: StackFrame[]): StackFrame[] {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  const firstFrameFunction = localStack[0].function || '';\n  const lastFrameFunction = localStack[localStack.length - 1].function || '';\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 (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\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 (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\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\ntype GetModuleFn = (filename: string | undefined) => string | undefined;\n\n// eslint-disable-next-line complexity\nfunction node(getModule?: GetModuleFn): StackLineParserFn {\n  const FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  const FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n  // eslint-disable-next-line complexity\n  return (line: string) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    const lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object: string | undefined;\n    let method: string | undefined;\n    let functionName: string | undefined;\n    let typeName: string | undefined;\n    let methodName: string | undefined;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n        // eslint-disable-next-line no-plusplus\n        methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        const objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    const filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].substr(7) : lineMatch[2];\n    const isNative = lineMatch[5] === 'native';\n    const isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    const in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: getModule?.(filename),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\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 { logger } from './logger';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\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\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","import { WrappedFunction } from '@sentry/types';\n\nimport { getGlobalSingleton, 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<typeof CONSOLE_LEVELS[number], LoggerMethod>;\n\n/** JSDoc */\ninterface Logger extends LoggerConsoleMethods {\n  disable(): void;\n  enable(): void;\n}\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox<T>(callback: () => T): T {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const originalConsole = GLOBAL_OBJ.console as Console & Record<string, unknown>;\n  const wrappedLevels: Partial<LoggerConsoleMethods> = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] as WrappedFunction).__sentry_original__;\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] as LoggerConsoleMethods[typeof level];\n      originalConsole[level] = originalWrappedFunc as Console[typeof level];\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level as typeof CONSOLE_LEVELS[number]];\n    });\n  }\n}\n\nfunction makeLogger(): Logger {\n  let enabled = false;\n  const logger: Partial<Logger> = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if (__DEBUG_BUILD__) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args: any[]) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_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\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger: Logger;\nif (__DEBUG_BUILD__) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { logger };\n","import { TraceparentData } from '@sentry/types';\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  const matches = traceparent.match(TRACEPARENT_REGEXP);\n\n  if (!traceparent || !matches) {\n    // empty string or no matches is invalid traceparent data\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","export const SDK_VERSION = '7.21.0';\n"],"sourceRoot":""}