{"version":3,"sources":["webpack://checkout/../src/index.ts","webpack://checkout/../src/exports.ts","webpack://checkout/../src/loglevel.ts","webpack://checkout/../src/session.ts","webpack://checkout/../src/severity.ts","webpack://checkout/../src/status.ts","webpack://checkout/../src/async.ts","webpack://checkout/../src/dsn.ts","webpack://checkout/../src/polyfill.ts","webpack://checkout/../src/instrument.ts","webpack://checkout/../src/path.ts","webpack://checkout/../src/promisebuffer.ts","webpack://checkout/../src/time.ts","webpack://checkout/../src/hub.ts","webpack://checkout/../src/api.ts","webpack://checkout/../src/baseclient.ts","webpack://checkout/../src/integration.ts","webpack://checkout/../src/basebackend.ts","webpack://checkout/../src/request.ts","webpack://checkout/../src/sdk.ts","webpack://checkout/../../src/integrations/index.ts","webpack://checkout/../../src/integrations/functiontostring.ts","webpack://checkout/../../src/integrations/inboundfilters.ts","webpack://checkout/../src/backend.ts","webpack://checkout/../../src/transports/fetch.ts","webpack://checkout/../../src/transports/xhr.ts","webpack://checkout/../../src/integrations/globalhandlers.ts","webpack://checkout/../../src/integrations/trycatch.ts","webpack://checkout/../../src/integrations/breadcrumbs.ts","webpack://checkout/../../src/integrations/linkederrors.ts","webpack://checkout/../../src/integrations/useragent.ts","webpack://checkout/../src/angular.ts","webpack://checkout/../src/captureconsole.ts","webpack://checkout/../src/debug.ts","webpack://checkout/../src/dedupe.ts","webpack://checkout/../src/ember.ts","webpack://checkout/../src/extraerrordata.ts","webpack://checkout/../src/offline.ts","webpack://checkout/../src/reportingobserver.ts","webpack://checkout/../src/rewriteframes.ts","webpack://checkout/../src/sessiontiming.ts","webpack://checkout/../src/transaction.ts","webpack://checkout/../src/vue.ts","webpack://checkout/../src/is.ts","webpack://checkout/../src/misc.ts","webpack://checkout/../src/helpers.ts","webpack://checkout/../src/error.ts","webpack://checkout/../src/logger.ts","webpack://checkout/../src/node.ts","webpack://checkout/../src/object.ts","webpack://checkout/../src/stacktrace.ts","webpack://checkout/../src/string.ts","webpack://checkout/../src/eventbuilder.ts","webpack://checkout/../src/tracekit.ts","webpack://checkout/../../src/transports/base.ts","webpack://checkout/../src/scope.ts","webpack://checkout/../src/browser.ts","webpack://checkout/../src/memo.ts","webpack://checkout/../src/supports.ts","webpack://checkout/../src/syncpromise.ts","webpack://checkout/../../src/transports/noop.ts","webpack://checkout/../src/client.ts","webpack://checkout/../src/parsers.ts","webpack://checkout/../../src/transports/index.ts","webpack://checkout/../src/version.ts"],"names":["Severity","Status","addGlobalEventProcessor","addBreadcrumb","captureException","captureEvent","captureMessage","configureScope","getHubFromCarrier","getCurrentHub","Hub","makeMain","Scope","startTransaction","setContext","setExtra","setExtras","setTag","setTags","setUser","withScope","BrowserClient","injectReportDialog","eventFromException","eventFromMessage","defaultIntegrations","forceLoad","init","lastEventId","onLoad","showReportDialog","flush","close","wrap","SDK_NAME","SDK_VERSION","LogLevel","fromString","level","Debug","Info","Warning","Error","Fatal","Critical","Log","fromHttpCode","code","Success","RateLimit","Invalid","Failed","Unknown","promise","then","e","console","error","DSN_REGEX","from","this","_fromString","_fromComponents","_validate","toString","withPassword","host","path","pass","port","projectId","protocol","user","str","match","exec","SentryError","split","length","slice","join","pop","projectMatch","components","forEach","component","ERROR_MESSAGE","isNaN","parseInt","Dsn","setPrototypeOf","Object","__proto__","Array","obj","proto","prop","hasOwnProperty","lastHref","global","getGlobalObject","handlers","instrumented","instrument","type","fill","originalConsoleLevel","triggerHandlers","args","Function","prototype","apply","call","instrumentConsole","document","addEventListener","domEventHandler","bind","keypressEventHandler","target","original","eventName","fn","options","handleEvent","innerOriginal","event","__sentry_wrapped__","instrumentDOM","requestKeys","requestValues","xhrproto","XMLHttpRequest","originalOpen","xhr","url","__sentry_xhr__","method","isString","toUpperCase","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","requestPos","indexOf","splice","undefined","body","endTimestamp","Date","now","startTimestamp","onreadystatechange","readyStateArgs","originalSend","push","instrumentXHR","supportsNativeFetch","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","response","instrumentFetch","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","String","location","href","history","instrumentHistory","_oldOnErrorHandler","onerror","msg","line","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","logger","warn","data","handler","getFunctionName","fetchArgs","isInstanceOf","Request","callback","keypressTimeout","lastCapturedEvent","debounceDuration","debounceTimer","name","debounce","clearTimeout","setTimeout","tagName","isContentEditable","normalizeArray","parts","allowAboveRoot","up","i","last","unshift","splitPathRe","splitPath","filename","resolve","resolvedPath","resolvedAbsolute","charAt","filter","p","trim","arr","start","end","normalizePath","isPathAbsolute","isAbsolute","trailingSlash","substr","normalizedPath","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","result","root","dir","ext","f","_limit","_buffer","isReady","add","task","remove","SyncPromise","reject","drain","timeout","capturedSetTimeout","all","PromiseBuffer","dateTimestampSource","nowSeconds","platformPerformance","isNodeEnv","dynamicRequire","module","performance","_","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","usingPerformanceAPI","browserPerformanceTimeOrigin","timing","navigationStart","API_VERSION","client","scope","_version","_stack","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","clone","getScope","getStack","getClient","popScope","exception","hint","eventId","_lastEventId","uuid4","finalHint","syntheticException","originalException","_invokeClient","event_id","message","breadcrumb","beforeBreadcrumb","maxBreadcrumbs","timestamp","mergedBreadcrumb","finalBreadcrumb","consoleSandbox","tags","extras","key","value","extra","context","run","oldHub","getIntegration","integration","_oO","id","startSpan","_callExtensionMethod","customSamplingContext","traceHeaders","startSession","endSession","release","environment","session","Session","getUser","setSession","getSession","captureSession","carrier","getMainCarrier","sentry","__SENTRY__","extensions","hub","registry","setHubOnCarrier","getActiveDomain","domain","active","hasHubOnCarrier","activeDomain","registryHubTopStack","_Oo","getHubFromActiveDomain","dsn","_dsnObject","getDsn","getBaseApiEndpoint","getStoreEndpoint","_getIngestEndpoint","getStoreEndpointWithUrlEncodedAuth","_encodedAuth","getEnvelopeEndpointWithUrlEncodedAuth","_getEnvelopeEndpoint","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","header","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","encodeURIComponent","email","auth","sentry_key","sentry_version","urlEncode","API","backendClass","_integrations","_processing","_backend","_options","_dsn","_process","_getBackend","_captureEvent","promisedEvent","isPrimitive","_sendSession","getOptions","_isClientProcessing","ready","getTransport","transportFlushed","enabled","_isEnabled","_updateSessionFromEvent","userAgent","crashed","errored","exceptions","values","mechanism","handled","headers","request","toLowerCase","update","SessionStatus","Crashed","errors","Number","sendSession","ticked","interval","setInterval","clearInterval","_prepareEvent","normalizeDepth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","applyToEvent","evt","_normalizeEvent","depth","normalized","breadcrumbs","map","b","normalize","contexts","trace","dist","maxValueLength","truncate","sdkInfo","sdk","integrationsArray","keys","integrations","_sendEvent","sendEvent","_processEvent","finalEvent","reason","beforeSend","sampleRate","isTransaction","random","__sentry__","beforeSendResult","isThenable","processedEvent","BaseClient","getIntegrationsToSetup","userIntegrations","isArray","defaultIntegration","userIntegration","integrationsNames","setupIntegration","installedIntegrations","setupOnce","log","_transport","_setupTransport","_exception","_hint","_message","_level","NoopTransport","BaseBackend","api","JSON","stringify","sent_at","toISOString","useEnvelope","req","envelope","originalFunctionToString","FunctionToString","__sentry_original__","DEFAULT_IGNORE_ERRORS","InboundFilters","self","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","getEventDescription","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","some","pattern","isMatchingPattern","denyUrls","allowUrls","whitelistUrls","blacklistUrls","oO","stacktrace","frames","transportOptions","transport","supportsFetch","FetchTransport","XHRTransport","BrowserBackend","_sendRequest","eventToSentryRequest","_api","sessionToSentryRequest","sentryRequest","originalPayload","_isRateLimited","Promise","_disabledUntil","referrerPolicy","supportsReferrerPolicy","fetchParameters","assign","fetch","get","_handleResponse","requestType","catch","BaseTransport","getResponseHeader","open","setRequestHeader","send","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","addInstrumentationHandler","currentHub","hasIntegration","isFailedOwnDelivery","shouldIgnoreOnError","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","eventFromUnknownInput","attachStacktrace","rejection","addExceptionMechanism","detail","_eventFromIncompleteRejection","isErrorEvent","groups","colno","lineno","getLocationHref","function","in_app","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","_wrapEventTarget","originalCallback","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","xmlHttpRequestProps","wrapOptions","Breadcrumbs","dom","addSentryBreadcrumb","category","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","safeJoin","input","htmlTreeAsString","parsedLoc","parseUrl","parsedFrom","parsedTo","relative","DEFAULT_KEY","DEFAULT_LIMIT","LinkedErrors","_key","limit","_handler","linkedErrors","_walkErrorTree","stack","computeStackTrace","exceptionFromStacktrace","UserAgent","navigator","referrer","Referer","SENTRY_RELEASE","autoSessionTracking","initAndBind","window","loadResolved","fcpResolved","possiblyEndSession","resolveWindowLoaded","removeEventListener","po","PerformanceObserver","entryList","getEntries","entry","startTime","disconnect","visibilityState","Infinity","timeStamp","once","observe","buffered","startSessionTracking","angularPattern","Angular","_angular","angular","_module","moduleName","_getCurrentHub","config","$provide","decorator","_$exceptionHandlerDecorator","$delegate","cause","addEventProcessor","ex","matches","angularDocs","CaptureConsole","_levels","levels","setLevel","debugger","Dedupe","currentEvent","_previousEvent","previousEvent","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_getFramesFromEvent","currentFrames","previousFrames","frameA","frameB","_getExceptionFromEvent","previousException","currentException","currentFingerprint","fingerprint","previousFingerprint","Ember","_Ember","oldOnError","testing","RSVP","on","ExtraErrorData","enhanceEventWithErrorData","isError","constructor","errorData","_extractErrorData","normalizedErrorData","isPlainObject","errorKeys","getOwnPropertyNames","extraErrorInfo","localForage","Offline","maxStoredEvents","offlineEventStore","createInstance","_sendEvents","onLine","_cacheEvent","_event","_error","setItem","_enforceMaxEvents","events","iterate","cacheKey","_index","_purgeEvents","sort","a","_purgeEvent","removeItem","cacheKeys","ReportTypes","types","Crash","Deprecation","Intervention","ReportingObserver","supportsReportingObserver","reports","report","label","details","plainBody","crashId","RewriteFrames","_iteratee","frame","isWindowsFrame","test","startsWithSlash","replace","base","_root","basename","iteratee","process","_processExceptionsEvent","_processStacktraceEvent","_processStacktrace","SessionTiming","_startTime","Transaction","transaction","_getTransaction","TRACING_GETTER","BROWSER_TRACING_GETTER","HOOKS","activate","create","destroy","mount","COMPONENT_NAME_REGEXP","ROOT_COMPONENT_NAME","Vue","_componentsCache","_applyTracingHooks","vm","$options","$_sentryPerfHook","_getComponentName","rootMount","spans","rootHandler","hook","_rootSpan","_finishRootSpan","$once","tracingIntegration","_tracingActivity","pushActivity","getTransaction","startChild","description","op","activeTransaction","getActiveTransaction","childHandler","operation","shouldTrack","tracingOptions","trackComponents","span","finish","hooks","internalHooks","internalHook","currentValue","attachProps","logErrors","tracing","_attachErrorHandler","_startTracing","$root","_componentTag","__file","unifiedFile","c","_rootSpanTimer","popActivity","applyTracingHooks","mixin","beforeCreate","currentErrorHandler","errorHandler","info","metadata","componentName","propsData","lifecycleHook","util","wat","_e","Event","Element","Boolean","fallbackGlobalObject","crypto","msCrypto","getRandomValues","Uint16Array","pad","num","v","r","query","fragment","originalConsole","wrappedLevels","SEMVER_REGEXP","major","minor","patch","buildmetadata","prerelease","defaultRetryAfter","headerDelay","headerDate","parse","lines","linesOfContext","maxLines","sourceLine","max","pre_context","snipLine","context_line","post_context","urlPath","ignoreOnError","ignoreNextOnError","before","sentryWrapped","wrappedArguments","arg","addExceptionTypeValue","property","defineProperty","enumerable","defineProperties","getOwnPropertyDescriptor","configurable","script","createElement","async","src","onload","head","appendChild","PREFIX","_enabled","disable","enable","Logger","mod","require","DEFAULT_REQUEST_KEYS","requestData","hostname","secure","socket","encrypted","originalUrl","absoluteUrl","cookies","cookie","query_string","getWalkSource","isEvent","source","isElement","currentTarget","CustomEvent","jsonSize","encodeURI","utf8Length","normalizeValue","_events","isSyntheticEvent","walk","memo","Memo","serializeValue","toJSON","acc","memoize","innerKey","unmemoize","replacement","wrapped","object","normalizeToSize","maxSize","serialized","maxLength","includedKeys","dropUndefinedKeys","val","rv","defaultFunctionName","newLine","ll","delimiter","output","isRegExp","eventFromStacktrace","isDOMError","isDOMException","domException","eventFromString","objectException","eventFromPlainObject","synthetic","prepareFramesForEvent","UNKNOWN_FUNCTION","chrome","gecko","winjs","geckoEval","chromeEval","reactMinifiedRegexp","popFrames","popSize","extractMessage","framesToPop","opera10Regex","opera11Regex","element","func","computeStackTraceFromStacktraceProp","submatch","isNative","columnNumber","computeStackTraceFromStackProp","failed","_rateLimits","_handleRateLimit","rlHeader","raHeader","parameters","delay","parseRetryAfterHeader","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","newScope","_span","_session","_transactionName","_fingerprint","addScopeListener","_notifyScopeListeners","setFingerprint","setTransactionName","setTransaction","setSpan","getSpan","spanRecorder","updatedScope","clear","clearBreadcrumbs","getTraceContext","transactionName","_applyFingerprint","_notifyEventProcessors","getGlobalEventProcessors","processors","index","processor","final","globalEventProcessors","_htmlElementAsString","el","className","classes","attr","elem","out","allowedAttrs","getAttribute","currentElem","height","len","sepLength","nextStr","parentNode","reverse","_hasWeakSet","WeakSet","_inner","has","delete","Headers","Response","isNativeFetch","ErrorEvent","DOMError","DOMException","doc","sandbox","hidden","contentWindow","removeChild","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","States","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","REJECTED","state","_value","_executeHandlers","_attachHandler","cachedHandlers","done","onfulfilled","onrejected","collection","counter","resolvedCollection","item","TypeError","finally","onfinally","isRejected","sid","started","duration","Ok","ip_address","ipAddress","did","username","Exited","attrs","user_agent","Skipped","platform","packages","STACKTRACE_LIMIT","localStack","firstFrameFunction","lastFrameFunction","extractExceptionKeysForMessage","__serialized__","Integrations"],"mappings":"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","file":"sentry~checkout-4931f9c7.js","sourcesContent":["export {\n  addBreadcrumb,\n  captureException,\n  captureEvent,\n  captureMessage,\n  configureScope,\n  startTransaction,\n  setContext,\n  setExtra,\n  setExtras,\n  setTag,\n  setTags,\n  setUser,\n  withScope,\n} from '@sentry/minimal';\nexport { addGlobalEventProcessor, getCurrentHub, getHubFromCarrier, Hub, makeMain, Scope } from '@sentry/hub';\nexport { API } from './api';\nexport { BaseClient } from './baseclient';\nexport { BackendClass, BaseBackend } from './basebackend';\nexport { eventToSentryRequest, sessionToSentryRequest } from './request';\nexport { initAndBind, ClientClass } from './sdk';\nexport { NoopTransport } from './transports/noop';\n\nimport * as Integrations from './integrations';\n\nexport { Integrations };\n","export {\n  Breadcrumb,\n  BreadcrumbHint,\n  Request,\n  SdkInfo,\n  Event,\n  EventHint,\n  Exception,\n  Response,\n  Severity,\n  StackFrame,\n  Stacktrace,\n  Status,\n  Thread,\n  User,\n} from '@sentry/types';\n\nexport {\n  addGlobalEventProcessor,\n  addBreadcrumb,\n  captureException,\n  captureEvent,\n  captureMessage,\n  configureScope,\n  getHubFromCarrier,\n  getCurrentHub,\n  Hub,\n  makeMain,\n  Scope,\n  startTransaction,\n  setContext,\n  setExtra,\n  setExtras,\n  setTag,\n  setTags,\n  setUser,\n  withScope,\n} from '@sentry/core';\n\nexport { BrowserOptions } from './backend';\nexport { BrowserClient } from './client';\nexport { injectReportDialog, ReportDialogOptions } from './helpers';\nexport { eventFromException, eventFromMessage } from './eventbuilder';\nexport { defaultIntegrations, forceLoad, init, lastEventId, onLoad, showReportDialog, flush, close, wrap } from './sdk';\nexport { SDK_NAME, SDK_VERSION } from './version';\n","/** Console logging verbosity for the SDK. */\nexport enum LogLevel {\n  /** No logs will be generated. */\n  None = 0,\n  /** Only SDK internal errors will be logged. */\n  Error = 1,\n  /** Information useful for debugging the SDK will be logged. */\n  Debug = 2,\n  /** All SDK actions will be logged. */\n  Verbose = 3,\n}\n","import { Session as SessionInterface, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, uuid4 } from '@sentry/utils';\n\n/**\n * @inheritdoc\n */\nexport class Session implements SessionInterface {\n  public userAgent?: string;\n  public errors: number = 0;\n  public release?: string;\n  public sid: string = uuid4();\n  public did?: string;\n  public timestamp: number = Date.now();\n  public started: number = Date.now();\n  public duration: number = 0;\n  public status: SessionStatus = SessionStatus.Ok;\n  public environment?: string;\n  public ipAddress?: string;\n\n  constructor(context?: Omit<SessionContext, 'started' | 'status'>) {\n    if (context) {\n      this.update(context);\n    }\n  }\n\n  /** JSDoc */\n  // eslint-disable-next-line complexity\n  update(context: SessionContext = {}): void {\n    if (context.user) {\n      if (context.user.ip_address) {\n        this.ipAddress = context.user.ip_address;\n      }\n\n      if (!context.did) {\n        this.did = context.user.id || context.user.email || context.user.username;\n      }\n    }\n\n    this.timestamp = context.timestamp || Date.now();\n\n    if (context.sid) {\n      // Good enough uuid validation. — Kamil\n      this.sid = context.sid.length === 32 ? context.sid : uuid4();\n    }\n    if (context.did) {\n      this.did = `${context.did}`;\n    }\n    if (typeof context.started === 'number') {\n      this.started = context.started;\n    }\n    if (typeof context.duration === 'number') {\n      this.duration = context.duration;\n    } else {\n      this.duration = this.timestamp - this.started;\n    }\n    if (context.release) {\n      this.release = context.release;\n    }\n    if (context.environment) {\n      this.environment = context.environment;\n    }\n    if (context.ipAddress) {\n      this.ipAddress = context.ipAddress;\n    }\n    if (context.userAgent) {\n      this.userAgent = context.userAgent;\n    }\n    if (typeof context.errors === 'number') {\n      this.errors = context.errors;\n    }\n    if (context.status) {\n      this.status = context.status;\n    }\n  }\n\n  /** JSDoc */\n  close(status?: Exclude<SessionStatus, SessionStatus.Ok>): void {\n    if (status) {\n      this.update({ status });\n    } else if (this.status === SessionStatus.Ok) {\n      this.update({ status: SessionStatus.Exited });\n    } else {\n      this.update();\n    }\n  }\n\n  /** JSDoc */\n  toJSON(): {\n    init: boolean;\n    sid: string;\n    did?: string;\n    timestamp: string;\n    started: string;\n    duration: number;\n    status: SessionStatus;\n    errors: number;\n    attrs?: {\n      release?: string;\n      environment?: string;\n      user_agent?: string;\n      ip_address?: string;\n    };\n  } {\n    return dropUndefinedKeys({\n      sid: `${this.sid}`,\n      init: true,\n      started: new Date(this.started).toISOString(),\n      timestamp: new Date(this.timestamp).toISOString(),\n      status: this.status,\n      errors: this.errors,\n      did: typeof this.did === 'number' || typeof this.did === 'string' ? `${this.did}` : undefined,\n      duration: this.duration,\n      attrs: dropUndefinedKeys({\n        release: this.release,\n        environment: this.environment,\n        ip_address: this.ipAddress,\n        user_agent: this.userAgent,\n      }),\n    });\n  }\n}\n","/** JSDoc */\n// eslint-disable-next-line import/export\nexport enum Severity {\n  /** JSDoc */\n  Fatal = 'fatal',\n  /** JSDoc */\n  Error = 'error',\n  /** JSDoc */\n  Warning = 'warning',\n  /** JSDoc */\n  Log = 'log',\n  /** JSDoc */\n  Info = 'info',\n  /** JSDoc */\n  Debug = 'debug',\n  /** JSDoc */\n  Critical = 'critical',\n}\n\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\nexport namespace Severity {\n  /**\n   * Converts a string-based level into a {@link Severity}.\n   *\n   * @param level string representation of Severity\n   * @returns Severity\n   */\n  export function fromString(level: string): Severity {\n    switch (level) {\n      case 'debug':\n        return Severity.Debug;\n      case 'info':\n        return Severity.Info;\n      case 'warn':\n      case 'warning':\n        return Severity.Warning;\n      case 'error':\n        return Severity.Error;\n      case 'fatal':\n        return Severity.Fatal;\n      case 'critical':\n        return Severity.Critical;\n      case 'log':\n      default:\n        return Severity.Log;\n    }\n  }\n}\n","/** The status of an event. */\n// eslint-disable-next-line import/export\nexport enum Status {\n  /** The status could not be determined. */\n  Unknown = 'unknown',\n  /** The event was skipped due to configuration or callbacks. */\n  Skipped = 'skipped',\n  /** The event was sent to Sentry successfully. */\n  Success = 'success',\n  /** The client is currently rate limited and will try again later. */\n  RateLimit = 'rate_limit',\n  /** The event could not be processed. */\n  Invalid = 'invalid',\n  /** A server-side error ocurred during submission. */\n  Failed = 'failed',\n}\n\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\nexport namespace Status {\n  /**\n   * Converts a HTTP status code into a {@link Status}.\n   *\n   * @param code The HTTP response status code.\n   * @returns The send status or {@link Status.Unknown}.\n   */\n  export function fromHttpCode(code: number): Status {\n    if (code >= 200 && code < 300) {\n      return Status.Success;\n    }\n\n    if (code === 429) {\n      return Status.RateLimit;\n    }\n\n    if (code >= 400 && code < 500) {\n      return Status.Invalid;\n    }\n\n    if (code >= 500) {\n      return Status.Failed;\n    }\n\n    return Status.Unknown;\n  }\n}\n","/**\n * Consumes the promise and logs the error when it rejects.\n * @param promise A promise to forget.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function forget(promise: PromiseLike<any>): void {\n  promise.then(null, e => {\n    // TODO: Use a better logging mechanism\n    // eslint-disable-next-line no-console\n    console.error(e);\n  });\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\n/** Error message */\nconst ERROR_MESSAGE = 'Invalid Dsn';\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nexport class Dsn implements DsnComponents {\n  /** Protocol used to connect to Sentry. */\n  public protocol!: DsnProtocol;\n  /** Public authorization key. */\n  public user!: string;\n  /** Private authorization key (deprecated, optional). */\n  public pass!: string;\n  /** Hostname of the Sentry instance. */\n  public host!: string;\n  /** Port of the Sentry instance. */\n  public port!: string;\n  /** Path */\n  public path!: string;\n  /** Project ID */\n  public projectId!: string;\n\n  /** Creates a new Dsn component */\n  public constructor(from: DsnLike) {\n    if (typeof from === 'string') {\n      this._fromString(from);\n    } else {\n      this._fromComponents(from);\n    }\n\n    this._validate();\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   */\n  public toString(withPassword: boolean = false): string {\n    const { host, path, pass, port, projectId, protocol, user } = this;\n    return (\n      `${protocol}://${user}${withPassword && pass ? `:${pass}` : ''}` +\n      `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n    );\n  }\n\n  /** Parses a string into this Dsn. */\n  private _fromString(str: string): void {\n    const match = DSN_REGEX.exec(str);\n\n    if (!match) {\n      throw new SentryError(ERROR_MESSAGE);\n    }\n\n    const [protocol, user, 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    this._fromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, user });\n  }\n\n  /** Maps Dsn components into this instance. */\n  private _fromComponents(components: DsnComponents): void {\n    this.protocol = components.protocol;\n    this.user = components.user;\n    this.pass = components.pass || '';\n    this.host = components.host;\n    this.port = components.port || '';\n    this.path = components.path || '';\n    this.projectId = components.projectId;\n  }\n\n  /** Validates this Dsn and throws on error. */\n  private _validate(): void {\n    ['protocol', 'user', 'host', 'projectId'].forEach(component => {\n      if (!this[component as keyof DsnComponents]) {\n        throw new SentryError(`${ERROR_MESSAGE}: ${component} missing`);\n      }\n    });\n\n    if (!this.projectId.match(/^\\d+$/)) {\n      throw new SentryError(`${ERROR_MESSAGE}: Invalid projectId ${this.projectId}`);\n    }\n\n    if (this.protocol !== 'http' && this.protocol !== 'https') {\n      throw new SentryError(`${ERROR_MESSAGE}: Invalid protocol ${this.protocol}`);\n    }\n\n    if (this.port && isNaN(parseInt(this.port, 10))) {\n      throw new SentryError(`${ERROR_MESSAGE}: Invalid port ${this.port}`);\n    }\n  }\n}\n","export const setPrototypeOf =\n  Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf<TTarget extends object, TProto>(obj: TTarget, proto: TProto): TTarget & TProto {\n  // @ts-ignore __proto__ does not exist on obj\n  obj.__proto__ = proto;\n  return obj as TTarget & TProto;\n}\n\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties<TTarget extends object, TProto>(obj: TTarget, proto: TProto): TTarget & TProto {\n  for (const prop in proto) {\n    // eslint-disable-next-line no-prototype-builtins\n    if (!obj.hasOwnProperty(prop)) {\n      // @ts-ignore typescript complains about indexing so we remove\n      obj[prop] = proto[prop];\n    }\n  }\n\n  return obj as TTarget & TProto;\n}\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 { logger } from './logger';\nimport { getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\n\nconst global = getGlobalObject<Window>();\n\n/** Object describing handler that will be triggered for a given `type` of instrumentation */\ninterface InstrumentHandler {\n  type: InstrumentHandlerType;\n  callback: InstrumentHandlerCallback;\n}\ntype InstrumentHandlerType =\n  | 'console'\n  | 'dom'\n  | 'fetch'\n  | 'history'\n  | 'sentry'\n  | 'xhr'\n  | 'error'\n  | 'unhandledrejection';\ntype 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      logger.warn('unknown instrumentation type:', type);\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(handler: InstrumentHandler): void {\n  if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n    return;\n  }\n  handlers[handler.type] = handlers[handler.type] || [];\n  (handlers[handler.type] as InstrumentHandlerCallback[]).push(handler.callback);\n  instrument(handler.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      logger.error(\n        `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(\n          handler,\n        )}\\nError: ${e}`,\n      );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole(): void {\n  if (!('console' in global)) {\n    return;\n  }\n\n  ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function(level: string): void {\n    if (!(level in global.console)) {\n      return;\n    }\n\n    fill(global.console, level, function(originalConsoleLevel: () => any): Function {\n      return function(...args: any[]): void {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleLevel) {\n          Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch(): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(global, '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(global, 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 global && 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 global && 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 global)) {\n    return;\n  }\n\n  // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n  const requestKeys: XMLHttpRequest[] = [];\n  const requestValues: Array<any>[] = [];\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      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) && xhr.__sentry_xhr__.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            if (xhr.__sentry_xhr__) {\n              xhr.__sentry_xhr__.status_code = xhr.status;\n            }\n          } catch (e) {\n            /* do nothing */\n          }\n\n          try {\n            const requestPos = requestKeys.indexOf(xhr);\n            if (requestPos !== -1) {\n              // Make sure to pop both key and value to keep it in sync.\n              requestKeys.splice(requestPos);\n              const args = requestValues.splice(requestPos)[0];\n              if (xhr.__sentry_xhr__ && args[0] !== undefined) {\n                xhr.__sentry_xhr__.body = args[0] as XHRSendInput;\n              }\n            }\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      requestKeys.push(this);\n      requestValues.push(args);\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 = global.onpopstate;\n  global.onpopstate = function(this: WindowEventHandlers, ...args: any[]): any {\n    const to = global.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      return oldOnPopState.apply(this, args);\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(global.history, 'pushState', historyReplacementFunction);\n  fill(global.history, 'replaceState', historyReplacementFunction);\n}\n\n/** JSDoc */\nfunction instrumentDOM(): void {\n  if (!('document' in global)) {\n    return;\n  }\n\n  // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n  // to the document. Do this before we instrument addEventListener.\n  global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n  global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n\n  // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n  ['EventTarget', 'Node'].forEach((target: string) => {\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    const proto = (global as any)[target] && (global as any)[target].prototype;\n\n    // eslint-disable-next-line no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n    fill(proto, 'addEventListener', function(\n      original: () => void,\n    ): (\n      eventName: string,\n      fn: EventListenerOrEventListenerObject,\n      options?: boolean | AddEventListenerOptions,\n    ) => void {\n      return function(\n        this: any,\n        eventName: string,\n        fn: EventListenerOrEventListenerObject,\n        options?: boolean | AddEventListenerOptions,\n      ): (eventName: string, fn: EventListenerOrEventListenerObject, capture?: boolean, secure?: boolean) => void {\n        if (fn && (fn as EventListenerObject).handleEvent) {\n          if (eventName === 'click') {\n            fill(fn, 'handleEvent', function(innerOriginal: () => void): (caughtEvent: Event) => void {\n              return function(this: any, event: Event): (event: Event) => void {\n                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                return innerOriginal.call(this, event);\n              };\n            });\n          }\n          if (eventName === 'keypress') {\n            fill(fn, 'handleEvent', function(innerOriginal: () => void): (caughtEvent: Event) => void {\n              return function(this: any, event: Event): (event: Event) => void {\n                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                return innerOriginal.call(this, event);\n              };\n            });\n          }\n        } else {\n          if (eventName === 'click') {\n            domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n          }\n          if (eventName === 'keypress') {\n            keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n          }\n        }\n\n        return original.call(this, eventName, fn, options);\n      };\n    });\n\n    fill(proto, 'removeEventListener', function(\n      original: () => void,\n    ): (\n      this: any,\n      eventName: string,\n      fn: EventListenerOrEventListenerObject,\n      options?: boolean | EventListenerOptions,\n    ) => () => void {\n      return function(\n        this: any,\n        eventName: string,\n        fn: EventListenerOrEventListenerObject,\n        options?: boolean | EventListenerOptions,\n      ): () => void {\n        try {\n          original.call(this, eventName, ((fn as unknown) as WrappedFunction).__sentry_wrapped__, options);\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return original.call(this, eventName, fn, options);\n      };\n    });\n  });\n}\n\nconst debounceDuration: number = 1000;\nlet debounceTimer: number = 0;\nlet keypressTimeout: number | undefined;\nlet lastCapturedEvent: Event | undefined;\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name: string, handler: Function, debounce: boolean = false): (event: Event) => void {\n  return (event: Event): void => {\n    // reset keypress timeout; e.g. triggering a 'click' after\n    // a 'keypress' will reset the keypress debounce so that a new\n    // set of keypresses can be recorded\n    keypressTimeout = undefined;\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors). Ignore if we've\n    // already captured the event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    lastCapturedEvent = event;\n\n    if (debounceTimer) {\n      clearTimeout(debounceTimer);\n    }\n\n    if (debounce) {\n      debounceTimer = setTimeout(() => {\n        handler({ event, name });\n      });\n    } else {\n      handler({ event, name });\n    }\n  };\n}\n\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler: Function): (event: Event) => void {\n  // TODO: if somehow user switches keypress target before\n  //       debounce timeout is triggered, we will only capture\n  //       a single breadcrumb from the FIRST target (acceptable?)\n  return (event: Event): void => {\n    let target;\n\n    try {\n      target = event.target;\n    } catch (e) {\n      // just accessing event properties can throw an exception in some rare circumstances\n      // see: https://github.com/getsentry/raven-js/issues/838\n      return;\n    }\n\n    const tagName = target && (target as HTMLElement).tagName;\n\n    // only consider keypress events on actual input elements\n    // this will disregard keypresses targeting body (e.g. tabbing\n    // through elements, hotkeys, etc)\n    if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !(target as HTMLElement).isContentEditable)) {\n      return;\n    }\n\n    // record first keypress in a series, but ignore subsequent\n    // keypresses until debounce clears\n    if (!keypressTimeout) {\n      domEventHandler('input', handler)(event);\n    }\n    clearTimeout(keypressTimeout);\n\n    keypressTimeout = (setTimeout(() => {\n      keypressTimeout = undefined;\n    }, debounceDuration) as any) as number;\n  };\n}\n\nlet _oldOnErrorHandler: OnErrorEventHandler = null;\n/** JSDoc */\nfunction instrumentError(): void {\n  _oldOnErrorHandler = global.onerror;\n\n  global.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 = global.onunhandledrejection;\n\n  global.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","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js\n\n/** JSDoc */\nfunction normalizeArray(parts: string[], allowAboveRoot?: boolean): string[] {\n  // if the path tries to go above the root, `up` ends up > 0\n  let up = 0;\n  for (let i = parts.length - 1; i >= 0; i--) {\n    const last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      // eslint-disable-next-line no-plusplus\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      // eslint-disable-next-line no-plusplus\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    // eslint-disable-next-line no-plusplus\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nconst splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^/]+?|)(\\.[^./]*|))(?:[/]*)$/;\n/** JSDoc */\nfunction splitPath(filename: string): string[] {\n  const parts = splitPathRe.exec(filename);\n  return parts ? parts.slice(1) : [];\n}\n\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nexport function resolve(...args: string[]): string {\n  let resolvedPath = '';\n  let resolvedAbsolute = false;\n\n  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    const path = i >= 0 ? args[i] : '/';\n\n    // Skip empty entries\n    if (!path) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(\n    resolvedPath.split('/').filter(p => !!p),\n    !resolvedAbsolute,\n  ).join('/');\n\n  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n\n/** JSDoc */\nfunction trim(arr: string[]): string[] {\n  let start = 0;\n  for (; start < arr.length; start++) {\n    if (arr[start] !== '') {\n      break;\n    }\n  }\n\n  let end = arr.length - 1;\n  for (; end >= 0; end--) {\n    if (arr[end] !== '') {\n      break;\n    }\n  }\n\n  if (start > end) {\n    return [];\n  }\n  return arr.slice(start, end - start + 1);\n}\n\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nexport function relative(from: string, to: string): string {\n  /* eslint-disable no-param-reassign */\n  from = resolve(from).substr(1);\n  to = resolve(to).substr(1);\n  /* eslint-enable no-param-reassign */\n\n  const fromParts = trim(from.split('/'));\n  const toParts = trim(to.split('/'));\n\n  const length = Math.min(fromParts.length, toParts.length);\n  let samePartsLength = length;\n  for (let i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  let outputParts = [];\n  for (let i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n}\n\n// path.normalize(path)\n// posix version\n/** JSDoc */\nexport function normalizePath(path: string): string {\n  const isPathAbsolute = isAbsolute(path);\n  const trailingSlash = path.substr(-1) === '/';\n\n  // Normalize the path\n  let normalizedPath = normalizeArray(\n    path.split('/').filter(p => !!p),\n    !isPathAbsolute,\n  ).join('/');\n\n  if (!normalizedPath && !isPathAbsolute) {\n    normalizedPath = '.';\n  }\n  if (normalizedPath && trailingSlash) {\n    normalizedPath += '/';\n  }\n\n  return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n\n// posix version\n/** JSDoc */\nexport function isAbsolute(path: string): boolean {\n  return path.charAt(0) === '/';\n}\n\n// posix version\n/** JSDoc */\nexport function join(...args: string[]): string {\n  return normalizePath(args.join('/'));\n}\n\n/** JSDoc */\nexport function dirname(path: string): string {\n  const result = splitPath(path);\n  const root = result[0];\n  let dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n}\n\n/** JSDoc */\nexport function basename(path: string, ext?: string): string {\n  let f = splitPath(path)[2];\n  if (ext && f.substr(ext.length * -1) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n}\n","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n\n/** A simple queue that holds promises. */\nexport class PromiseBuffer<T> {\n  /** Internal set of queued Promises */\n  private readonly _buffer: Array<PromiseLike<T>> = [];\n\n  public constructor(protected _limit?: number) {}\n\n  /**\n   * Says if the buffer is ready to take more requests\n   */\n  public isReady(): boolean {\n    return this._limit === undefined || this.length() < this._limit;\n  }\n\n  /**\n   * Add a promise to the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns The original promise.\n   */\n  public add(task: PromiseLike<T>): PromiseLike<T> {\n    if (!this.isReady()) {\n      return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n    }\n    if (this._buffer.indexOf(task) === -1) {\n      this._buffer.push(task);\n    }\n    task\n      .then(() => this.remove(task))\n      .then(null, () =>\n        this.remove(task).then(null, () => {\n          // We have to add this catch here otherwise we have an unhandledPromiseRejection\n          // because it's a new Promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Remove a promise to the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  public remove(task: PromiseLike<T>): PromiseLike<T> {\n    const removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n    return removedTask;\n  }\n\n  /**\n   * This function returns the number of unresolved promises in the queue.\n   */\n  public length(): number {\n    return this._buffer.length;\n  }\n\n  /**\n   * This will drain the whole queue, returns true if queue is empty or drained.\n   * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n   *\n   * @param timeout Number in ms to wait until it resolves with false.\n   */\n  public drain(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise<boolean>(resolve => {\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n      SyncPromise.all(this._buffer)\n        .then(() => {\n          clearTimeout(capturedSetTimeout);\n          resolve(true);\n        })\n        .then(null, () => {\n          resolve(true);\n        });\n    });\n  }\n}\n","import { getGlobalObject } from './misc';\nimport { dynamicRequire, isNodeEnv } from './node';\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\ninterface TimestampSource {\n  nowSeconds(): number;\n}\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nconst dateTimestampSource: TimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high resolution monotonic clock.\n */\ninterface Performance {\n  /**\n   * The millisecond timestamp at which measurement began, measured in Unix time.\n   */\n  timeOrigin: number;\n  /**\n   * Returns the current millisecond timestamp, where 0 represents the start of measurement.\n   */\n  now(): number;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance(): Performance | undefined {\n  const { performance } = getGlobalObject<Window>();\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance(): Performance | undefined {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') as { performance: Performance };\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance: Performance | undefined = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource: TimestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport const dateTimestampInSeconds = 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 = 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 * 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  const { performance } = getGlobalObject<Window>();\n  if (!performance) {\n    return undefined;\n  }\n  if (performance.timeOrigin) {\n    return performance.timeOrigin;\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  return (performance.timing && performance.timing.navigationStart) || Date.now();\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  SessionContext,\n  Severity,\n  Span,\n  SpanContext,\n  Transaction,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\n\nimport { Carrier, DomainAsCarrier, Layer } from './interfaces';\nimport { Scope } from './scope';\nimport { Session } from './session';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = 3;\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 * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nconst MAX_BREADCRUMBS = 100;\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    this.bindClient(client);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isOlderThan(version: number): boolean {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public bindClient(client?: Client): void {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public pushScope(): Scope {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public popScope(): boolean {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public withScope(callback: (scope: Scope) => void): void {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this.getStackTop().client as C;\n  }\n\n  /** Returns the scope of the top stack. */\n  public getScope(): Scope | undefined {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n  public getStack(): Layer[] {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint): string {\n    const eventId = (this._lastEventId = uuid4());\n    let finalHint = hint;\n\n    // If there's no explicit hint provided, mimick the same thing that would happen\n    // in the minimal itself to create a consistent behavior.\n    // We don't do this in the client, as it's the lowest level API, and doing this,\n    // would prevent user from having full control over direct calls.\n    if (!hint) {\n      let syntheticException: Error;\n      try {\n        throw new Error('Sentry syntheticException');\n      } catch (exception) {\n        syntheticException = exception as Error;\n      }\n      finalHint = {\n        originalException: exception,\n        syntheticException,\n      };\n    }\n\n    this._invokeClient('captureException', exception, {\n      ...finalHint,\n      event_id: eventId,\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(message: string, level?: Severity, hint?: EventHint): string {\n    const eventId = (this._lastEventId = uuid4());\n    let finalHint = hint;\n\n    // If there's no explicit hint provided, mimick the same thing that would happen\n    // in the minimal itself to create a consistent behavior.\n    // We don't do this in the client, as it's the lowest level API, and doing this,\n    // would prevent user from having full control over direct calls.\n    if (!hint) {\n      let syntheticException: Error;\n      try {\n        throw new Error(message);\n      } catch (exception) {\n        syntheticException = exception as Error;\n      }\n      finalHint = {\n        originalException: message,\n        syntheticException,\n      };\n    }\n\n    this._invokeClient('captureMessage', message, level, {\n      ...finalHint,\n      event_id: eventId,\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = (this._lastEventId = uuid4());\n    this._invokeClient('captureEvent', event, {\n      ...hint,\n      event_id: eventId,\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\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]: string }): 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: string): 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      logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startSpan(context: SpanContext): Span {\n    return this._callExtensionMethod('startSpan', context);\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 startSession(context?: SessionContext): Session {\n    // End existing session if there's one\n    this.endSession();\n\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n    const session = new Session({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...context,\n    });\n    if (scope) {\n      scope.setSession(session);\n    }\n    return session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public endSession(): void {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession && scope.getSession();\n    if (session) {\n      session.close();\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n      scope.setSession();\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _invokeClient<M extends keyof Client>(method: M, ...args: any[]): void {\n    const { scope, client } = this.getStackTop();\n    if (client && client[method]) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n      (client as any)[method](...args, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/** Returns the global shim registry. */\nexport function getMainCarrier(): Carrier {\n  const carrier = getGlobalObject();\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub: Hub): Hub {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub(): Hub {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nexport function getActiveDomain(): DomainAsCarrier | undefined {\n  const sentry = getMainCarrier().__SENTRY__;\n\n  return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\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 activeDomain = getActiveDomain();\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  if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) return carrier.__SENTRY__.hub;\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n  carrier.__SENTRY__.hub = new Hub();\n  return carrier.__SENTRY__.hub;\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 */\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n  if (!carrier) return false;\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n  carrier.__SENTRY__.hub = hub;\n  return true;\n}\n","import { DsnLike } from '@sentry/types';\nimport { Dsn, urlEncode } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Helper class to provide urls to different Sentry endpoints. */\nexport class API {\n  /** The internally used Dsn object. */\n  private readonly _dsnObject: Dsn;\n  /** Create a new instance of API */\n  public constructor(public dsn: DsnLike) {\n    this._dsnObject = new Dsn(dsn);\n  }\n\n  /** Returns the Dsn object. */\n  public getDsn(): Dsn {\n    return this._dsnObject;\n  }\n\n  /** Returns the prefix to construct Sentry ingestion API endpoints. */\n  public getBaseApiEndpoint(): string {\n    const dsn = this._dsnObject;\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 store endpoint URL. */\n  public getStoreEndpoint(): string {\n    return this._getIngestEndpoint('store');\n  }\n\n  /**\n   * Returns the store 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   */\n  public getStoreEndpointWithUrlEncodedAuth(): string {\n    return `${this.getStoreEndpoint()}?${this._encodedAuth()}`;\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   */\n  public getEnvelopeEndpointWithUrlEncodedAuth(): string {\n    return `${this._getEnvelopeEndpoint()}?${this._encodedAuth()}`;\n  }\n\n  /** Returns only the path component for the store endpoint. */\n  public getStoreEndpointPath(): string {\n    const dsn = this._dsnObject;\n    return `${dsn.path ? `/${dsn.path}` : ''}/api/${dsn.projectId}/store/`;\n  }\n\n  /**\n   * Returns an object that can be used in request headers.\n   * This is needed for node and the old /store endpoint in sentry\n   */\n  public getRequestHeaders(clientName: string, clientVersion: string): { [key: string]: string } {\n    const dsn = this._dsnObject;\n    const header = [`Sentry sentry_version=${SENTRY_API_VERSION}`];\n    header.push(`sentry_client=${clientName}/${clientVersion}`);\n    header.push(`sentry_key=${dsn.user}`);\n    if (dsn.pass) {\n      header.push(`sentry_secret=${dsn.pass}`);\n    }\n    return {\n      'Content-Type': 'application/json',\n      'X-Sentry-Auth': header.join(', '),\n    };\n  }\n\n  /** Returns the url to the report dialog endpoint. */\n  public getReportDialogEndpoint(\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 = this._dsnObject;\n    const endpoint = `${this.getBaseApiEndpoint()}embed/error-page/`;\n\n    const encodedOptions = [];\n    encodedOptions.push(`dsn=${dsn.toString()}`);\n    for (const key in dialogOptions) {\n      if (key === 'user') {\n        if (!dialogOptions.user) {\n          continue;\n        }\n        if (dialogOptions.user.name) {\n          encodedOptions.push(`name=${encodeURIComponent(dialogOptions.user.name)}`);\n        }\n        if (dialogOptions.user.email) {\n          encodedOptions.push(`email=${encodeURIComponent(dialogOptions.user.email)}`);\n        }\n      } else {\n        encodedOptions.push(`${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`);\n      }\n    }\n    if (encodedOptions.length) {\n      return `${endpoint}?${encodedOptions.join('&')}`;\n    }\n\n    return endpoint;\n  }\n\n  /** Returns the envelope endpoint URL. */\n  private _getEnvelopeEndpoint(): string {\n    return this._getIngestEndpoint('envelope');\n  }\n\n  /** Returns the ingest API endpoint for target. */\n  private _getIngestEndpoint(target: 'store' | 'envelope'): string {\n    const base = this.getBaseApiEndpoint();\n    const dsn = this._dsnObject;\n    return `${base}${dsn.projectId}/${target}/`;\n  }\n\n  /** Returns a URL-encoded string with auth config suitable for a query string. */\n  private _encodedAuth(): string {\n    const dsn = this._dsnObject;\n    const auth = {\n      // We send only the minimum set of required information. See\n      // https://github.com/getsentry/sentry-javascript/issues/2572.\n      sentry_key: dsn.user,\n      sentry_version: SENTRY_API_VERSION,\n    };\n    return urlEncode(auth);\n  }\n}\n","/* eslint-disable max-lines */\nimport { Scope, Session } from '@sentry/hub';\nimport {\n  Client,\n  Event,\n  EventHint,\n  Integration,\n  IntegrationClass,\n  Options,\n  SessionStatus,\n  Severity,\n} from '@sentry/types';\nimport {\n  dateTimestampInSeconds,\n  Dsn,\n  isPrimitive,\n  isThenable,\n  logger,\n  normalize,\n  SentryError,\n  SyncPromise,\n  truncate,\n  uuid4,\n} from '@sentry/utils';\n\nimport { Backend, BackendClass } from './basebackend';\nimport { IntegrationIndex, setupIntegrations } from './integration';\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\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 via the backend, 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<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nexport abstract class BaseClient<B extends Backend, O extends Options> implements Client<O> {\n  /**\n   * The backend used to physically interact in the environment. Usually, this\n   * will correspond to the client. When composing SDKs, however, the Backend\n   * from the root SDK will be used.\n   */\n  protected readonly _backend: B;\n\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?: Dsn;\n\n  /** Array of used integrations. */\n  protected _integrations: IntegrationIndex = {};\n\n  /** Number of call being processed */\n  protected _processing: number = 0;\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param backendClass A constructor function to create the backend.\n   * @param options Options for the client.\n   */\n  protected constructor(backendClass: BackendClass<B, O>, options: O) {\n    this._backend = new backendClass(options);\n    this._options = options;\n\n    if (options.dsn) {\n      this._dsn = new Dsn(options.dsn);\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    let eventId: string | undefined = hint && hint.event_id;\n\n    this._process(\n      this._getBackend()\n        .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(message: string, level?: Severity, hint?: EventHint, scope?: Scope): string | undefined {\n    let eventId: string | undefined = hint && hint.event_id;\n\n    const promisedEvent = isPrimitive(message)\n      ? this._getBackend().eventFromMessage(`${message}`, level, hint)\n      : this._getBackend().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    let eventId: string | undefined = hint && hint.event_id;\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 (!session.release) {\n      logger.warn('Discarded session because of missing release');\n    } else {\n      this._sendSession(session);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getDsn(): Dsn | 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 flush(timeout?: number): PromiseLike<boolean> {\n    return this._isClientProcessing(timeout).then(ready => {\n      return this._getBackend()\n        .getTransport()\n        .close(timeout)\n        .then(transportFlushed => ready && transportFlushed);\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()) {\n      this._integrations = setupIntegrations(this._options);\n    }\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      logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\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    let userAgent;\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    const user = event.user;\n    if (!session.userAgent) {\n      const headers = event.request ? event.request.headers : {};\n      for (const key in headers) {\n        if (key.toLowerCase() === 'user-agent') {\n          userAgent = headers[key];\n          break;\n        }\n      }\n    }\n\n    session.update({\n      ...(crashed && { status: SessionStatus.Crashed }),\n      user,\n      userAgent,\n      errors: session.errors + Number(errored || crashed),\n    });\n  }\n\n  /** Deliver captured session to Sentry */\n  protected _sendSession(session: Session): void {\n    this._getBackend().sendSession(session);\n  }\n\n  /** Waits for the client to be done with processing. */\n  protected _isClientProcessing(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._processing == 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  /** Returns the current backend. */\n  protected _getBackend(): B {\n    return this._backend;\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, scope?: Scope, hint?: EventHint): PromiseLike<Event | null> {\n    const { normalizeDepth = 3 } = this.getOptions();\n    const prepared: Event = {\n      ...event,\n      event_id: event.event_id || (hint && hint.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 && 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 = SyncPromise.resolve<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    if (finalScope) {\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);\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): Event | null {\n    if (!event) {\n      return null;\n    }\n\n    const normalized = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth),\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) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      normalized.contexts.trace = event.contexts.trace;\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 sdkInfo The sdkInfo of the event that will be filled with all integrations.\n   */\n  protected _applyIntegrationsMetadata(event: Event): void {\n    const sdkInfo = event.sdk;\n    const integrationsArray = Object.keys(this._integrations);\n    if (sdkInfo && integrationsArray.length > 0) {\n      sdkInfo.integrations = integrationsArray;\n    }\n  }\n\n  /**\n   * Tells the backend to send this event\n   * @param event The Sentry event to send\n   */\n  protected _sendEvent(event: Event): void {\n    this._getBackend().sendEvent(event);\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        logger.error(reason);\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    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));\n    }\n\n    const isTransaction = event.type === 'transaction';\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      return SyncPromise.reject(new SentryError('This event has been sampled, will not send event.'));\n    }\n\n    return this._prepareEvent(event, scope, hint)\n      .then(prepared => {\n        if (prepared === null) {\n          throw new SentryError('An event processor returned null, will not send event.');\n        }\n\n        const isInternalException = hint && hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        const beforeSendResult = beforeSend(prepared, hint);\n        if (typeof beforeSendResult === 'undefined') {\n          throw new SentryError('`beforeSend` method has to return `null` or a valid event.');\n        } else if (isThenable(beforeSendResult)) {\n          return (beforeSendResult as PromiseLike<Event | null>).then(\n            event => event,\n            e => {\n              throw new SentryError(`beforeSend rejected with ${e}`);\n            },\n          );\n        }\n        return beforeSendResult;\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          throw new SentryError('`beforeSend` returned `null`, will not send event.');\n        }\n\n        const session = scope && scope.getSession && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        this._sendEvent(processedEvent);\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._processing += 1;\n    promise.then(\n      value => {\n        this._processing -= 1;\n        return value;\n      },\n      reason => {\n        this._processing -= 1;\n        return reason;\n      },\n    );\n  }\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { Integration, Options } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport interface IntegrationIndex {\n  [key: string]: Integration;\n}\n\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options: Options): Integration[] {\n  const defaultIntegrations = (options.defaultIntegrations && [...options.defaultIntegrations]) || [];\n  const userIntegrations = options.integrations;\n  let integrations: Integration[] = [];\n  if (Array.isArray(userIntegrations)) {\n    const userIntegrationsNames = userIntegrations.map(i => i.name);\n    const pickedIntegrationsNames: string[] = [];\n\n    // Leave only unique default integrations, that were not overridden with provided user integrations\n    defaultIntegrations.forEach(defaultIntegration => {\n      if (\n        userIntegrationsNames.indexOf(defaultIntegration.name) === -1 &&\n        pickedIntegrationsNames.indexOf(defaultIntegration.name) === -1\n      ) {\n        integrations.push(defaultIntegration);\n        pickedIntegrationsNames.push(defaultIntegration.name);\n      }\n    });\n\n    // Don't add same user integration twice\n    userIntegrations.forEach(userIntegration => {\n      if (pickedIntegrationsNames.indexOf(userIntegration.name) === -1) {\n        integrations.push(userIntegration);\n        pickedIntegrationsNames.push(userIntegration.name);\n      }\n    });\n  } else if (typeof userIntegrations === 'function') {\n    integrations = userIntegrations(defaultIntegrations);\n    integrations = Array.isArray(integrations) ? integrations : [integrations];\n  } else {\n    integrations = [...defaultIntegrations];\n  }\n\n  // Make sure that if present, `Debug` integration will always run last\n  const integrationsNames = integrations.map(i => i.name);\n  const alwaysLastToRun = 'Debug';\n  if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n    integrations.push(...integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1));\n  }\n\n  return integrations;\n}\n\n/** Setup given integration */\nexport function setupIntegration(integration: Integration): void {\n  if (installedIntegrations.indexOf(integration.name) !== -1) {\n    return;\n  }\n  integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n  installedIntegrations.push(integration.name);\n  logger.log(`Integration installed: ${integration.name}`);\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<O extends Options>(options: O): IntegrationIndex {\n  const integrations: IntegrationIndex = {};\n  getIntegrationsToSetup(options).forEach(integration => {\n    integrations[integration.name] = integration;\n    setupIntegration(integration);\n  });\n  return integrations;\n}\n","import { Event, EventHint, Options, Session, Severity, Transport } from '@sentry/types';\nimport { logger, SentryError } from '@sentry/utils';\n\nimport { NoopTransport } from './transports/noop';\n\n/**\n * Internal platform-dependent Sentry SDK Backend.\n *\n * While {@link Client} contains business logic specific to an SDK, the\n * Backend offers platform specific implementations for low-level operations.\n * These are persisting and loading information, sending events, and hooking\n * into the environment.\n *\n * Backends receive a handle to the Client in their constructor. When a\n * Backend automatically generates events, it must pass them to\n * the Client for validation and processing first.\n *\n * Usually, the Client will be of corresponding type, e.g. NodeBackend\n * receives NodeClient. However, higher-level SDKs can choose to instantiate\n * multiple Backends and delegate tasks between them. In this case, an event\n * generated by one backend might very well be sent by another one.\n *\n * The client also provides access to options via {@link Client.getOptions}.\n * @hidden\n */\nexport interface Backend {\n  /** Creates a {@link Event} from an exception. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  eventFromException(exception: any, hint?: EventHint): PromiseLike<Event>;\n\n  /** Creates a {@link Event} from a plain message. */\n  eventFromMessage(message: string, level?: Severity, hint?: EventHint): PromiseLike<Event>;\n\n  /** Submits the event to Sentry */\n  sendEvent(event: Event): void;\n\n  /** Submits the session to Sentry */\n  sendSession(session: Session): void;\n\n  /**\n   * Returns the transport that is used by the backend.\n   * Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.\n   *\n   * @returns The transport.\n   */\n  getTransport(): Transport;\n}\n\n/**\n * A class object that can instantiate Backend objects.\n * @hidden\n */\nexport type BackendClass<B extends Backend, O extends Options> = new (options: O) => B;\n\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nexport abstract class BaseBackend<O extends Options> implements Backend {\n  /** Options passed to the SDK. */\n  protected readonly _options: O;\n\n  /** Cached transport used internally. */\n  protected _transport: Transport;\n\n  /** Creates a new backend instance. */\n  public constructor(options: O) {\n    this._options = options;\n    if (!this._options.dsn) {\n      logger.warn('No DSN provided, backend will not do anything.');\n    }\n    this._transport = this._setupTransport();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event> {\n    throw new SentryError('Backend has to implement `eventFromException` method');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(_message: string, _level?: Severity, _hint?: EventHint): PromiseLike<Event> {\n    throw new SentryError('Backend has to implement `eventFromMessage` method');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event): void {\n    this._transport.sendEvent(event).then(null, reason => {\n      logger.error(`Error while sending event: ${reason}`);\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session): void {\n    if (!this._transport.sendSession) {\n      logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n      return;\n    }\n\n    this._transport.sendSession(session).then(null, reason => {\n      logger.error(`Error while sending session: ${reason}`);\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransport(): Transport {\n    return this._transport;\n  }\n\n  /**\n   * Sets up the transport so it can be used later to send requests.\n   */\n  protected _setupTransport(): Transport {\n    return new NoopTransport();\n  }\n}\n","import { Event, SentryRequest, Session } from '@sentry/types';\n\nimport { API } from './api';\n\n/** Creates a SentryRequest from an event. */\nexport function sessionToSentryRequest(session: Session, api: API): SentryRequest {\n  const envelopeHeaders = JSON.stringify({\n    sent_at: new Date().toISOString(),\n  });\n  const itemHeaders = JSON.stringify({\n    type: 'session',\n  });\n\n  return {\n    body: `${envelopeHeaders}\\n${itemHeaders}\\n${JSON.stringify(session)}`,\n    type: 'session',\n    url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n  };\n}\n\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event: Event, api: API): SentryRequest {\n  const useEnvelope = event.type === 'transaction';\n\n  const req: SentryRequest = {\n    body: JSON.stringify(event),\n    type: event.type || 'event',\n    url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n  };\n\n  // https://develop.sentry.dev/sdk/envelopes/\n\n  // Since we don't need to manipulate envelopes nor store them, there is no\n  // exported concept of an Envelope with operations including serialization and\n  // deserialization. Instead, we only implement a minimal subset of the spec to\n  // serialize events inline here.\n  if (useEnvelope) {\n    const envelopeHeaders = JSON.stringify({\n      event_id: event.event_id,\n      // We need to add * 1000 since we divide it by 1000 by default but JS works with ms precision\n      // The reason we use timestampWithMs here is that all clocks across the SDK use the same clock\n      sent_at: new Date().toISOString(),\n    });\n    const itemHeaders = JSON.stringify({\n      type: event.type,\n      // The content-type is assumed to be 'application/json' and not part of\n      // the current spec for transaction items, so we don't bloat the request\n      // body with it.\n      //\n      // content_type: 'application/json',\n      //\n      // The length is optional. It must be the number of bytes in req.Body\n      // encoded as UTF-8. Since the server can figure this out and would\n      // otherwise refuse events that report the length incorrectly, we decided\n      // not to send the length to avoid problems related to reporting the wrong\n      // size and to reduce request body size.\n      //\n      // length: new TextEncoder().encode(req.body).length,\n    });\n    // The trailing newline is optional. We intentionally don't send it to avoid\n    // sending unnecessary bytes.\n    //\n    // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n    const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}`;\n    req.body = envelope;\n  }\n\n  return req;\n}\n","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject, SyncPromise } from '@sentry/utils';\n\nimport { BrowserOptions } from './backend';\nimport { BrowserClient } from './client';\nimport { ReportDialogOptions, wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\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 UserAgent(),\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    const window = getGlobalObject<Window>();\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 = false;\n  }\n\n  initAndBind(BrowserClient, options);\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 = {}): void {\n  if (!options.eventId) {\n    options.eventId = getCurrentHub().lastEventId();\n  }\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    client.showReportDialog(options);\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 * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.flush(timeout);\n  }\n  return SyncPromise.reject(false);\n}\n\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.close(timeout);\n  }\n  return SyncPromise.reject(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\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  const window = getGlobalObject<Window>();\n  const hub = getCurrentHub();\n\n  /**\n   * We should be using `Promise.all([windowLoaded, firstContentfulPaint])` here,\n   * but, as always, it's not available in the IE10-11. Thanks IE.\n   */\n  let loadResolved = document.readyState === 'complete';\n  let fcpResolved = false;\n  const possiblyEndSession = (): void => {\n    if (fcpResolved && loadResolved) {\n      hub.endSession();\n    }\n  };\n  const resolveWindowLoaded = (): void => {\n    loadResolved = true;\n    possiblyEndSession();\n    window.removeEventListener('load', resolveWindowLoaded);\n  };\n\n  hub.startSession();\n\n  if (!loadResolved) {\n    // IE doesn't support `{ once: true }` for event listeners, so we have to manually\n    // attach and then detach it once completed.\n    window.addEventListener('load', resolveWindowLoaded);\n  }\n\n  try {\n    const po = new PerformanceObserver((entryList, po) => {\n      entryList.getEntries().forEach(entry => {\n        if (entry.name === 'first-contentful-paint' && entry.startTime < firstHiddenTime) {\n          po.disconnect();\n          fcpResolved = true;\n          possiblyEndSession();\n        }\n      });\n    });\n\n    // There's no need to even attach this listener if `PerformanceObserver` constructor will fail,\n    // so we do it below here.\n    let firstHiddenTime = document.visibilityState === 'hidden' ? 0 : Infinity;\n    document.addEventListener(\n      'visibilitychange',\n      event => {\n        firstHiddenTime = Math.min(firstHiddenTime, event.timeStamp);\n      },\n      { once: true },\n    );\n\n    po.observe({\n      type: 'paint',\n      buffered: true,\n    });\n  } catch (e) {\n    fcpResolved = true;\n    possiblyEndSession();\n  }\n}\n","export { GlobalHandlers } from './globalhandlers';\nexport { TryCatch } from './trycatch';\nexport { Breadcrumbs } from './breadcrumbs';\nexport { LinkedErrors } from './linkederrors';\nexport { UserAgent } from './useragent';\n","import { Integration, WrappedFunction } from '@sentry/types';\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 = this.__sentry_original__ || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { Event, Integration } from '@sentry/types';\nimport { getEventDescription, isMatchingPattern, logger } 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/** JSDoc */\ninterface InboundFiltersOptions {\n  allowUrls: Array<string | RegExp>;\n  denyUrls: Array<string | RegExp>;\n  ignoreErrors: Array<string | RegExp>;\n  ignoreInternal: boolean;\n\n  /** @deprecated use {@link InboundFiltersOptions.allowUrls} instead. */\n  whitelistUrls: Array<string | RegExp>;\n  /** @deprecated use {@link InboundFiltersOptions.denyUrls} instead. */\n  blacklistUrls: Array<string | RegExp>;\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(): void {\n    addGlobalEventProcessor((event: Event) => {\n      const hub = getCurrentHub();\n      if (!hub) {\n        return event;\n      }\n      const self = hub.getIntegration(InboundFilters);\n      if (self) {\n        const client = hub.getClient();\n        const clientOptions = client ? client.getOptions() : {};\n        const options = self._mergeOptions(clientOptions);\n        if (self._shouldDropEvent(event, options)) {\n          return null;\n        }\n      }\n      return event;\n    });\n  }\n\n  /** JSDoc */\n  private _shouldDropEvent(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n    if (this._isSentryError(event, options)) {\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n      return true;\n    }\n    if (this._isIgnoredError(event, options)) {\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n      return true;\n    }\n    if (this._isDeniedUrl(event, options)) {\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${this._getEventFilterUrl(event)}`,\n      );\n      return true;\n    }\n    if (!this._isAllowedUrl(event, options)) {\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${this._getEventFilterUrl(event)}`,\n      );\n      return true;\n    }\n    return false;\n  }\n\n  /** JSDoc */\n  private _isSentryError(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n    if (!options.ignoreInternal) {\n      return false;\n    }\n\n    try {\n      return (\n        (event &&\n          event.exception &&\n          event.exception.values &&\n          event.exception.values[0] &&\n          event.exception.values[0].type === 'SentryError') ||\n        false\n      );\n    } catch (_oO) {\n      return false;\n    }\n  }\n\n  /** JSDoc */\n  private _isIgnoredError(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n    if (!options.ignoreErrors || !options.ignoreErrors.length) {\n      return false;\n    }\n\n    return this._getPossibleEventMessages(event).some(message =>\n      // Not sure why TypeScript complains here...\n      (options.ignoreErrors as Array<RegExp | string>).some(pattern => isMatchingPattern(message, pattern)),\n    );\n  }\n\n  /** JSDoc */\n  private _isDeniedUrl(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n    // TODO: Use Glob instead?\n    if (!options.denyUrls || !options.denyUrls.length) {\n      return false;\n    }\n    const url = this._getEventFilterUrl(event);\n    return !url ? false : options.denyUrls.some(pattern => isMatchingPattern(url, pattern));\n  }\n\n  /** JSDoc */\n  private _isAllowedUrl(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n    // TODO: Use Glob instead?\n    if (!options.allowUrls || !options.allowUrls.length) {\n      return true;\n    }\n    const url = this._getEventFilterUrl(event);\n    return !url ? true : options.allowUrls.some(pattern => isMatchingPattern(url, pattern));\n  }\n\n  /** JSDoc */\n  private _mergeOptions(clientOptions: Partial<InboundFiltersOptions> = {}): Partial<InboundFiltersOptions> {\n    return {\n      allowUrls: [\n        // eslint-disable-next-line deprecation/deprecation\n        ...(this._options.whitelistUrls || []),\n        ...(this._options.allowUrls || []),\n        // eslint-disable-next-line deprecation/deprecation\n        ...(clientOptions.whitelistUrls || []),\n        ...(clientOptions.allowUrls || []),\n      ],\n      denyUrls: [\n        // eslint-disable-next-line deprecation/deprecation\n        ...(this._options.blacklistUrls || []),\n        ...(this._options.denyUrls || []),\n        // eslint-disable-next-line deprecation/deprecation\n        ...(clientOptions.blacklistUrls || []),\n        ...(clientOptions.denyUrls || []),\n      ],\n      ignoreErrors: [\n        ...(this._options.ignoreErrors || []),\n        ...(clientOptions.ignoreErrors || []),\n        ...DEFAULT_IGNORE_ERRORS,\n      ],\n      ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n    };\n  }\n\n  /** JSDoc */\n  private _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        logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n        return [];\n      }\n    }\n    return [];\n  }\n\n  /** JSDoc */\n  private _getEventFilterUrl(event: Event): string | null {\n    try {\n      if (event.stacktrace) {\n        const frames = event.stacktrace.frames;\n        return (frames && frames[frames.length - 1].filename) || null;\n      }\n      if (event.exception) {\n        const frames =\n          event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n        return (frames && frames[frames.length - 1].filename) || null;\n      }\n      return null;\n    } catch (oO) {\n      logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n      return null;\n    }\n  }\n}\n","import { BaseBackend } from '@sentry/core';\nimport { Event, EventHint, Options, Severity, Transport } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\n\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see BrowserClient for more information.\n */\nexport interface BrowserOptions extends Options {\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  /** @deprecated use {@link Options.allowUrls} instead. */\n  whitelistUrls?: Array<string | RegExp>;\n\n  /** @deprecated use {@link Options.denyUrls} instead. */\n  blacklistUrls?: Array<string | RegExp>;\n\n  /**\n   * A flag enabling Sessions Tracking feature.\n   * By default Sessions Tracking is disabled.\n   */\n  autoSessionTracking?: boolean;\n}\n\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nexport class BrowserBackend extends BaseBackend<BrowserOptions> {\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options, exception, hint);\n  }\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {\n    return eventFromMessage(this._options, message, level, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _setupTransport(): Transport {\n    if (!this._options.dsn) {\n      // We return the noop transport here in case there is no Dsn.\n      return super._setupTransport();\n    }\n\n    const transportOptions = {\n      ...this._options.transportOptions,\n      dsn: this._options.dsn,\n    };\n\n    if (this._options.transport) {\n      return new this._options.transport(transportOptions);\n    }\n    if (supportsFetch()) {\n      return new FetchTransport(transportOptions);\n    }\n    return new XHRTransport(transportOptions);\n  }\n}\n","import { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { Event, Response, SentryRequest, Session } from '@sentry/types';\nimport { getGlobalObject, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\n\nimport { BaseTransport } from './base';\n\nconst global = getGlobalObject<Window>();\n\n/** `fetch` based transport */\nexport class FetchTransport extends BaseTransport {\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event): PromiseLike<Response> {\n    return this._sendRequest(eventToSentryRequest(event, this._api), event);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session): PromiseLike<Response> {\n    return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n  }\n\n  /**\n   * @param sentryRequest Prepared SentryRequest to be delivered\n   * @param originalPayload Original payload used to create SentryRequest\n   */\n  private _sendRequest(sentryRequest: SentryRequest, originalPayload: Event | Session): PromiseLike<Response> {\n    if (this._isRateLimited(sentryRequest.type)) {\n      return Promise.reject({\n        event: originalPayload,\n        type: sentryRequest.type,\n        reason: `Transport locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,\n        status: 429,\n      });\n    }\n\n    const options: RequestInit = {\n      body: sentryRequest.body,\n      method: 'POST',\n      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n      // https://caniuse.com/#feat=referrer-policy\n      // It doesn't. And it throw exception instead of ignoring this parameter...\n      // REF: https://github.com/getsentry/raven-js/issues/1233\n      referrerPolicy: (supportsReferrerPolicy() ? 'origin' : '') as ReferrerPolicy,\n    };\n    if (this.options.fetchParameters !== undefined) {\n      Object.assign(options, this.options.fetchParameters);\n    }\n    if (this.options.headers !== undefined) {\n      options.headers = this.options.headers;\n    }\n\n    return this._buffer.add(\n      new SyncPromise<Response>((resolve, reject) => {\n        global\n          .fetch(sentryRequest.url, options)\n          .then(response => {\n            const headers = {\n              'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n              'retry-after': response.headers.get('Retry-After'),\n            };\n            this._handleResponse({ requestType: sentryRequest.type, response, headers, resolve, reject });\n          })\n          .catch(reject);\n      }),\n    );\n  }\n}\n","import { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { Event, Response, SentryRequest, Session } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n\nimport { BaseTransport } from './base';\n\n/** `XHR` based transport */\nexport class XHRTransport extends BaseTransport {\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event): PromiseLike<Response> {\n    return this._sendRequest(eventToSentryRequest(event, this._api), event);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session): PromiseLike<Response> {\n    return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n  }\n\n  /**\n   * @param sentryRequest Prepared SentryRequest to be delivered\n   * @param originalPayload Original payload used to create SentryRequest\n   */\n  private _sendRequest(sentryRequest: SentryRequest, originalPayload: Event | Session): PromiseLike<Response> {\n    if (this._isRateLimited(sentryRequest.type)) {\n      return Promise.reject({\n        event: originalPayload,\n        type: sentryRequest.type,\n        reason: `Transport locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,\n        status: 429,\n      });\n    }\n\n    return this._buffer.add(\n      new SyncPromise<Response>((resolve, reject) => {\n        const request = new XMLHttpRequest();\n\n        request.onreadystatechange = (): void => {\n          if (request.readyState === 4) {\n            const headers = {\n              'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': request.getResponseHeader('Retry-After'),\n            };\n            this._handleResponse({ requestType: sentryRequest.type, response: request, headers, resolve, reject });\n          }\n        };\n\n        request.open('POST', sentryRequest.url);\n        for (const header in this.options.headers) {\n          if (this.options.headers.hasOwnProperty(header)) {\n            request.setRequestHeader(header, this.options.headers[header]);\n          }\n        }\n        request.send(sentryRequest.body);\n      }),\n    );\n  }\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, Integration, Severity } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addInstrumentationHandler,\n  getLocationHref,\n  isErrorEvent,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/utils';\n\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\n/** JSDoc */\ninterface GlobalHandlersIntegrations {\n  onerror: boolean;\n  onunhandledrejection: boolean;\n}\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  /** JSDoc */\n  private _onErrorHandlerInstalled: boolean = false;\n\n  /** JSDoc */\n  private _onUnhandledRejectionHandlerInstalled: boolean = false;\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\n    if (this._options.onerror) {\n      logger.log('Global Handler attached: onerror');\n      this._installGlobalOnErrorHandler();\n    }\n\n    if (this._options.onunhandledrejection) {\n      logger.log('Global Handler attached: onunhandledrejection');\n      this._installGlobalOnUnhandledRejectionHandler();\n    }\n  }\n\n  /** JSDoc */\n  private _installGlobalOnErrorHandler(): void {\n    if (this._onErrorHandlerInstalled) {\n      return;\n    }\n\n    addInstrumentationHandler({\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      callback: (data: { msg: any; url: any; line: any; column: any; error: any }) => {\n        const error = data.error;\n        const currentHub = getCurrentHub();\n        const hasIntegration = currentHub.getIntegration(GlobalHandlers);\n        const isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n\n        if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n          return;\n        }\n\n        const client = currentHub.getClient();\n        const event = isPrimitive(error)\n          ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n          : this._enhanceEventWithInitialFrame(\n              eventFromUnknownInput(error, undefined, {\n                attachStacktrace: client && client.getOptions().attachStacktrace,\n                rejection: false,\n              }),\n              data.url,\n              data.line,\n              data.column,\n            );\n\n        addExceptionMechanism(event, {\n          handled: false,\n          type: 'onerror',\n        });\n\n        currentHub.captureEvent(event, {\n          originalException: error,\n        });\n      },\n      type: 'error',\n    });\n\n    this._onErrorHandlerInstalled = true;\n  }\n\n  /** JSDoc */\n  private _installGlobalOnUnhandledRejectionHandler(): void {\n    if (this._onUnhandledRejectionHandlerInstalled) {\n      return;\n    }\n\n    addInstrumentationHandler({\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      callback: (e: any) => {\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        const currentHub = getCurrentHub();\n        const hasIntegration = currentHub.getIntegration(GlobalHandlers);\n        const isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n\n        if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n          return true;\n        }\n\n        const client = currentHub.getClient();\n        const event = isPrimitive(error)\n          ? this._eventFromIncompleteRejection(error)\n          : eventFromUnknownInput(error, undefined, {\n              attachStacktrace: client && client.getOptions().attachStacktrace,\n              rejection: true,\n            });\n\n        event.level = Severity.Error;\n\n        addExceptionMechanism(event, {\n          handled: false,\n          type: 'onunhandledrejection',\n        });\n\n        currentHub.captureEvent(event, {\n          originalException: error,\n        });\n\n        return;\n      },\n      type: 'unhandledrejection',\n    });\n\n    this._onUnhandledRejectionHandlerInstalled = true;\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\n  private _eventFromIncompleteOnError(msg: any, url: any, line: any, column: any): Event {\n    const ERROR_TYPES_RE = /^(?:[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;\n\n    if (isString(message)) {\n      const groups = message.match(ERROR_TYPES_RE);\n      if (groups) {\n        name = groups[1];\n        message = groups[2];\n      }\n    }\n\n    const event = {\n      exception: {\n        values: [\n          {\n            type: name || 'Error',\n            value: message,\n          },\n        ],\n      },\n    };\n\n    return this._enhanceEventWithInitialFrame(event, url, line, column);\n  }\n\n  /**\n   * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _eventFromIncompleteRejection(error: any): Event {\n    return {\n      exception: {\n        values: [\n          {\n            type: 'UnhandledRejection',\n            value: `Non-Error promise rejection captured with value: ${error}`,\n          },\n        ],\n      },\n    };\n  }\n\n  /** JSDoc */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _enhanceEventWithInitialFrame(event: Event, url: any, line: any, column: any): Event {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n    event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.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    if (event.exception.values[0].stacktrace.frames.length === 0) {\n      event.exception.values[0].stacktrace.frames.push({\n        colno,\n        filename,\n        function: '?',\n        in_app: true,\n        lineno,\n      });\n    }\n\n    return event;\n  }\n}\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\n\nimport { 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    const global = getGlobalObject();\n\n    if (this._options.setTimeout) {\n      fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n    }\n\n    if (this._options.setInterval) {\n      fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n      fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n    }\n\n    if (this._options.eventTarget) {\n      const eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(this._wrapEventTarget.bind(this));\n    }\n  }\n\n  /** JSDoc */\n  private _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\n  private _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.call(\n        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 */\n  private _wrapEventTarget(target: string): void {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const global = getGlobalObject() as { [key: string]: any };\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = global[target] && global[target].prototype;\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function(\n      original: () => void,\n    ): (eventName: string, fn: EventListenerObject, options?: boolean | AddEventListenerOptions) => 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            fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\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.call(\n          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(proto, 'removeEventListener', 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?.__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  /** JSDoc */\n  private _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            if (original.__sentry_original__) {\n              wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\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","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, Integration, Severity } from '@sentry/types';\nimport {\n  addInstrumentationHandler,\n  getEventDescription,\n  getGlobalObject,\n  htmlTreeAsString,\n  parseUrl,\n  safeJoin,\n} from '@sentry/utils';\n\n/** JSDoc */\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom: boolean;\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\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 = 'Breadcrumbs';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Breadcrumbs.id;\n\n  /** JSDoc */\n  private readonly _options: 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   * Create a breadcrumb of `sentry` from the events themselves\n   */\n  public addSentryBreadcrumb(event: Event): void {\n    if (!this._options.sentry) {\n      return;\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  /**\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({\n        callback: (...args) => {\n          this._consoleBreadcrumb(...args);\n        },\n        type: 'console',\n      });\n    }\n    if (this._options.dom) {\n      addInstrumentationHandler({\n        callback: (...args) => {\n          this._domBreadcrumb(...args);\n        },\n        type: 'dom',\n      });\n    }\n    if (this._options.xhr) {\n      addInstrumentationHandler({\n        callback: (...args) => {\n          this._xhrBreadcrumb(...args);\n        },\n        type: 'xhr',\n      });\n    }\n    if (this._options.fetch) {\n      addInstrumentationHandler({\n        callback: (...args) => {\n          this._fetchBreadcrumb(...args);\n        },\n        type: 'fetch',\n      });\n    }\n    if (this._options.history) {\n      addInstrumentationHandler({\n        callback: (...args) => {\n          this._historyBreadcrumb(...args);\n        },\n        type: 'history',\n      });\n    }\n  }\n\n  /**\n   * Creates breadcrumbs from console API calls\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _consoleBreadcrumb(handlerData: { [key: string]: any }): void {\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: Severity.fromString(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 DOM API calls\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _domBreadcrumb(handlerData: { [key: string]: any }): void {\n    let target;\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)\n        : htmlTreeAsString((handlerData.event as unknown) as Node);\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      },\n    );\n  }\n\n  /**\n   * Creates breadcrumbs from XHR API calls\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _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\n  private _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: Severity.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\n  private _historyBreadcrumb(handlerData: { [key: string]: any }): void {\n    const global = getGlobalObject<Window>();\n    let from = handlerData.from;\n    let to = handlerData.to;\n    const parsedLoc = parseUrl(global.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}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\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: string;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: number;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: { key?: string; limit?: number } = {}) {\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    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      if (self) {\n        return self._handler(event, hint);\n      }\n      return event;\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  private _handler(event: Event, hint?: EventHint): Event | null {\n    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n      return event;\n    }\n    const linkedErrors = this._walkErrorTree(hint.originalException as ExtendedError, this._key);\n    event.exception.values = [...linkedErrors, ...event.exception.values];\n    return event;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  private _walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {\n    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n      return stack;\n    }\n    const stacktrace = computeStackTrace(error[key]);\n    const exception = exceptionFromStacktrace(stacktrace);\n    return this._walkErrorTree(error[key], key, [exception, ...stack]);\n  }\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, Integration } from '@sentry/types';\nimport { getGlobalObject } from '@sentry/utils';\n\nconst global = getGlobalObject<Window>();\n\n/** UserAgent */\nexport class UserAgent implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'UserAgent';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = UserAgent.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    addGlobalEventProcessor((event: Event) => {\n      if (getCurrentHub().getIntegration(UserAgent)) {\n        // if none of the information we want exists, don't bother\n        if (!global.navigator && !global.location && !global.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        const url = event.request?.url || global.location?.href;\n        const { referrer } = global.document || {};\n        const { userAgent } = global.navigator || {};\n\n        const headers = {\n          ...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 { Event, EventProcessor, Hub, Integration } from '@sentry/types';\nimport { getGlobalObject, logger } from '@sentry/utils';\n\n// See https://github.com/angular/angular.js/blob/v1.4.7/src/minErr.js\nconst angularPattern = /^\\[((?:[$a-zA-Z0-9]+:)?(?:[$a-zA-Z0-9]+))\\] (.*?)\\n?(\\S+)$/;\n\n/**\n * AngularJS integration\n *\n * Provides an $exceptionHandler for AngularJS\n */\nexport class Angular implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'AngularJS';\n\n  /**\n   * moduleName used in Angular's DI resolution algorithm\n   */\n  public static moduleName: string = 'ngSentry';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Angular.id;\n\n  /**\n   * Angular's instance\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private readonly _angular: any;\n\n  /**\n   * ngSentry module instance\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private readonly _module: any;\n\n  /**\n   * Returns current hub.\n   */\n  private _getCurrentHub?: () => Hub;\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public constructor(options: { angular?: any } = {}) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n    this._angular = options.angular || getGlobalObject<any>().angular;\n\n    if (!this._angular) {\n      logger.error('AngularIntegration is missing an Angular instance');\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    this._module = this._angular.module(Angular.moduleName, []);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    if (!this._module) {\n      return;\n    }\n\n    this._getCurrentHub = getCurrentHub;\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    this._module.config([\n      '$provide',\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ($provide: any): void => {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        $provide.decorator('$exceptionHandler', ['$delegate', this._$exceptionHandlerDecorator.bind(this)]);\n      },\n    ]);\n  }\n\n  /**\n   * Angular's exceptionHandler for Sentry integration\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _$exceptionHandlerDecorator($delegate: any): any {\n    return (exception: Error, cause?: string): void => {\n      const hub = this._getCurrentHub && this._getCurrentHub();\n\n      if (hub && hub.getIntegration(Angular)) {\n        hub.withScope(scope => {\n          if (cause) {\n            scope.setExtra('cause', cause);\n          }\n\n          scope.addEventProcessor((event: Event) => {\n            const ex = event.exception && event.exception.values && event.exception.values[0];\n\n            if (ex) {\n              const matches = angularPattern.exec(ex.value || '');\n\n              if (matches) {\n                // This type now becomes something like: $rootScope:inprog\n                ex.type = matches[1];\n                ex.value = matches[2];\n                event.message = `${ex.type}: ${ex.value}`;\n                // auto set a new tag specifically for the angular error url\n                event.extra = {\n                  ...event.extra,\n                  angularDocs: matches[3].substr(0, 250),\n                };\n              }\n            }\n\n            return event;\n          });\n\n          hub.captureException(exception);\n        });\n      }\n      $delegate(exception, cause);\n    };\n  }\n}\n","import { EventProcessor, Hub, Integration, Severity } from '@sentry/types';\nimport { fill, getGlobalObject, safeJoin } from '@sentry/utils';\n\nconst global = getGlobalObject<Window | NodeJS.Global>();\n\n/** Send Console API calls as Sentry Events */\nexport class CaptureConsole implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'CaptureConsole';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = CaptureConsole.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _levels: string[] = ['log', 'info', 'warn', 'error', 'debug', 'assert'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: { levels?: string[] } = {}) {\n    if (options.levels) {\n      this._levels = options.levels;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    if (!('console' in global)) {\n      return;\n    }\n\n    this._levels.forEach((level: string) => {\n      if (!(level in global.console)) {\n        return;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      fill(global.console, level, (originalConsoleLevel: () => any) => (...args: any[]): void => {\n        const hub = getCurrentHub();\n\n        if (hub.getIntegration(CaptureConsole)) {\n          hub.withScope(scope => {\n            scope.setLevel(Severity.fromString(level));\n            scope.setExtra('arguments', args);\n            scope.addEventProcessor(event => {\n              event.logger = 'console';\n              return event;\n            });\n\n            let message = safeJoin(args, ' ');\n            if (level === 'assert') {\n              if (args[0] === false) {\n                message = `Assertion failed: ${safeJoin(args.slice(1), ' ') || 'console.assert'}`;\n                scope.setExtra('arguments', args.slice(1));\n                hub.captureMessage(message);\n              }\n            } else {\n              hub.captureMessage(message);\n            }\n          });\n        }\n\n        // this fails for some browsers. :(\n        if (originalConsoleLevel) {\n          Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n        }\n      });\n    });\n  }\n}\n","import { Event, EventHint, EventProcessor, Hub, Integration } from '@sentry/types';\nimport { consoleSandbox } from '@sentry/utils';\n\n/** JSDoc */\ninterface DebugOptions {\n  stringify?: boolean;\n  debugger?: boolean;\n}\n\n/** JSDoc */\nexport class Debug implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Debug';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Debug.id;\n\n  /** JSDoc */\n  private readonly _options: DebugOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: DebugOptions) {\n    this._options = {\n      debugger: false,\n      stringify: false,\n      ...options,\n    };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(Debug);\n      if (self) {\n        if (self._options.debugger) {\n          // eslint-disable-next-line no-debugger\n          debugger;\n        }\n\n        /* eslint-disable no-console */\n        consoleSandbox(() => {\n          if (self._options.stringify) {\n            console.log(JSON.stringify(event, null, 2));\n            if (hint) {\n              console.log(JSON.stringify(hint, null, 2));\n            }\n          } else {\n            console.log(event);\n            if (hint) {\n              console.log(hint);\n            }\n          }\n        });\n        /* eslint-enable no-console */\n      }\n      return event;\n    });\n  }\n}\n","import { Event, EventProcessor, Exception, Hub, Integration, StackFrame } from '@sentry/types';\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    addGlobalEventProcessor((currentEvent: Event) => {\n      const self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (self._shouldDropEvent(currentEvent, self._previousEvent)) {\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\n  /** JSDoc */\n  private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n    if (!previousEvent) {\n      return false;\n    }\n\n    if (this._isSameMessageEvent(currentEvent, previousEvent)) {\n      return true;\n    }\n\n    if (this._isSameExceptionEvent(currentEvent, previousEvent)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /** JSDoc */\n  private _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 (!this._isSameFingerprint(currentEvent, previousEvent)) {\n      return false;\n    }\n\n    if (!this._isSameStacktrace(currentEvent, previousEvent)) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /** JSDoc */\n  private _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    } else if (event.stacktrace) {\n      return event.stacktrace.frames;\n    }\n    return undefined;\n  }\n\n  /** JSDoc */\n  private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n    let currentFrames = this._getFramesFromEvent(currentEvent);\n    let previousFrames = this._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 */\n  private _getExceptionFromEvent(event: Event): Exception | undefined {\n    return event.exception && event.exception.values && event.exception.values[0];\n  }\n\n  /** JSDoc */\n  private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n    const previousException = this._getExceptionFromEvent(previousEvent);\n    const currentException = this._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 (!this._isSameFingerprint(currentEvent, previousEvent)) {\n      return false;\n    }\n\n    if (!this._isSameStacktrace(currentEvent, previousEvent)) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /** JSDoc */\n  private _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","import { EventProcessor, Hub, Integration } from '@sentry/types';\nimport { getGlobalObject, isInstanceOf, logger } from '@sentry/utils';\n\n/** JSDoc */\nexport class Ember implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Ember';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Ember.id;\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  private readonly _Ember: any;\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public constructor(options: { Ember?: any } = {}) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n    this._Ember = options.Ember || getGlobalObject<any>().Ember;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    if (!this._Ember) {\n      logger.error('EmberIntegration is missing an Ember instance');\n      return;\n    }\n\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    const oldOnError = this._Ember.onerror;\n\n    this._Ember.onerror = (error: Error): void => {\n      if (getCurrentHub().getIntegration(Ember)) {\n        getCurrentHub().captureException(error, { originalException: error });\n      }\n\n      if (typeof oldOnError === 'function') {\n        oldOnError.call(this._Ember, error);\n      } else if (this._Ember.testing) {\n        throw error;\n      }\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this._Ember.RSVP.on('error', (reason: unknown): void => {\n      if (getCurrentHub().getIntegration(Ember)) {\n        getCurrentHub().withScope(scope => {\n          if (isInstanceOf(reason, Error)) {\n            scope.setExtra('context', 'Unhandled Promise error detected');\n            getCurrentHub().captureException(reason, { originalException: reason as Error });\n          } else {\n            scope.setExtra('reason', reason);\n            getCurrentHub().captureMessage('Unhandled Promise error detected');\n          }\n        });\n      }\n    });\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n}\n","import { Event, EventHint, EventProcessor, ExtendedError, Hub, Integration } from '@sentry/types';\nimport { isError, isPlainObject, logger, normalize } from '@sentry/utils';\n\n/** JSDoc */\ninterface ExtraErrorDataOptions {\n  depth?: number;\n}\n\n/** Patch toString calls to return proper name for wrapped functions */\nexport class ExtraErrorData implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'ExtraErrorData';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = ExtraErrorData.id;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(private readonly _options: ExtraErrorDataOptions = { depth: 3 }) {}\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(ExtraErrorData);\n      if (!self) {\n        return event;\n      }\n      return self.enhanceEventWithErrorData(event, hint);\n    });\n  }\n\n  /**\n   * Attaches extracted information from the Error object to extra field in the Event\n   */\n  public enhanceEventWithErrorData(event: Event, hint?: EventHint): Event {\n    if (!hint || !hint.originalException || !isError(hint.originalException)) {\n      return event;\n    }\n    const name = (hint.originalException as ExtendedError).name || hint.originalException.constructor.name;\n\n    const errorData = this._extractErrorData(hint.originalException as ExtendedError);\n\n    if (errorData) {\n      let contexts = {\n        ...event.contexts,\n      };\n\n      const normalizedErrorData = normalize(errorData, this._options.depth);\n      if (isPlainObject(normalizedErrorData)) {\n        contexts = {\n          ...event.contexts,\n          [name]: {\n            ...normalizedErrorData,\n          },\n        };\n      }\n\n      return {\n        ...event,\n        contexts,\n      };\n    }\n\n    return event;\n  }\n\n  /**\n   * Extract extra information from the Error object\n   */\n  private _extractErrorData(error: ExtendedError): { [key: string]: unknown } | null {\n    let result = null;\n    // We are trying to enhance already existing event, so no harm done if it won't succeed\n    try {\n      const nativeKeys = ['name', 'message', 'stack', 'line', 'column', 'fileName', 'lineNumber', 'columnNumber'];\n      const errorKeys = Object.getOwnPropertyNames(error).filter(key => nativeKeys.indexOf(key) === -1);\n\n      if (errorKeys.length) {\n        const extraErrorInfo: { [key: string]: unknown } = {};\n        for (const key of errorKeys) {\n          let value = error[key];\n          if (isError(value)) {\n            value = (value as Error).toString();\n          }\n          extraErrorInfo[key] = value;\n        }\n        result = extraErrorInfo;\n      }\n    } catch (oO) {\n      logger.error('Unable to extract extra data from the Error object:', oO);\n    }\n\n    return result;\n  }\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { Event, EventProcessor, Hub, Integration } from '@sentry/types';\nimport { getGlobalObject, logger, uuid4 } from '@sentry/utils';\nimport * as localForageType from 'localforage';\n\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst localForage = require('localforage');\n/**\n * cache offline errors and send when connected\n */\nexport class Offline implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Offline';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = Offline.id;\n\n  /**\n   * the global instance\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public global: any;\n\n  /**\n   * the current hub instance\n   */\n  public hub?: Hub;\n\n  /**\n   * maximum number of events to store while offline\n   */\n  public maxStoredEvents: number;\n\n  /**\n   * event cache\n   */\n  public offlineEventStore: typeof localForageType; // type imported from localforage\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: { maxStoredEvents?: number } = {}) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this.global = getGlobalObject<any>();\n    this.maxStoredEvents = options.maxStoredEvents || 30; // set a reasonable default\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    this.offlineEventStore = localForage.createInstance({\n      name: 'sentry/offlineEventStore',\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    this.hub = getCurrentHub();\n\n    if ('addEventListener' in this.global) {\n      this.global.addEventListener('online', () => {\n        this._sendEvents().catch(() => {\n          logger.warn('could not send cached events');\n        });\n      });\n    }\n\n    addGlobalEventProcessor((event: Event) => {\n      if (this.hub && this.hub.getIntegration(Offline)) {\n        // cache if we are positively offline\n        if ('navigator' in this.global && 'onLine' in this.global.navigator && !this.global.navigator.onLine) {\n          this._cacheEvent(event)\n            .then((_event: Event): Promise<void> => this._enforceMaxEvents())\n            .catch((_error): void => {\n              logger.warn('could not cache event while offline');\n            });\n\n          // return null on success or failure, because being offline will still result in an error\n          return null;\n        }\n      }\n\n      return event;\n    });\n\n    // if online now, send any events stored in a previous offline session\n    if ('navigator' in this.global && 'onLine' in this.global.navigator && this.global.navigator.onLine) {\n      this._sendEvents().catch(() => {\n        logger.warn('could not send cached events');\n      });\n    }\n  }\n\n  /**\n   * cache an event to send later\n   * @param event an event\n   */\n  private async _cacheEvent(event: Event): Promise<Event> {\n    return this.offlineEventStore.setItem<Event>(uuid4(), event);\n  }\n\n  /**\n   * purge excess events if necessary\n   */\n  private async _enforceMaxEvents(): Promise<void> {\n    const events: Array<{ event: Event; cacheKey: string }> = [];\n\n    return this.offlineEventStore\n      .iterate<Event, void>((event: Event, cacheKey: string, _index: number): void => {\n        // aggregate events\n        events.push({ cacheKey, event });\n      })\n      .then(\n        (): Promise<void> =>\n          // this promise resolves when the iteration is finished\n          this._purgeEvents(\n            // purge all events past maxStoredEvents in reverse chronological order\n            events\n              .sort((a, b) => (b.event.timestamp || 0) - (a.event.timestamp || 0))\n              .slice(this.maxStoredEvents < events.length ? this.maxStoredEvents : events.length)\n              .map(event => event.cacheKey),\n          ),\n      )\n      .catch((_error): void => {\n        logger.warn('could not enforce max events');\n      });\n  }\n\n  /**\n   * purge event from cache\n   */\n  private async _purgeEvent(cacheKey: string): Promise<void> {\n    return this.offlineEventStore.removeItem(cacheKey);\n  }\n\n  /**\n   * purge events from cache\n   */\n  private async _purgeEvents(cacheKeys: string[]): Promise<void> {\n    // trail with .then to ensure the return type as void and not void|void[]\n    return Promise.all(cacheKeys.map(cacheKey => this._purgeEvent(cacheKey))).then();\n  }\n\n  /**\n   * send all events\n   */\n  private async _sendEvents(): Promise<void> {\n    return this.offlineEventStore.iterate<Event, void>((event: Event, cacheKey: string, _index: number): void => {\n      if (this.hub) {\n        this.hub.captureEvent(event);\n\n        this._purgeEvent(cacheKey).catch((_error): void => {\n          logger.warn('could not purge event from cache');\n        });\n      } else {\n        logger.warn('no hub found - could not send cached event');\n      }\n    });\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { EventProcessor, Hub, Integration } from '@sentry/types';\nimport { getGlobalObject, supportsReportingObserver } from '@sentry/utils';\n\n/** JSDoc */\ninterface Report {\n  [key: string]: any;\n  type: ReportTypes;\n  url: string;\n  body?: ReportBody;\n}\n\n/** JSDoc */\nenum ReportTypes {\n  /** JSDoc */\n  Crash = 'crash',\n  /** JSDoc */\n  Deprecation = 'deprecation',\n  /** JSDoc */\n  Intervention = 'intervention',\n}\n\n/** JSDoc */\ntype ReportBody = CrashReportBody | DeprecationReportBody | InterventionReportBody;\n\n/** JSDoc */\ninterface CrashReportBody {\n  [key: string]: any;\n  crashId: string;\n  reason?: string;\n}\n\n/** JSDoc */\ninterface DeprecationReportBody {\n  [key: string]: any;\n  id: string;\n  anticipatedRemoval?: Date;\n  message: string;\n  sourceFile?: string;\n  lineNumber?: number;\n  columnNumber?: number;\n}\n\n/** JSDoc */\ninterface InterventionReportBody {\n  [key: string]: any;\n  id: string;\n  message: string;\n  sourceFile?: string;\n  lineNumber?: number;\n  columnNumber?: number;\n}\n\n/** Reporting API integration - https://w3c.github.io/reporting/ */\nexport class ReportingObserver implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'ReportingObserver';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = ReportingObserver.id;\n\n  /**\n   * Returns current hub.\n   */\n  private _getCurrentHub?: () => Hub;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(\n    private readonly _options: {\n      types?: ReportTypes[];\n    } = {\n      types: [ReportTypes.Crash, ReportTypes.Deprecation, ReportTypes.Intervention],\n    },\n  ) {}\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    if (!supportsReportingObserver()) {\n      return;\n    }\n\n    this._getCurrentHub = getCurrentHub;\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const observer = new (getGlobalObject<any>().ReportingObserver)(this.handler.bind(this), {\n      buffered: true,\n      types: this._options.types,\n    });\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    observer.observe();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public handler(reports: Report[]): void {\n    const hub = this._getCurrentHub && this._getCurrentHub();\n    if (!hub || !hub.getIntegration(ReportingObserver)) {\n      return;\n    }\n    for (const report of reports) {\n      hub.withScope(scope => {\n        scope.setExtra('url', report.url);\n\n        const label = `ReportingObserver [${report.type}]`;\n        let details = 'No details available';\n\n        if (report.body) {\n          // Object.keys doesn't work on ReportBody, as all properties are inheirted\n          const plainBody: {\n            [key: string]: any;\n          } = {};\n\n          // eslint-disable-next-line guard-for-in\n          for (const prop in report.body) {\n            plainBody[prop] = report.body[prop];\n          }\n\n          scope.setExtra('body', plainBody);\n\n          if (report.type === ReportTypes.Crash) {\n            const body = report.body as CrashReportBody;\n            // A fancy way to create a message out of crashId OR reason OR both OR fallback\n            details = [body.crashId || '', body.reason || ''].join(' ').trim() || details;\n          } else {\n            const body = report.body as DeprecationReportBody | InterventionReportBody;\n            details = body.message || details;\n          }\n        }\n\n        hub.captureMessage(`${label}: ${details}`);\n      });\n    }\n  }\n}\n","import { Event, EventProcessor, Hub, Integration, StackFrame, Stacktrace } from '@sentry/types';\nimport { basename, relative } from '@sentry/utils';\n\ntype StackFrameIteratee = (frame: StackFrame) => StackFrame;\n\n/** Rewrite event frames paths */\nexport class RewriteFrames implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'RewriteFrames';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = RewriteFrames.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _root?: string;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: { root?: string; iteratee?: StackFrameIteratee } = {}) {\n    if (options.root) {\n      this._root = options.root;\n    }\n    if (options.iteratee) {\n      this._iteratee = options.iteratee;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor(event => {\n      const self = getCurrentHub().getIntegration(RewriteFrames);\n      if (self) {\n        return self.process(event);\n      }\n      return event;\n    });\n  }\n\n  /** JSDoc */\n  public process(event: Event): Event {\n    if (event.exception && Array.isArray(event.exception.values)) {\n      return this._processExceptionsEvent(event);\n    }\n\n    if (event.stacktrace) {\n      return this._processStacktraceEvent(event);\n    }\n\n    return event;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _iteratee: StackFrameIteratee = (frame: StackFrame) => {\n    if (!frame.filename) {\n      return frame;\n    }\n    // Check if the frame filename begins with `/` or a Windows-style prefix such as `C:\\`\n    const isWindowsFrame = /^[A-Z]:\\\\/.test(frame.filename);\n    const startsWithSlash = /^\\//.test(frame.filename);\n    if (isWindowsFrame || startsWithSlash) {\n      const filename = isWindowsFrame\n        ? frame.filename\n            .replace(/^[A-Z]:/, '') // remove Windows-style prefix\n            .replace(/\\\\/g, '/') // replace all `\\\\` instances with `/`\n        : frame.filename;\n      const base = this._root ? relative(this._root, filename) : basename(filename);\n      frame.filename = `app:///${base}`;\n    }\n    return frame;\n  };\n\n  /** JSDoc */\n  private _processExceptionsEvent(event: Event): Event {\n    try {\n      return {\n        ...event,\n        exception: {\n          ...event.exception,\n          // The check for this is performed inside `process` call itself, safe to skip here\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          values: event.exception!.values!.map(value => ({\n            ...value,\n            stacktrace: this._processStacktrace(value.stacktrace),\n          })),\n        },\n      };\n    } catch (_oO) {\n      return event;\n    }\n  }\n\n  /** JSDoc */\n  private _processStacktraceEvent(event: Event): Event {\n    try {\n      return {\n        ...event,\n        stacktrace: this._processStacktrace(event.stacktrace),\n      };\n    } catch (_oO) {\n      return event;\n    }\n  }\n\n  /** JSDoc */\n  private _processStacktrace(stacktrace?: Stacktrace): Stacktrace {\n    return {\n      ...stacktrace,\n      frames: stacktrace && stacktrace.frames && stacktrace.frames.map(f => this._iteratee(f)),\n    };\n  }\n}\n","import { Event, EventProcessor, Hub, Integration } from '@sentry/types';\n\n/** This function adds duration since Sentry was initialized till the time event was sent */\nexport class SessionTiming implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'SessionTiming';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = SessionTiming.id;\n\n  /** Exact time Client was initialized expressed in milliseconds since Unix Epoch. */\n  protected readonly _startTime: number = Date.now();\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor(event => {\n      const self = getCurrentHub().getIntegration(SessionTiming);\n      if (self) {\n        return self.process(event);\n      }\n      return event;\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public process(event: Event): Event {\n    const now = Date.now();\n\n    return {\n      ...event,\n      extra: {\n        ...event.extra,\n        ['session:start']: this._startTime,\n        ['session:duration']: now - this._startTime,\n        ['session:end']: now,\n      },\n    };\n  }\n}\n","import { Event, EventProcessor, Hub, Integration, StackFrame } from '@sentry/types';\n\n/** Add node transaction to the event */\nexport class Transaction implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Transaction';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Transaction.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    addGlobalEventProcessor(event => {\n      const self = getCurrentHub().getIntegration(Transaction);\n      if (self) {\n        return self.process(event);\n      }\n      return event;\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public process(event: Event): Event {\n    const frames = this._getFramesFromEvent(event);\n\n    // use for loop so we don't have to reverse whole frames array\n    for (let i = frames.length - 1; i >= 0; i--) {\n      const frame = frames[i];\n\n      if (frame.in_app === true) {\n        event.transaction = this._getTransaction(frame);\n        break;\n      }\n    }\n\n    return event;\n  }\n\n  /** JSDoc */\n  private _getFramesFromEvent(event: Event): StackFrame[] {\n    const exception = event.exception && event.exception.values && event.exception.values[0];\n    return (exception && exception.stacktrace && exception.stacktrace.frames) || [];\n  }\n\n  /** JSDoc */\n  private _getTransaction(frame: StackFrame): string {\n    return frame.module || frame.function ? `${frame.module || '?'}/${frame.function || '?'}` : '<unknown>';\n  }\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { EventProcessor, Hub, Integration, IntegrationClass, Scope, Span, Transaction } from '@sentry/types';\nimport { basename, getGlobalObject, logger, timestampWithMs } from '@sentry/utils';\n\n/**\n * Used to extract Tracing integration from the current client,\n * without the need to import `Tracing` itself from the @sentry/apm package.\n * @deprecated as @sentry/tracing should be used over @sentry/apm.\n */\nconst TRACING_GETTER = ({\n  id: 'Tracing',\n} as any) as IntegrationClass<Integration>;\n\n/**\n * Used to extract BrowserTracing integration from @sentry/tracing\n */\nconst BROWSER_TRACING_GETTER = ({\n  id: 'BrowserTracing',\n} as any) as IntegrationClass<Integration>;\n\n/** Global Vue object limited to the methods/attributes we require */\ninterface VueInstance {\n  config: {\n    errorHandler?(error: Error, vm?: ViewModel, info?: string): void;\n  };\n  util?: {\n    warn(...input: any): void;\n  };\n  mixin(hooks: { [key: string]: () => void }): void;\n}\n\n/** Representation of Vue component internals */\ninterface ViewModel {\n  [key: string]: any;\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  $root: object;\n  $options: {\n    [key: string]: any;\n    name?: string;\n    propsData?: { [key: string]: any };\n    _componentTag?: string;\n    __file?: string;\n    $_sentryPerfHook?: boolean;\n  };\n  $once(hook: string, cb: () => void): void;\n}\n\n/** Vue Integration configuration */\ninterface IntegrationOptions {\n  /** Vue instance to be used inside the integration */\n  Vue: VueInstance;\n\n  /**\n   * When set to `false`, Sentry will suppress reporting of all props data\n   * from your Vue components for privacy concerns.\n   */\n  attachProps: boolean;\n  /**\n   * When set to `true`, original Vue's `logError` will be called as well.\n   * https://github.com/vuejs/vue/blob/c2b1cfe9ccd08835f2d99f6ce60f67b4de55187f/src/core/util/error.js#L38-L48\n   */\n  logErrors: boolean;\n\n  /**\n   * When set to `true`, enables tracking of components lifecycle performance.\n   * It requires `Tracing` integration to be also enabled.\n   */\n  tracing: boolean;\n\n  /** {@link TracingOptions} */\n  tracingOptions: TracingOptions;\n}\n\n/** Vue specific configuration for Tracing Integration  */\ninterface TracingOptions {\n  /**\n   * Decides whether to track components by hooking into its lifecycle methods.\n   * Can be either set to `boolean` to enable/disable tracking for all of them.\n   * Or to an array of specific component names (case-sensitive).\n   */\n  trackComponents: boolean | string[];\n  /** How long to wait until the tracked root activity is marked as finished and sent of to Sentry */\n  timeout: number;\n  /**\n   * List of hooks to keep track of during component lifecycle.\n   * Available hooks: 'activate' | 'create' | 'destroy' | 'mount' | 'update'\n   * Based on https://vuejs.org/v2/api/#Options-Lifecycle-Hooks\n   */\n  hooks: Operation[];\n}\n\n/** Optional metadata attached to Sentry Event */\ninterface Metadata {\n  [key: string]: any;\n  componentName?: string;\n  propsData?: { [key: string]: any };\n  lifecycleHook?: string;\n}\n\n// https://vuejs.org/v2/api/#Options-Lifecycle-Hooks\ntype Hook =\n  | 'activated'\n  | 'beforeCreate'\n  | 'beforeDestroy'\n  | 'beforeMount'\n  | 'beforeUpdate'\n  | 'created'\n  | 'deactivated'\n  | 'destroyed'\n  | 'mounted'\n  | 'updated';\n\ntype Operation = 'activate' | 'create' | 'destroy' | 'mount' | 'update';\n\n// Mappings from operation to corresponding lifecycle hook.\nconst HOOKS: { [key in Operation]: Hook[] } = {\n  activate: ['activated', 'deactivated'],\n  create: ['beforeCreate', 'created'],\n  destroy: ['beforeDestroy', 'destroyed'],\n  mount: ['beforeMount', 'mounted'],\n  update: ['beforeUpdate', 'updated'],\n};\n\nconst COMPONENT_NAME_REGEXP = /(?:^|[-_/])(\\w)/g;\nconst ROOT_COMPONENT_NAME = 'root';\nconst ANONYMOUS_COMPONENT_NAME = 'anonymous component';\n\n/** JSDoc */\nexport class Vue implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Vue';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Vue.id;\n\n  private readonly _options: IntegrationOptions;\n\n  /**\n   * Cache holding already processed component names\n   */\n  private readonly _componentsCache: { [key: string]: string } = {};\n  private _rootSpan?: Span;\n  private _rootSpanTimer?: ReturnType<typeof setTimeout>;\n  private _tracingActivity?: number;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(\n    options: Partial<Omit<IntegrationOptions, 'tracingOptions'> & { tracingOptions: Partial<TracingOptions> }>,\n  ) {\n    this._options = {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      Vue: getGlobalObject<any>().Vue,\n      attachProps: true,\n      logErrors: false,\n      tracing: false,\n      ...options,\n      tracingOptions: {\n        hooks: ['mount', 'update'],\n        timeout: 2000,\n        trackComponents: false,\n        ...options.tracingOptions,\n      },\n    };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    if (!this._options.Vue) {\n      logger.error('Vue integration is missing a Vue instance');\n      return;\n    }\n\n    this._attachErrorHandler(getCurrentHub);\n\n    if (this._options.tracing) {\n      this._startTracing(getCurrentHub);\n    }\n  }\n\n  /**\n   * Extract component name from the ViewModel\n   */\n  private _getComponentName(vm: ViewModel): string {\n    // Such level of granularity is most likely not necessary, but better safe than sorry. — Kamil\n    if (!vm) {\n      return ANONYMOUS_COMPONENT_NAME;\n    }\n\n    if (vm.$root === vm) {\n      return ROOT_COMPONENT_NAME;\n    }\n\n    if (!vm.$options) {\n      return ANONYMOUS_COMPONENT_NAME;\n    }\n\n    if (vm.$options.name) {\n      return vm.$options.name;\n    }\n\n    if (vm.$options._componentTag) {\n      return vm.$options._componentTag;\n    }\n\n    // injected by vue-loader\n    if (vm.$options.__file) {\n      const unifiedFile = vm.$options.__file.replace(/^[a-zA-Z]:/, '').replace(/\\\\/g, '/');\n      const filename = basename(unifiedFile, '.vue');\n      return (\n        this._componentsCache[filename] ||\n        (this._componentsCache[filename] = filename.replace(COMPONENT_NAME_REGEXP, (_, c: string) =>\n          c ? c.toUpperCase() : '',\n        ))\n      );\n    }\n\n    return ANONYMOUS_COMPONENT_NAME;\n  }\n\n  /** Keep it as attribute function, to keep correct `this` binding inside the hooks callbacks  */\n  // eslint-disable-next-line @typescript-eslint/typedef\n  private readonly _applyTracingHooks = (vm: ViewModel, getCurrentHub: () => Hub): void => {\n    // Don't attach twice, just in case\n    if (vm.$options.$_sentryPerfHook) {\n      return;\n    }\n    vm.$options.$_sentryPerfHook = true;\n\n    const name = this._getComponentName(vm);\n    const rootMount = name === ROOT_COMPONENT_NAME;\n    const spans: { [key: string]: Span } = {};\n\n    // Render hook starts after once event is emitted,\n    // but it ends before the second event of the same type.\n    //\n    // Because of this, we start measuring inside the first event,\n    // but finish it before it triggers, to skip the event emitter timing itself.\n    const rootHandler = (hook: Hook): void => {\n      const now = timestampWithMs();\n\n      // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n      // However, on the second call (after), it'll be already in place.\n      if (this._rootSpan) {\n        this._finishRootSpan(now, getCurrentHub);\n      } else {\n        vm.$once(`hook:${hook}`, () => {\n          // Create an activity on the first event call. There'll be no second call, as rootSpan will be in place,\n          // thus new event handler won't be attached.\n\n          // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n          // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n          /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n          // eslint-disable-next-line deprecation/deprecation\n          const tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n          if (tracingIntegration) {\n            this._tracingActivity = (tracingIntegration as any).constructor.pushActivity('Vue Application Render');\n            const transaction = (tracingIntegration as any).constructor.getTransaction();\n            if (transaction) {\n              this._rootSpan = transaction.startChild({\n                description: 'Application Render',\n                op: 'Vue',\n              });\n            }\n            // Use functionality from @sentry/tracing\n          } else {\n            const activeTransaction = getActiveTransaction(getCurrentHub());\n            if (activeTransaction) {\n              this._rootSpan = activeTransaction.startChild({\n                description: 'Application Render',\n                op: 'Vue',\n              });\n            }\n          }\n          /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n        });\n      }\n    };\n\n    const childHandler = (hook: Hook, operation: Operation): void => {\n      // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n      const shouldTrack = Array.isArray(this._options.tracingOptions.trackComponents)\n        ? this._options.tracingOptions.trackComponents.indexOf(name) > -1\n        : this._options.tracingOptions.trackComponents;\n\n      if (!this._rootSpan || !shouldTrack) {\n        return;\n      }\n\n      const now = timestampWithMs();\n      const span = spans[operation];\n\n      // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n      // However, on the second call (after), it'll be already in place.\n      if (span) {\n        span.finish();\n        this._finishRootSpan(now, getCurrentHub);\n      } else {\n        vm.$once(`hook:${hook}`, () => {\n          if (this._rootSpan) {\n            spans[operation] = this._rootSpan.startChild({\n              description: `Vue <${name}>`,\n              op: operation,\n            });\n          }\n        });\n      }\n    };\n\n    // Each component has it's own scope, so all activities are only related to one of them\n    this._options.tracingOptions.hooks.forEach(operation => {\n      // Retrieve corresponding hooks from Vue lifecycle.\n      // eg. mount => ['beforeMount', 'mounted']\n      const internalHooks = HOOKS[operation];\n\n      if (!internalHooks) {\n        logger.warn(`Unknown hook: ${operation}`);\n        return;\n      }\n\n      internalHooks.forEach(internalHook => {\n        const handler = rootMount\n          ? rootHandler.bind(this, internalHook)\n          : childHandler.bind(this, internalHook, operation);\n        const currentValue = vm.$options[internalHook];\n\n        if (Array.isArray(currentValue)) {\n          vm.$options[internalHook] = [handler, ...currentValue];\n        } else if (typeof currentValue === 'function') {\n          vm.$options[internalHook] = [handler, currentValue];\n        } else {\n          vm.$options[internalHook] = [handler];\n        }\n      });\n    });\n  };\n\n  /** Finish top-level span and activity with a debounce configured using `timeout` option */\n  private _finishRootSpan(timestamp: number, getCurrentHub: () => Hub): void {\n    if (this._rootSpanTimer) {\n      clearTimeout(this._rootSpanTimer);\n    }\n\n    this._rootSpanTimer = setTimeout(() => {\n      if (this._tracingActivity) {\n        // We do this whole dance with `TRACING_GETTER` to prevent `@sentry/apm` from becoming a peerDependency.\n        // We also need to ask for the `.constructor`, as `pushActivity` and `popActivity` are static, not instance methods.\n        // eslint-disable-next-line deprecation/deprecation\n        const tracingIntegration = getCurrentHub().getIntegration(TRACING_GETTER);\n        if (tracingIntegration) {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n          (tracingIntegration as any).constructor.popActivity(this._tracingActivity);\n        }\n      }\n\n      // We should always finish the span, only should pop activity if using @sentry/apm\n      if (this._rootSpan) {\n        this._rootSpan.finish(timestamp);\n      }\n    }, this._options.tracingOptions.timeout);\n  }\n\n  /** Inject configured tracing hooks into Vue's component lifecycles */\n  private _startTracing(getCurrentHub: () => Hub): void {\n    const applyTracingHooks = this._applyTracingHooks;\n\n    this._options.Vue.mixin({\n      beforeCreate(this: ViewModel): void {\n        // eslint-disable-next-line deprecation/deprecation\n        if (getCurrentHub().getIntegration(TRACING_GETTER) || getCurrentHub().getIntegration(BROWSER_TRACING_GETTER)) {\n          // `this` points to currently rendered component\n          applyTracingHooks(this, getCurrentHub);\n        } else {\n          logger.error('Vue integration has tracing enabled, but Tracing integration is not configured');\n        }\n      },\n    });\n  }\n\n  /** Inject Sentry's handler into owns Vue's error handler  */\n  private _attachErrorHandler(getCurrentHub: () => Hub): void {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const currentErrorHandler = this._options.Vue.config.errorHandler;\n\n    this._options.Vue.config.errorHandler = (error: Error, vm?: ViewModel, info?: string): void => {\n      const metadata: Metadata = {};\n\n      if (vm) {\n        try {\n          metadata.componentName = this._getComponentName(vm);\n\n          if (this._options.attachProps) {\n            metadata.propsData = vm.$options.propsData;\n          }\n        } catch (_oO) {\n          logger.warn('Unable to extract metadata from Vue component.');\n        }\n      }\n\n      if (info) {\n        metadata.lifecycleHook = info;\n      }\n\n      if (getCurrentHub().getIntegration(Vue)) {\n        // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n        setTimeout(() => {\n          getCurrentHub().withScope(scope => {\n            scope.setContext('vue', metadata);\n            getCurrentHub().captureException(error);\n          });\n        });\n      }\n\n      if (typeof currentErrorHandler === 'function') {\n        currentErrorHandler.call(this._options.Vue, error, vm, info);\n      }\n\n      if (this._options.logErrors) {\n        if (this._options.Vue.util) {\n          this._options.Vue.util.warn(`Error in ${info}: \"${error.toString()}\"`, vm);\n        }\n        // eslint-disable-next-line no-console\n        console.error(error);\n      }\n    };\n  }\n}\n\ninterface HubType extends Hub {\n  getScope?(): Scope | undefined;\n}\n\n/** Grabs active transaction off scope */\nexport function getActiveTransaction<T extends Transaction>(hub: HubType): T | undefined {\n  if (hub && hub.getScope) {\n    const scope = hub.getScope() as Scope;\n    if (scope) {\n      return scope.getTransaction() as T | undefined;\n    }\n  }\n\n  return undefined;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\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: any): boolean {\n  switch (Object.prototype.toString.call(wat)) {\n    case '[object Error]':\n      return true;\n    case '[object Exception]':\n      return true;\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object 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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object 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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object 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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object String]';\n}\n\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: any): boolean {\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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object 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: any): boolean {\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: any): 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: any): boolean {\n  return Object.prototype.toString.call(wat) === '[object 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): boolean {\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: any): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\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","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Event, Integration, StackFrame, WrappedFunction } from '@sentry/types';\n\nimport { isNodeEnv } from './node';\nimport { snipLine } from './string';\n\n/** Internal */\ninterface SentryGlobal {\n  Sentry?: {\n    Integrations?: Integration[];\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n  };\n}\n\nconst fallbackGlobalObject = {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject<T>(): T & SentryGlobal {\n  return (isNodeEnv()\n    ? global\n    : typeof window !== 'undefined'\n    ? window\n    : typeof self !== 'undefined'\n    ? self\n    : fallbackGlobalObject) as T & SentryGlobal;\n}\n\n/**\n * Extended Window interface that allows for Crypto API usage in IE browsers\n */\ninterface MsCryptoWindow extends Window {\n  msCrypto?: Crypto;\n}\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4(): string {\n  const global = getGlobalObject() as MsCryptoWindow;\n  const crypto = global.crypto || global.msCrypto;\n\n  if (!(crypto === void 0) && crypto.getRandomValues) {\n    // Use window.crypto API if available\n    const arr = new Uint16Array(8);\n    crypto.getRandomValues(arr);\n\n    // set 4 in byte 7\n    // eslint-disable-next-line no-bitwise\n    arr[3] = (arr[3] & 0xfff) | 0x4000;\n    // set 2 most significant bits of byte 9 to '10'\n    // eslint-disable-next-line no-bitwise\n    arr[4] = (arr[4] & 0x3fff) | 0x8000;\n\n    const pad = (num: number): string => {\n      let v = num.toString(16);\n      while (v.length < 4) {\n        v = `0${v}`;\n      }\n      return v;\n    };\n\n    return (\n      pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7])\n    );\n  }\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, c => {\n    // eslint-disable-next-line no-bitwise\n    const r = (Math.random() * 16) | 0;\n    // eslint-disable-next-line no-bitwise\n    const v = c === 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\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(\n  url: string,\n): {\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 * 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  if (event.message) {\n    return event.message;\n  }\n  if (event.exception && event.exception.values && event.exception.values[0]) {\n    const exception = event.exception.values[0];\n\n    if (exception.type && exception.value) {\n      return `${exception.type}: ${exception.value}`;\n    }\n    return exception.type || exception.value || event.event_id || '<unknown>';\n  }\n  return event.event_id || '<unknown>';\n}\n\n/** JSDoc */\ninterface ExtensibleConsole extends Console {\n  [key: string]: any;\n}\n\n/** JSDoc */\nexport function consoleSandbox(callback: () => any): any {\n  const global = getGlobalObject<Window>();\n  const levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n\n  if (!('console' in global)) {\n    return callback();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const originalConsole = (global as any).console as ExtensibleConsole;\n  const wrappedLevels: { [key: string]: any } = {};\n\n  // Restore all wrapped console methods\n  levels.forEach(level => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    if (level in (global as any).console && (originalConsole[level] as WrappedFunction).__sentry_original__) {\n      wrappedLevels[level] = originalConsole[level] as WrappedFunction;\n      originalConsole[level] = (originalConsole[level] as WrappedFunction).__sentry_original__;\n    }\n  });\n\n  // Perform callback manipulations\n  const result = callback();\n\n  // Revert restoration to wrapped state\n  Object.keys(wrappedLevels).forEach(level => {\n    originalConsole[level] = wrappedLevels[level];\n  });\n\n  return result;\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  event.exception = event.exception || {};\n  event.exception.values = event.exception.values || [];\n  event.exception.values[0] = event.exception.values[0] || {};\n  event.exception.values[0].value = event.exception.values[0].value || value || '';\n  event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(\n  event: Event,\n  mechanism: {\n    [key: string]: any;\n  } = {},\n): void {\n  // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n  try {\n    // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception!.values![0].mechanism = event.exception!.values![0].mechanism || {};\n    Object.keys(mechanism).forEach(key => {\n      // @ts-ignore Mechanism has no index signature\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception!.values![0].mechanism[key] = mechanism[key];\n    });\n  } catch (_oO) {\n    // no-empty\n  }\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  try {\n    return document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP = /^(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\nconst defaultRetryAfter = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now: number, header?: string | number | null): number {\n  if (!header) {\n    return defaultRetryAfter;\n  }\n\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 defaultRetryAfter;\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 * 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","import { API, captureException, withScope } from '@sentry/core';\nimport { DsnLike, Event as SentryEvent, Mechanism, Scope, WrappedFunction } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, logger } from '@sentry/utils';\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.\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  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // We don't wanna wrap it twice\n    if (fn.__sentry__) {\n      return fn;\n    }\n\n    // If this has already been wrapped in the past, return that wrapped function\n    if (fn.__sentry_wrapped__) {\n      return fn.__sentry_wrapped__;\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const sentryWrapped: WrappedFunction = function(this: any): 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      if (fn.handleEvent) {\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        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        return fn.handleEvent.apply(this, wrappedArguments);\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          const processedEvent = { ...event };\n\n          if (options.mechanism) {\n            addExceptionTypeValue(processedEvent, undefined, undefined);\n            addExceptionMechanism(processedEvent, options.mechanism);\n          }\n\n          processedEvent.extra = {\n            ...processedEvent.extra,\n            arguments: args,\n          };\n\n          return processedEvent;\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  fn.prototype = fn.prototype || {};\n  sentryWrapped.prototype = fn.prototype;\n\n  Object.defineProperty(fn, '__sentry_wrapped__', {\n    enumerable: false,\n    value: sentryWrapped,\n  });\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  Object.defineProperties(sentryWrapped, {\n    __sentry__: {\n      enumerable: false,\n      value: true,\n    },\n    __sentry_original__: {\n      enumerable: false,\n      value: fn,\n    },\n  });\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\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options: ReportDialogOptions = {}): void {\n  if (!options.eventId) {\n    logger.error(`Missing eventId option in showReportDialog call`);\n    return;\n  }\n  if (!options.dsn) {\n    logger.error(`Missing dsn option in showReportDialog call`);\n    return;\n  }\n\n  const script = document.createElement('script');\n  script.async = true;\n  script.src = new API(options.dsn).getReportDialogEndpoint(options);\n\n  if (options.onLoad) {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    script.onload = options.onLoad;\n  }\n\n  (document.head || document.body).appendChild(script);\n}\n","import { setPrototypeOf } from './polyfill';\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 constructor(public message: string) {\n    super(message);\n\n    this.name = new.target.prototype.constructor.name;\n    setPrototypeOf(this, new.target.prototype);\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { consoleSandbox, getGlobalObject } from './misc';\n\n// TODO: Implement different loggers for different environments\nconst global = getGlobalObject<Window | NodeJS.Global>();\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\n/** JSDoc */\nclass Logger {\n  /** JSDoc */\n  private _enabled: boolean;\n\n  /** JSDoc */\n  public constructor() {\n    this._enabled = false;\n  }\n\n  /** JSDoc */\n  public disable(): void {\n    this._enabled = false;\n  }\n\n  /** JSDoc */\n  public enable(): void {\n    this._enabled = true;\n  }\n\n  /** JSDoc */\n  public log(...args: any[]): void {\n    if (!this._enabled) {\n      return;\n    }\n    consoleSandbox(() => {\n      global.console.log(`${PREFIX}[Log]: ${args.join(' ')}`);\n    });\n  }\n\n  /** JSDoc */\n  public warn(...args: any[]): void {\n    if (!this._enabled) {\n      return;\n    }\n    consoleSandbox(() => {\n      global.console.warn(`${PREFIX}[Warn]: ${args.join(' ')}`);\n    });\n  }\n\n  /** JSDoc */\n  public error(...args: any[]): void {\n    if (!this._enabled) {\n      return;\n    }\n    consoleSandbox(() => {\n      global.console.error(`${PREFIX}[Error]: ${args.join(' ')}`);\n    });\n  }\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nconst logger = (global.__SENTRY__.logger as Logger) || (global.__SENTRY__.logger = new Logger());\n\nexport { logger };\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ExtractedNodeRequestData } from '@sentry/types';\n\nimport { isString } from './is';\nimport { normalize } from './object';\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  return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\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\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/** Default request keys that'll be used to extract data from the request */\nconst DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\n\n/**\n * Normalizes data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not\n * provided.\n * @returns An object containing normalized request data\n */\nexport function extractNodeRequestData(\n  req: { [key: string]: any },\n  keys: string[] = DEFAULT_REQUEST_KEYS,\n): ExtractedNodeRequestData {\n  // make sure we can safely use dynamicRequire below\n  if (!isNodeEnv()) {\n    throw new Error(\"Can't get node request data outside of a node environment\");\n  }\n\n  const requestData: { [key: string]: any } = {};\n\n  // headers:\n  //   node, express: req.headers\n  //   koa: req.header\n  const headers = (req.headers || req.header || {}) as {\n    host?: string;\n    cookie?: string;\n  };\n  // method:\n  //   node, express, koa: req.method\n  const method = req.method;\n  // host:\n  //   express: req.hostname in > 4 and req.host in < 4\n  //   koa: req.host\n  //   node: req.headers.host\n  const host = req.hostname || req.host || headers.host || '<no host>';\n  // protocol:\n  //   node: <n/a>\n  //   express, koa: req.protocol\n  const protocol =\n    req.protocol === 'https' || req.secure || ((req.socket || {}) as { encrypted?: boolean }).encrypted\n      ? 'https'\n      : 'http';\n  // url (including path and query string):\n  //   node, express: req.originalUrl\n  //   koa: req.url\n  const originalUrl = (req.originalUrl || req.url || '') as string;\n  // absolute url\n  const absoluteUrl = `${protocol}://${host}${originalUrl}`;\n\n  keys.forEach(key => {\n    switch (key) {\n      case 'headers':\n        requestData.headers = headers;\n        break;\n      case 'method':\n        requestData.method = method;\n        break;\n      case 'url':\n        requestData.url = absoluteUrl;\n        break;\n      case 'cookies':\n        // cookies:\n        //   node, express, koa: req.headers.cookie\n        //   vercel, sails.js, express (w/ cookie middleware): req.cookies\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        requestData.cookies = req.cookies || dynamicRequire(module, 'cookie').parse(headers.cookie || '');\n        break;\n      case 'query_string':\n        // query string:\n        //   node: req.url (raw)\n        //   express, koa: req.query\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        requestData.query_string = dynamicRequire(module, 'url').parse(originalUrl || '', false).query;\n        break;\n      case 'data':\n        if (method === 'GET' || method === 'HEAD') {\n          break;\n        }\n        // body data:\n        //   node, express, koa: req.body\n        if (req.body !== undefined) {\n          requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));\n        }\n        break;\n      default:\n        if ({}.hasOwnProperty.call(req, key)) {\n          requestData[key] = (req as { [key: string]: any })[key];\n        }\n    }\n  });\n\n  return requestData;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ExtendedError, WrappedFunction } from '@sentry/types';\n\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName } from './stacktrace';\nimport { truncate } from './string';\n\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacement A function that should be used to wrap a given method.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacement: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacement(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      wrapped.prototype = wrapped.prototype || {};\n      Object.defineProperties(wrapped, {\n        __sentry_original__: {\n          enumerable: false,\n          value: original,\n        },\n      });\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 * 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 object into an object literal with all it's attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order to be usable by the serializer\n */\nfunction getWalkSource(\n  value: any,\n): {\n  [key: string]: any;\n} {\n  if (isError(value)) {\n    const error = value as ExtendedError;\n    const err: {\n      [key: string]: any;\n      stack: string | undefined;\n      message: string;\n      name: string;\n    } = {\n      message: error.message,\n      name: error.name,\n      stack: error.stack,\n    };\n\n    for (const i in error) {\n      if (Object.prototype.hasOwnProperty.call(error, i)) {\n        err[i] = error[i];\n      }\n    }\n\n    return err;\n  }\n\n  if (isEvent(value)) {\n    /**\n     * Event-like interface that's usable in browser and node\n     */\n    interface SimpleEvent {\n      [key: string]: unknown;\n      type: string;\n      target?: unknown;\n      currentTarget?: unknown;\n    }\n\n    const event = value as SimpleEvent;\n\n    const source: {\n      [key: string]: any;\n    } = {};\n\n    source.type = event.type;\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      source.target = isElement(event.target)\n        ? htmlTreeAsString(event.target)\n        : Object.prototype.toString.call(event.target);\n    } catch (_oO) {\n      source.target = '<unknown>';\n    }\n\n    try {\n      source.currentTarget = isElement(event.currentTarget)\n        ? htmlTreeAsString(event.currentTarget)\n        : Object.prototype.toString.call(event.currentTarget);\n    } catch (_oO) {\n      source.currentTarget = '<unknown>';\n    }\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      source.detail = event.detail;\n    }\n\n    for (const i in event) {\n      if (Object.prototype.hasOwnProperty.call(event, i)) {\n        source[i] = event;\n      }\n    }\n\n    return source;\n  }\n\n  return value as {\n    [key: string]: any;\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 */\nfunction jsonSize(value: any): number {\n  return utf8Length(JSON.stringify(value));\n}\n\n/** JSDoc */\nexport function normalizeToSize<T>(\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 serialized = normalize(object, depth);\n\n  if (jsonSize(serialized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return serialized as T;\n}\n\n/** Transforms any input value into a string form, either primitive value or a type of the input */\nfunction serializeValue(value: any): any {\n  const type = Object.prototype.toString.call(value);\n\n  // Node.js REPL notation\n  if (typeof value === 'string') {\n    return value;\n  }\n  if (type === '[object Object]') {\n    return '[Object]';\n  }\n  if (type === '[object Array]') {\n    return '[Array]';\n  }\n\n  const normalized = normalizeValue(value);\n  return isPrimitive(normalized) ? normalized : type;\n}\n\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue<T>(value: T, key?: any): T | string {\n  if (key === 'domain' && value && typeof value === 'object' && ((value as unknown) as { _events: any })._events) {\n    return '[Domain]';\n  }\n\n  if (key === 'domainEmitter') {\n    return '[DomainEmitter]';\n  }\n\n  if (typeof (global as any) !== 'undefined' && (value as unknown) === global) {\n    return '[Global]';\n  }\n\n  if (typeof (window as any) !== 'undefined' && (value as unknown) === window) {\n    return '[Window]';\n  }\n\n  if (typeof (document as any) !== 'undefined' && (value as unknown) === document) {\n    return '[Document]';\n  }\n\n  // React's SyntheticEvent thingy\n  if (isSyntheticEvent(value)) {\n    return '[SyntheticEvent]';\n  }\n\n  if (typeof value === 'number' && value !== value) {\n    return '[NaN]';\n  }\n\n  if (value === void 0) {\n    return '[undefined]';\n  }\n\n  if (typeof value === 'function') {\n    return `[Function: ${getFunctionName(value)}]`;\n  }\n\n  return value;\n}\n\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function walk(key: string, value: any, depth: number = +Infinity, memo: Memo = new Memo()): any {\n  // If we reach the maximum depth, serialize whatever has left\n  if (depth === 0) {\n    return serializeValue(value);\n  }\n\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // If value implements `toJSON` method, call it and return early\n  if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n    return value.toJSON();\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n  // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n  const normalized = normalizeValue(value, key);\n  if (isPrimitive(normalized)) {\n    return normalized;\n  }\n\n  // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n  const source = getWalkSource(value);\n\n  // Create an accumulator that will act as a parent for all future itterations of that branch\n  const acc = Array.isArray(value) ? [] : {};\n\n  // If we already walked that branch, bail out, as it's circular reference\n  if (memo.memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // Walk all keys of the source\n  for (const innerKey in source) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n      continue;\n    }\n    // Recursively walk through all the child nodes\n    (acc as { [key: string]: any })[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n  }\n\n  // Once walked through all the branches, remove the parent from memo storage\n  memo.unmemoize(value);\n\n  // Return accumulated values\n  return acc;\n}\n\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function normalize(input: any, depth?: number): any {\n  try {\n    return JSON.parse(JSON.stringify(input, (key: string, value: any) => walk(key, value, depth)));\n  } catch (_oO) {\n    return '**non-serializable**';\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 */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception: any, maxLength: number = 40): string {\n  const keys = Object.keys(getWalkSource(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 the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys<T>(val: T): T {\n  if (isPlainObject(val)) {\n    const obj = val as { [key: string]: any };\n    const rv: { [key: string]: any } = {};\n    for (const key of Object.keys(obj)) {\n      if (typeof obj[key] !== 'undefined') {\n        rv[key] = dropUndefinedKeys(obj[key]);\n      }\n    }\n    return rv as T;\n  }\n\n  if (Array.isArray(val)) {\n    return val.map(dropUndefinedKeys) as any;\n  }\n\n  return val;\n}\n","const 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","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\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 ll = newLine.length;\n  if (ll <= 150) {\n    return newLine;\n  }\n  if (colno > ll) {\n    // eslint-disable-next-line no-param-reassign\n    colno = ll;\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, ll);\n  if (end > ll - 5) {\n    end = ll;\n  }\n  if (end === ll) {\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 < ll) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input: any[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value: string, pattern: RegExp | string): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return (pattern as RegExp).test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n","import { Event, EventHint, Options, Severity } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isPlainObject,\n  SyncPromise,\n} from '@sentry/utils';\n\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options: Options, exception: unknown, hint?: EventHint): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(exception, syntheticException, {\n    attachStacktrace: options.attachStacktrace,\n  });\n  addExceptionMechanism(event, {\n    handled: true,\n    type: 'generic',\n  });\n  event.level = Severity.Error;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return SyncPromise.resolve(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  options: Options,\n  message: string,\n  level: Severity = Severity.Info,\n  hint?: EventHint,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(message, syntheticException, {\n    attachStacktrace: options.attachStacktrace,\n  });\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return SyncPromise.resolve(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  exception: unknown,\n  syntheticException?: Error,\n  options: {\n    rejection?: boolean;\n    attachStacktrace?: boolean;\n  } = {},\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    // eslint-disable-next-line no-param-reassign\n    exception = errorEvent.error;\n    event = eventFromStacktrace(computeStackTrace(exception as Error));\n    return event;\n  }\n  if (isDOMError(exception as DOMError) || isDOMException(exception as DOMException)) {\n    // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n    // then we just extract the name, code, and message, as they don't provide anything else\n    // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n    // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n    const domException = exception as DOMException;\n    const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n    const message = domException.message ? `${name}: ${domException.message}` : name;\n\n    event = eventFromString(message, syntheticException, options);\n    addExceptionTypeValue(event, message);\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception as Error)) {\n    // we have a real Error object, do nothing\n    event = eventFromStacktrace(computeStackTrace(exception as Error));\n    return event;\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it is plain Object or Event, serialize it manually and extract options\n    // This will allow us to group events based on top-level keys\n    // which is much better than creating new group when any key/value change\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(objectException, syntheticException, options.rejection);\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(exception as string, syntheticException, options);\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  input: string,\n  syntheticException?: Error,\n  options: {\n    attachStacktrace?: boolean;\n  } = {},\n): Event {\n  const event: Event = {\n    message: input,\n  };\n\n  if (options.attachStacktrace && syntheticException) {\n    const stacktrace = computeStackTrace(syntheticException);\n    const frames = prepareFramesForEvent(stacktrace.stack);\n    event.stacktrace = {\n      frames,\n    };\n  }\n\n  return event;\n}\n","/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/**\n * An object representing a single stack frame.\n * {Object} StackFrame\n * {string} url The JavaScript or HTML file URL.\n * {string} func The function name, or empty for anonymous functions (if guessing did not work).\n * {string[]?} args The arguments passed to the function, if known.\n * {number=} line The line number, if known.\n * {number=} column The column number, if known.\n * {string[]} context An array of source code lines; the middle element corresponds to the correct line#.\n */\nexport interface StackFrame {\n  url: string;\n  func: string;\n  args: string[];\n  line: number | null;\n  column: number | null;\n}\n\n/**\n * An object representing a JavaScript stack trace.\n * {Object} StackTrace\n * {string} name The name of the thrown exception.\n * {string} message The exception error message.\n * {TraceKit.StackFrame[]} stack An array of stack frames.\n */\nexport interface StackTrace {\n  name: string;\n  message: string;\n  mechanism?: string;\n  stack: StackFrame[];\n  failed?: boolean;\n}\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\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 gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nconst geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nconst chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex: any): StackTrace {\n  let stack = null;\n  let popSize = 0;\n\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      popSize = ex.framesToPop;\n    } else if (reactMinifiedRegexp.test(ex.message)) {\n      popSize = 1;\n    }\n  }\n\n  try {\n    // This must be tried first because Opera 10 *destroys*\n    // its stacktrace property if you try to access the stack\n    // property first!!\n    stack = computeStackTraceFromStacktraceProp(ex);\n    if (stack) {\n      return popFrames(stack, popSize);\n    }\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    stack = computeStackTraceFromStackProp(ex);\n    if (stack) {\n      return popFrames(stack, popSize);\n    }\n  } catch (e) {\n    // no-empty\n  }\n\n  return {\n    message: extractMessage(ex),\n    name: ex && ex.name,\n    stack: [],\n    failed: true,\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex: any): StackTrace | null {\n  if (!ex || !ex.stack) {\n    return null;\n  }\n\n  const stack = [];\n  const lines = ex.stack.split('\\n');\n  let isEval;\n  let submatch;\n  let parts;\n  let element;\n\n  for (let i = 0; i < lines.length; ++i) {\n    if ((parts = chrome.exec(lines[i]))) {\n      const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n      isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n      if (isEval && (submatch = chromeEval.exec(parts[2]))) {\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      element = {\n        // working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n        // prefix here seems like the quickest solution for now.\n        url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n        func: parts[1] || UNKNOWN_FUNCTION,\n        args: isNative ? [parts[2]] : [],\n        line: parts[3] ? +parts[3] : null,\n        column: parts[4] ? +parts[4] : null,\n      };\n    } else if ((parts = winjs.exec(lines[i]))) {\n      element = {\n        url: parts[2],\n        func: parts[1] || UNKNOWN_FUNCTION,\n        args: [],\n        line: +parts[3],\n        column: parts[4] ? +parts[4] : null,\n      };\n    } else if ((parts = gecko.exec(lines[i]))) {\n      isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n      if (isEval && (submatch = geckoEval.exec(parts[3]))) {\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      } else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n        // FireFox uses this awesome columnNumber property for its top frame\n        // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n        // so adding 1\n        // NOTE: this hack doesn't work if top-most frame is eval\n        stack[0].column = (ex.columnNumber as number) + 1;\n      }\n      element = {\n        url: parts[3],\n        func: parts[1] || UNKNOWN_FUNCTION,\n        args: parts[2] ? parts[2].split(',') : [],\n        line: parts[4] ? +parts[4] : null,\n        column: parts[5] ? +parts[5] : null,\n      };\n    } else {\n      continue;\n    }\n\n    if (!element.func && element.line) {\n      element.func = UNKNOWN_FUNCTION;\n    }\n\n    stack.push(element);\n  }\n\n  if (!stack.length) {\n    return null;\n  }\n\n  return {\n    message: extractMessage(ex),\n    name: ex.name,\n    stack,\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex: any): StackTrace | null {\n  if (!ex || !ex.stacktrace) {\n    return null;\n  }\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;\n  const opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n  const opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n  const lines = stacktrace.split('\\n');\n  const stack = [];\n  let parts;\n\n  for (let line = 0; line < lines.length; line += 2) {\n    let element = null;\n    if ((parts = opera10Regex.exec(lines[line]))) {\n      element = {\n        url: parts[2],\n        func: parts[3],\n        args: [],\n        line: +parts[1],\n        column: null,\n      };\n    } else if ((parts = opera11Regex.exec(lines[line]))) {\n      element = {\n        url: parts[6],\n        func: parts[3] || parts[4],\n        args: parts[5] ? parts[5].split(',') : [],\n        line: +parts[1],\n        column: +parts[2],\n      };\n    }\n\n    if (element) {\n      if (!element.func && element.line) {\n        element.func = UNKNOWN_FUNCTION;\n      }\n      stack.push(element);\n    }\n  }\n\n  if (!stack.length) {\n    return null;\n  }\n\n  return {\n    message: extractMessage(ex),\n    name: ex.name,\n    stack,\n  };\n}\n\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace: StackTrace, popSize: number): StackTrace {\n  try {\n    return {\n      ...stacktrace,\n      stack: stacktrace.stack.slice(popSize),\n    };\n  } catch (e) {\n    return stacktrace;\n  }\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction extractMessage(ex: any): 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","import { API } from '@sentry/core';\nimport {\n  Event,\n  Response as SentryResponse,\n  SentryRequestType,\n  Status,\n  Transport,\n  TransportOptions,\n} from '@sentry/types';\nimport { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';\n\n/** Base Transport class implementation */\nexport abstract class BaseTransport implements Transport {\n  /**\n   * @deprecated\n   */\n  public url: string;\n\n  /** Helper to get Sentry API endpoints. */\n  protected readonly _api: API;\n\n  /** A simple buffer holding all requests. */\n  protected readonly _buffer: PromiseBuffer<SentryResponse> = new PromiseBuffer(30);\n\n  /** Locks transport after receiving rate limits in a response */\n  protected readonly _rateLimits: Record<string, Date> = {};\n\n  public constructor(public options: TransportOptions) {\n    this._api = new API(this.options.dsn);\n    // eslint-disable-next-line deprecation/deprecation\n    this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(_: Event): PromiseLike<SentryResponse> {\n    throw new SentryError('Transport Class has to implement `sendEvent` method');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this._buffer.drain(timeout);\n  }\n\n  /**\n   * Handle Sentry repsonse for promise-based transports.\n   */\n  protected _handleResponse({\n    requestType,\n    response,\n    headers,\n    resolve,\n    reject,\n  }: {\n    requestType: SentryRequestType;\n    response: Response | XMLHttpRequest;\n    headers: Record<string, string | null>;\n    resolve: (value?: SentryResponse | PromiseLike<SentryResponse> | null | undefined) => void;\n    reject: (reason?: unknown) => void;\n  }): void {\n    const status = Status.fromHttpCode(response.status);\n    /**\n     * \"The name is case-insensitive.\"\n     * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n     */\n    const limited = this._handleRateLimit(headers);\n    if (limited) logger.warn(`Too many requests, backing off till: ${this._disabledUntil(requestType)}`);\n\n    if (status === Status.Success) {\n      resolve({ status });\n      return;\n    }\n\n    reject(response);\n  }\n\n  /**\n   * Gets the time that given category is disabled until for rate limiting\n   */\n  protected _disabledUntil(category: string): Date {\n    return this._rateLimits[category] || this._rateLimits.all;\n  }\n\n  /**\n   * Checks if a category is rate limited\n   */\n  protected _isRateLimited(category: string): boolean {\n    return this._disabledUntil(category) > new Date(Date.now());\n  }\n\n  /**\n   * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n   */\n  protected _handleRateLimit(headers: Record<string, string | null>): boolean {\n    const now = Date.now();\n    const rlHeader = headers['x-sentry-rate-limits'];\n    const raHeader = headers['retry-after'];\n\n    if (rlHeader) {\n      for (const limit of rlHeader.trim().split(',')) {\n        const parameters = limit.split(':', 2);\n        const headerDelay = parseInt(parameters[0], 10);\n        const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n        for (const category of parameters[1].split(';')) {\n          this._rateLimits[category || 'all'] = new Date(now + delay);\n        }\n      }\n      return true;\n    } else if (raHeader) {\n      this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n      return true;\n    }\n    return false;\n  }\n}\n","/* eslint-disable max-lines */\nimport {\n  Breadcrumb,\n  CaptureContext,\n  Context,\n  Contexts,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Scope as ScopeInterface,\n  ScopeContext,\n  Severity,\n  Span,\n  Transaction,\n  User,\n} from '@sentry/types';\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n\nimport { Session } from './session';\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 notifiying is happening. */\n  protected _notifyingListeners: boolean = false;\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]: string } = {};\n\n  /** Extra */\n  protected _extra: Extras = {};\n\n  /** Contexts */\n  protected _contexts: Contexts = {};\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  protected _level?: Severity;\n\n  /** Transaction Name */\n  protected _transactionName?: string;\n\n  /** Span */\n  protected _span?: Span;\n\n  /** Session */\n  protected _session?: Session;\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    }\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      this._session.update({ 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 setTags(tags: { [key: string]: string }): 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: string): 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(level: Severity): 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   * Can be removed in major version.\n   * @deprecated in favor of {@link this.setTransactionName}\n   */\n  public setTransaction(name?: string): this {\n    return this.setTransactionName(name);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSpan(span?: Span): this {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSpan(): Span | undefined {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransaction(): Transaction | undefined {\n    // often, this span will be a transaction, but it's not guaranteed to be\n    const span = this.getSpan() as undefined | (Span & { spanRecorder: { spans: Span[] } });\n\n    // try it the new way first\n    if (span?.transaction) {\n      return span?.transaction;\n    }\n\n    // fallback to the old way (known bug: this only finds transactions with sampled = true)\n    if (span?.spanRecorder?.spans[0]) {\n      return span.spanRecorder.spans[0] as Transaction;\n    }\n\n    // neither way found a transaction\n    return undefined;\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    } 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    }\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._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n\n    this._breadcrumbs =\n      maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n        ? [...this._breadcrumbs, mergedBreadcrumb].slice(-maxBreadcrumbs)\n        : [...this._breadcrumbs, mergedBreadcrumb];\n    this._notifyScopeListeners();\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   * Applies the current context and fingerprint to the event.\n   * Note that breadcrumbs will be added by the client.\n   * Also if the event has already breadcrumbs on it, we do not merge them.\n   * @param event Event\n   * @param hint May contain additional informartion about the original exception.\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    // 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 relys on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = 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    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\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        if (isThenable(result)) {\n          (result as PromiseLike<Event | null>)\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          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    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      setTimeout(() => {\n        this._scopeListeners.forEach(callback => {\n          callback(this);\n        });\n        this._notifyingListeners = false;\n      });\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\n      ? Array.isArray(event.fingerprint)\n        ? event.fingerprint\n        : [event.fingerprint]\n      : [];\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 * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors(): EventProcessor[] {\n  /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n  const global = getGlobalObject<any>();\n  global.__SENTRY__ = global.__SENTRY__ || {};\n  global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n  return global.__SENTRY__.globalEventProcessors;\n  /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n  getGlobalEventProcessors().push(callback);\n}\n","import { isString } from './is';\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem: unknown): 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);\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): 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  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  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","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nexport class Memo {\n  /** Determines if WeakSet is available */\n  private readonly _hasWeakSet: boolean;\n  /** Either WeakSet or Array */\n  private readonly _inner: any;\n\n  public constructor() {\n    this._hasWeakSet = typeof WeakSet === 'function';\n    this._inner = this._hasWeakSet ? new WeakSet() : [];\n  }\n\n  /**\n   * Sets obj to remember.\n   * @param obj Object to remember\n   */\n  public memoize(obj: any): boolean {\n    if (this._hasWeakSet) {\n      if (this._inner.has(obj)) {\n        return true;\n      }\n      this._inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < this._inner.length; i++) {\n      const value = this._inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    this._inner.push(obj);\n    return false;\n  }\n\n  /**\n   * Removes object from internal storage.\n   * @param obj Object to forget\n   */\n  public unmemoize(obj: any): void {\n    if (this._hasWeakSet) {\n      this._inner.delete(obj);\n    } else {\n      for (let i = 0; i < this._inner.length; i++) {\n        if (this._inner[i] === obj) {\n          this._inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n}\n","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\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 getGlobalObject<Window>())) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('');\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\nfunction 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  const global = getGlobalObject<Window>();\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(global.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 = global.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      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 getGlobalObject();\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  // https://caniuse.com/#feat=referrer-policy\n  // It doesn't. And it throw 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  const global = getGlobalObject<Window>();\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chrome = (global 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 global && !!global.history.pushState && !!global.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\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 */\nenum States {\n  /** Pending */\n  PENDING = 'PENDING',\n  /** Resolved / OK */\n  RESOLVED = 'RESOLVED',\n  /** Rejected / Error */\n  REJECTED = 'REJECTED',\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<{\n    done: boolean;\n    onfulfilled?: ((value: T) => T | PromiseLike<T>) | null;\n    onrejected?: ((reason: any) => any) | null;\n  }> = [];\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 static resolve<T>(value: T | PromiseLike<T>): PromiseLike<T> {\n    return new SyncPromise(resolve => {\n      resolve(value);\n    });\n  }\n\n  /** JSDoc */\n  public static reject<T = never>(reason?: any): PromiseLike<T> {\n    return new SyncPromise((_, reject) => {\n      reject(reason);\n    });\n  }\n\n  /** JSDoc */\n  public static all<U = any>(collection: Array<U | PromiseLike<U>>): PromiseLike<U[]> {\n    return new SyncPromise<U[]>((resolve, reject) => {\n      if (!Array.isArray(collection)) {\n        reject(new TypeError(`Promise.all requires an array as input.`));\n        return;\n      }\n\n      if (collection.length === 0) {\n        resolve([]);\n        return;\n      }\n\n      let counter = collection.length;\n      const resolvedCollection: U[] = [];\n\n      collection.forEach((item, index) => {\n        SyncPromise.resolve(item)\n          .then(value => {\n            resolvedCollection[index] = value;\n            counter -= 1;\n\n            if (counter !== 0) {\n              return;\n            }\n            resolve(resolvedCollection);\n          })\n          .then(null, reject);\n      });\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._attachHandler({\n        done: false,\n        onfulfilled: result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n            return;\n          }\n          try {\n            resolve(onfulfilled(result));\n            return;\n          } catch (e) {\n            reject(e);\n            return;\n          }\n        },\n        onrejected: reason => {\n          if (!onrejected) {\n            reject(reason);\n            return;\n          }\n          try {\n            resolve(onrejected(reason));\n            return;\n          } catch (e) {\n            reject(e);\n            return;\n          }\n        },\n      });\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  public toString(): string {\n    return '[object SyncPromise]';\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      (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  // TODO: FIXME\n  /** JSDoc */\n  private readonly _attachHandler = (handler: {\n    /** JSDoc */\n    done: boolean;\n    /** JSDoc */\n    onfulfilled?(value: T): any;\n    /** JSDoc */\n    onrejected?(reason: any): any;\n  }) => {\n    this._handlers = this._handlers.concat(handler);\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.done) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        if (handler.onfulfilled) {\n          // eslint-disable-next-line @typescript-eslint/no-floating-promises\n          handler.onfulfilled((this._value as unknown) as any);\n        }\n      }\n\n      if (this._state === States.REJECTED) {\n        if (handler.onrejected) {\n          handler.onrejected(this._value);\n        }\n      }\n\n      handler.done = true;\n    });\n  };\n}\n\nexport { SyncPromise };\n","import { Event, Response, Status, Transport } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n\n/** Noop transport */\nexport class NoopTransport implements Transport {\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(_: Event): PromiseLike<Response> {\n    return SyncPromise.resolve({\n      reason: `NoopTransport: Event has been skipped because no Dsn is configured.`,\n      status: Status.Skipped,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(_?: number): PromiseLike<boolean> {\n    return SyncPromise.resolve(true);\n  }\n}\n","import { BaseClient, Scope } from '@sentry/core';\nimport { Event, EventHint } from '@sentry/types';\nimport { getGlobalObject, logger } from '@sentry/utils';\n\nimport { BrowserBackend, BrowserOptions } from './backend';\nimport { injectReportDialog, ReportDialogOptions } from './helpers';\nimport { Breadcrumbs } from './integrations';\nimport { SDK_NAME, SDK_VERSION } from './version';\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<BrowserBackend, BrowserOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserOptions = {}) {\n    super(BrowserBackend, options);\n  }\n\n  /**\n   * Show a report dialog to the user to send feedback to a specific event.\n   *\n   * @param options Set individual options for the dialog\n   */\n  public showReportDialog(options: ReportDialogOptions = {}): void {\n    // doesn't work without a document (React Native)\n    const document = getGlobalObject<Window>().document;\n    if (!document) {\n      return;\n    }\n\n    if (!this._isEnabled()) {\n      logger.error('Trying to call showReportDialog with Sentry Client disabled');\n      return;\n    }\n\n    injectReportDialog({\n      ...options,\n      dsn: options.dsn || this.getDsn(),\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, scope?: Scope, hint?: EventHint): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    event.sdk = {\n      ...event.sdk,\n      name: SDK_NAME,\n      packages: [\n        ...((event.sdk && event.sdk.packages) || []),\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    return super._prepareEvent(event, scope, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _sendEvent(event: Event): void {\n    const integration = this.getIntegration(Breadcrumbs);\n    if (integration) {\n      integration.addSentryBreadcrumb(event);\n    }\n    super._sendEvent(event);\n  }\n}\n","import { Event, Exception, StackFrame } from '@sentry/types';\nimport { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\n\nimport { computeStackTrace, StackFrame as TraceKitStackFrame, StackTrace as TraceKitStackTrace } from './tracekit';\n\nconst STACKTRACE_LIMIT = 50;\n\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace: TraceKitStackTrace): Exception {\n  const frames = prepareFramesForEvent(stacktrace.stack);\n\n  const exception: Exception = {\n    type: stacktrace.name,\n    value: stacktrace.message,\n  };\n\n  if (frames && 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  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  rejection?: boolean,\n): Event {\n  const event: Event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            rejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception),\n    },\n  };\n\n  if (syntheticException) {\n    const stacktrace = computeStackTrace(syntheticException);\n    const frames = prepareFramesForEvent(stacktrace.stack);\n    event.stacktrace = {\n      frames,\n    };\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace: TraceKitStackTrace): Event {\n  const exception = exceptionFromStacktrace(stacktrace);\n\n  return {\n    exception: {\n      values: [exception],\n    },\n  };\n}\n\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack: TraceKitStackFrame[]): StackFrame[] {\n  if (!stack || !stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  const firstFrameFunction = localStack[0].func || '';\n  const lastFrameFunction = localStack[localStack.length - 1].func || '';\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(\n      (frame: TraceKitStackFrame): StackFrame => ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n      }),\n    )\n    .reverse();\n}\n","export { BaseTransport } from './base';\nexport { FetchTransport } from './fetch';\nexport { XHRTransport } from './xhr';\n","export const SDK_NAME = 'sentry.javascript.browser';\nexport const SDK_VERSION = '5.27.4';\n"],"sourceRoot":""}