{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/global.js","webpack:///../../src/object.ts","webpack:///../../src/worldwide.ts","webpack:///../../src/string.ts","webpack:///./node_modules/process/browser.js","webpack:///../../src/stacktrace.ts","webpack:///../../src/node.ts","webpack:///(webpack)/buildin/harmony-module.js","webpack:///../../src/time.ts","webpack:///../../src/env.ts","webpack:///../../src/normalize.ts","webpack:///../../src/memo.ts","webpack:///./cartridges/app_storefront_naturesmenu/cartridge/client/default/js/sentry.js","webpack:///./cartridges/app_storefront_naturesmenu/cartridge/client/default/js/sentry/main.js","webpack:///../../../src/integrations/functiontostring.ts","webpack:///../../src/logger.ts","webpack:///../../src/misc.ts","webpack:///../../../src/integrations/inboundfilters.ts","webpack:///../../src/syncpromise.ts","webpack:///../../src/session.ts","webpack:///../../src/scope.ts","webpack:///../../src/hub.ts","webpack:///../../src/version.ts","webpack:///../../src/exports.ts","webpack:///../../src/error.ts","webpack:///../../src/promisebuffer.ts","webpack:///../../src/envelope.ts","webpack:///../../src/ratelimit.ts","webpack:///../../../src/transports/base.ts","webpack:///../../src/supports.ts","webpack:///../../src/instrument.ts","webpack:///../../../src/eventbuilder.ts","webpack:///../../../src/helpers.ts","webpack:///../../../../src/integrations/globalhandlers.ts","webpack:///../../../../src/integrations/trycatch.ts","webpack:///../../src/severity.ts","webpack:///../../src/url.ts","webpack:///../../../../src/integrations/breadcrumbs.ts","webpack:///../../../../src/integrations/linkederrors.ts","webpack:///../../../../src/integrations/httpcontext.ts","webpack:///../../../../src/integrations/dedupe.ts","webpack:///../../src/dsn.ts","webpack:///../../src/api.ts","webpack:///../../src/integration.ts","webpack:///../../src/baseclient.ts","webpack:///../../../src/client.ts","webpack:///../../../../src/transports/utils.ts","webpack:///../../src/clientreport.ts","webpack:///../../../../src/transports/fetch.ts","webpack:///../../../../src/transports/xhr.ts","webpack:///../../../src/stack-parsers.ts","webpack:///../../src/sdk.ts","webpack:///../../../src/sdk.ts","webpack:///../../../src/index.ts","webpack:///../../src/browser.ts","webpack:///../../src/is.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","g","this","Function","e","window","_typeof","fill","source","replacementFactory","original","wrapped","markFunctionWrapped","_Oo","addNonEnumerableProperty","obj","writable","configurable","proto","getOriginalFunction","func","__sentry_original__","urlEncode","keys","map","concat","encodeURIComponent","join","convertToPlainObject","isError","_objectSpread","message","stack","getOwnProperties","isEvent","newObj","type","target","serializeEventTarget","currentTarget","CustomEvent","isInstanceOf","detail","isElement","htmlTreeAsString","toString","_oO","extractedProps","extractExceptionKeysForMessage","exception","maxLength","arguments","length","undefined","sort","truncate","includedKeys","serialized","slice","dropUndefinedKeys","inputValue","_dropUndefinedKeys","memoizationMap","isPlainObject","memoVal","returnValue","set","_i","_Object$keys","Array","isArray","forEach","item","push","Map","isGlobalObj","Math","GLOBAL_OBJ","globalThis","self","global","getGlobalSingleton","creator","gbl","__SENTRY__","str","max","substr","snipLine","line","colno","newLine","lineLength","start","end","min","safeJoin","input","delimiter","output","String","isMatchingPattern","pattern","isString","isRegExp","test","indexOf","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","createStackParser","_len","parsers","_key","sortedParsers","a","b","_step","skipFirst","frames","_iterator","_createForOfIteratorHelper","split","done","_step2","cleanedLine","replace","_iterator2","parser","frame","err","f","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","_toConsumableArray","localStack","firstFrameFunction","function","lastFrameFunction","filename","reverse","getFunctionName","fn","isNodeEnv","isBrowserBundle","dynamicRequire","mod","request","require","originalModule","webpackPolyfill","children","dateTimestampSource","nowSeconds","Date","now","platformPerformance","performance","_","getNodePerformance","WINDOW","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","__SENTRY_BROWSER_BUNDLE__","normalize","depth","Infinity","maxProperties","visit","ERROR","normalizeToSize","maxSize","normalized","jsonSize","memo","memoBuilder","_memo","_slicedToArray","memoize","unmemoize","includes","isNaN","stringified","stringifyValue","startsWith","valueWithToJSON","toJSON","jsonValue","numAdded","visitable","visitKey","visitValue","_events","document","isSyntheticEvent","getPrototypeOf","constructor","encodeURI","utf8Length","JSON","stringify","hasWeakSet","WeakSet","inner","has","add","delete","splice","$","ready","init","instanceCode","DSN","attr","codeVersion","dsn","release","environment","0","1","2","originalFunctionToString","FunctionToString","_classCallCheck","__init","id","context","__initStatic","logger","CONSOLE_LEVELS","consoleSandbox","callback","originalConsole","console","wrappedLevels","level","originalWrappedFunc","makeLogger","enabled","enable","disable","__SENTRY_DEBUG__","_GLOBAL_OBJ$console","uuid4","crypto","msCrypto","randomUUID","getRandomByte","getRandomValues","Uint8Array","random","getFirstException","event","values","getEventDescription","eventId","event_id","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mechanism","handled","mergedData","data","checkOrSetAlreadyCaught","__sentry_captured__","arrayify","maybeArray","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","addGlobalEventProcessor","getCurrentHub","eventProcess","hub","getIntegration","client","getClient","clientOptions","getOptions","options","ignoreInternal","_isSentryError","warn","ignoreErrors","_ref","_ref$type","_ref$value","oO","error","_getPossibleEventMessages","some","_isIgnoredError","denyUrls","url","_getEventFilterUrl","_isDeniedUrl","allowUrls","_isAllowedUrl","_shouldDropEvent","internalOptions","_mergeOptions","stacktrace","_getLastValidUrl","States","resolvedSyncPromise","SyncPromise","resolve","rejectedSyncPromise","reason","reject","executor","__init2","__init3","__init4","__init5","__init6","_resolve","_reject","_state","PENDING","_handlers","onfulfilled","onrejected","_this","result","_executeHandlers","then","val","onfinally","_this2","isRejected","_this3","_setResult","RESOLVED","_this4","REJECTED","_this5","state","isThenable","_value","_this6","cachedHandlers","handler","makeSession","startingTime","session","sid","timestamp","started","duration","status","errors","ignoreDuration","toISOString","did","attrs","ip_address","ipAddress","user_agent","userAgent","sessionToJSON","updateSession","user","email","username","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","scope","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","_notifyScopeListeners","requestSession","tags","_defineProperty","extras","extra","fingerprint","span","getSpan","transaction","captureContext","updatedScope","contexts","breadcrumb","maxBreadcrumbs","maxCrumbs","mergedBreadcrumb","attachment","hint","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","newData","processors","index","processor","log","final","Hub","_version","getStackTop","bindClient","_stack","setupIntegrations","clone","getScope","getStack","pop","pushScope","popScope","_lastEventId","syntheticException","_withClient","captureException","originalException","captureMessage","captureEvent","_this$getStackTop","_ref$beforeBreadcrumb","beforeBreadcrumb","_ref$maxBreadcrumbs","finalBreadcrumb","addBreadcrumb","setUser","setTags","setExtras","setTag","setExtra","setContext","_this$getStackTop2","oldHub","makeMain","integration","customSamplingContext","_callExtensionMethod","endSession","_sendSessionUpdate","layer","getSession","closeSession","setSession","_this$getStackTop3","_ref2","navigator","getUser","currentSession","Boolean","sendDefaultPii","_this$getStackTop4","captureSession","_this$getStackTop5","method","carrier","getMainCarrier","sentry","extensions","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","isOlderThan","activeDomain","domain","active","registryHubTopStack","getHubFromActiveDomain","SDK_VERSION","configureScope","withScope","startTransaction","SentryError","_Error","_inherits","_super","logLevel","setPrototypeOf","_assertThisInitialized","_wrapNativeSuper","makePromiseBuffer","limit","buffer","remove","task","taskProducer","drain","counter","capturedSetTimeout","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","_envelope","forEachEnvelopeItem","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","TextEncoder","encode","serializeEnvelope","_envelope2","envHeaders","parts","append","next","_item","itemHeaders","payload","stringifiedPayload","buffers","totalLength","reduce","acc","buf","merged","offset","concatBuffers","createAttachmentEnvelopeItem","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","parseRetryAfterHeader","header","headerDelay","parseInt","headerDate","parse","disabledUntil","limits","category","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","_limit$split","_limit$split2","retryAfter","categories","delay","createTransport","makeRequest","bufferSize","rateLimits","flush","send","filteredEnvelopeItems","envelopeItemDataCategory","recordDroppedEvent","filteredEnvelope","recordEnvelopeLoss","body","response","supportsFetch","Headers","Request","Response","isNativeFetch","lastHref","handlers","instrumented","instrument","originalConsoleMethod","triggerHandlers","instrumentConsole","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","addEventListener","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","instrumentDOM","xhrproto","XMLHttpRequest","originalOpen","_len3","_key3","xhr","xhrInfo","__sentry_xhr__","toUpperCase","match","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","endTimestamp","startTimestamp","onreadystatechange","_len4","readyStateArgs","_key4","originalSend","_len5","_key5","instrumentXHR","fetch","doc","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","supportsNativeFetch","originalFetch","_len2","_key2","handlerData","fetchData","getFetchMethod","getFetchUrl","instrumentFetch","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","_len7","_key7","from","to","location","href","_len6","_key6","instrumentHistory","_oldOnErrorHandler","onerror","msg","column","_oldOnUnhandledRejectionHandler","onunhandledrejection","addInstrumentationHandler","fetchArgs","debounceTimerID","lastCapturedEvent","shouldShortcircuitPreviousDebounce","previous","current","shouldSkipDOMEvent","tagName","isContentEditable","globalListener","exceptionFromError","ex","parseStackFrames","extractMessage","eventFromError","popSize","framesToPop","reactMinifiedRegexp","getPopSize","eventFromMessage","attachStacktrace","eventFromString","eventFromUnknownInput","isUnhandledRejection","isErrorEvent","isDOMError","isDOMException","domException","code","normalizeDepth","__serialized__","eventFromPlainObject","synthetic","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","before","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","addEventProcessor","descriptor","getOwnPropertyDescriptor","GlobalHandlers","_installFunc","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","_getHubAndOptions2","getHubAndOptions","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","_getHubAndOptions4","isPrimitive","ev","ev0","ev0s","ev0sf","lineno","getLocationHref","in_app","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","originalCallback","xmlHttpRequestProps","prop","wrapOptions","originalFunction","globalObject","eventName","handleEvent","wrappedEventHandler","originalEventHandler","validSeverityLevels","severityLevelFromString","parseUrl","query","fragment","host","path","protocol","relative","Breadcrumbs","dom","_consoleBreadcrumb","keyAttrs","serializeAttribute","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","LinkedErrors","_limit","linkedErrors","_walkErrorTree","_handler","HttpContext","referrer","Referer","Dedupe","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","previousFingerprint","DSN_REGEX","dsnToString","withPassword","pass","port","projectId","publicKey","dsnFromComponents","components","makeDsn","exec","_match$slice2","_match$slice2$","_match$slice2$2","projectMatch","dsnFromString","component","isValidProtocol","validateDsn","getBaseApiEndpoint","_getIngestEndpoint","_encodedAuth","sdkInfo","sentry_key","sentry_version","sentry_client","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","_metadata","sdk","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","getSdkMetadataForEnvelopeHeader","metadata","_metadata$sdk","createEventEnvelope","eventType","integrations","packages","enhanceEventWithSdkInfo","envelopeHeaders","dynamicSamplingContext","sent_at","createEventEnvelopeHeaders","installedIntegrations","getIntegrationsToSetup","defaultIntegrations","userIntegrations","isDefaultInstance","finalIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","debugIndex","findIndex","debugInstance","ALREADY_SEEN_ERROR","cachedFetchImpl","BrowserClient","_BaseClient","_createSuper","sendClientReports","visibilityState","_flushOutcomes","eventFromException","breadcrumbIntegration","getIntegrationById","_get","_getPrototypeOf","platform","outcomes","_clearOutcomes","_dsn","discarded_events","sendBeacon","transportOptions","_sendEnvelope","BaseClient","_transport","transport","_integrations","_integrationsInitialized","_numProcessing","_outcomes","_process","_captureEvent","promisedEvent","_isEnabled","sendSession","_isClientDoneProcessing","clientFinished","transportFlushed","integrationIndex","setupOnce","integrationId","attachments","createSessionEnvelope","crashed","errored","exceptions","sessionNonTerminal","Number","ticked","interval","clearInterval","_this$getOptions","_this$getOptions$norm","_this$getOptions$norm2","normalizeMaxBreadth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","update","getAttachments","applyToEvent","evt","_normalizeEvent","maxBreadth","spans","dist","_options$maxValueLeng","maxValueLength","integrationsArray","_processEvent","finalEvent","sentryError","_this$getOptions2","beforeSend","sampleRate","isTransaction","_prepareEvent","__sentry__","rv","nullErr","_ensureBeforeSendRv","processedEvent","_updateSessionFromEvent","transactionInfo","transaction_info","changes","propagations","sendEvent","promise","_this7","_key$split2","quantity","getNativeFetchImplementation","fetchImpl","makeFetchTransport","nativeFetch","requestOptions","referrerPolicy","keepalive","fetchOptions","makeXHRTransport","getResponseHeader","open","setRequestHeader","createFrame","chromeRegex","chromeEvalRegex","chromeStackLineParser","subMatch","_extractSafariExtensi2","extractSafariExtensionDetails","geckoREgex","geckoEvalRegex","geckoStackLineParser","_extractSafariExtensi4","winjsRegex","winjsStackLineParser","opera10Regex","opera10StackLineParser","opera11Regex","opera11StackLineParser","defaultStackLineParsers","defaultStackParser","isSafariExtension","isSafariWebExtension","initAndBind","clientClass","debug","initialScope","Integrations","SENTRY_RELEASE","autoSessionTracking","startSessionTracking","showReportDialog","_hub$getStackTop","getDsn","lastEventId","script","async","src","onLoad","onload","injectionPoint","forceLoad","close","wrap$1","startSessionOnHub","startSession","windowIntegrations","Sentry","INTEGRATIONS","elem","nextStr","currentElem","out","height","sepLength","_htmlElementAsString","parentNode","el","className","classes","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","allowedAttrs","objectToString","wat","isBuiltin","Event","Element","base","_e"],"mappings":"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","file":"default/js/sentry.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 296);\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { WrappedFunction } from '@sentry/types';\n\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacementFactory(original) as WrappedFunction;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: { [key: string]: unknown }, name: string, value: unknown): void {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nexport function getOriginalFunction(func: WrappedFunction): WrappedFunction | undefined {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object: { [key: string]: any }): string {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nexport function convertToPlainObject<V extends unknown>(\n  value: V,\n):\n  | {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    }\n  | {\n      [ownProps: string]: unknown;\n      message: string;\n      name: string;\n      stack?: string;\n    }\n  | V {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj: {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    } = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps: { [key: string]: unknown } = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj as Record<string, unknown>)[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nexport function dropUndefinedKeys<T>(inputValue: T): T {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map<unknown, unknown>();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: { [key: string]: any } = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue as T;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: unknown[] = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item: unknown) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue as unknown as T;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat as any).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n *\n * Note: This file was originally called `global.ts`, but was changed to unblock users which might be doing\n * string replaces with bundlers like Vite for `global` (would break imports that rely on importing from utils/src/global).\n *\n * Why worldwide?\n *\n * Why not?\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { Integration } from '@sentry/types';\n\n/** Internal global with common properties and Sentry extensions  */\nexport interface InternalGlobal {\n  navigator?: { userAgent?: string };\n  console: Console;\n  Sentry?: {\n    Integrations?: Integration[];\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n    extensions?: {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n}\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj: { Math?: Math }): any | undefined {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nexport const GLOBAL_OBJ: InternalGlobal =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function (this: any) {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead. This will be removed in v8\n */\nexport function getGlobalObject<T>(): T & InternalGlobal {\n  return GLOBAL_OBJ as T & InternalGlobal;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton<T>(name: keyof InternalGlobal['__SENTRY__'], creator: () => T, obj?: unknown): T {\n  const gbl = (obj || GLOBAL_OBJ) as InternalGlobal;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n","import { isRegExp, isString } from './is';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input: any[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value: string, pattern: RegExp | string): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nexport function escapeStringForRegex(regexString: string): string {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","import { StackFrame, StackLineParser, StackLineParserFn, StackParser } from '@sentry/types';\n\nconst STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nexport function createStackParser(...parsers: StackLineParser[]): StackParser {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack: string, skipFirst: number = 0): StackFrame[] => {\n    const frames: StackFrame[] = [];\n\n    for (const line of stack.split('\\n').slice(skipFirst)) {\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = line.replace(/\\(error: (.*)\\)/, '$1');\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nexport function stackParserFromStackParserOptions(stackParser: StackParser | StackLineParser[]): StackParser {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: StackFrame[]): StackFrame[] {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  const firstFrameFunction = localStack[0].function || '';\n  const lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn: unknown): string {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\ntype GetModuleFn = (filename: string | undefined) => string | undefined;\n\n// eslint-disable-next-line complexity\nfunction node(getModule?: GetModuleFn): StackLineParserFn {\n  const FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  const FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n  // eslint-disable-next-line complexity\n  return (line: string) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    const lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object: string | undefined;\n    let method: string | undefined;\n    let functionName: string | undefined;\n    let typeName: string | undefined;\n    let methodName: string | undefined;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n        // eslint-disable-next-line no-plusplus\n        methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        const objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    const filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].substr(7) : lineMatch[2];\n    const isNative = lineMatch[5] === 'native';\n    const isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    const in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: getModule?.(filename),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\n  };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nexport function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {\n  return [90, node(getModule)];\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\nimport { isBrowserBundle } from './env';\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv(): boolean {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nexport function dynamicRequire(mod: any, request: string): any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nexport function loadModule<T>(moduleName: string): T | undefined {\n  let mod: T | undefined;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) as T;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","import { WINDOW } from './browser';\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 } = WINDOW;\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance(): Performance | undefined {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') as { performance: Performance };\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance: Performance | undefined = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource: TimestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport const dateTimestampInSeconds: () => number = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport const timestampInSeconds: () => number = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nexport const timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport const usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport let _browserPerformanceTimeOriginMode: string;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport const browserPerformanceTimeOrigin = ((): number | undefined => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\ndeclare const __SENTRY_BROWSER_BUNDLE__: boolean | undefined;\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle(): boolean {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n","import { Primitive } from '@sentry/types';\n\nimport { isNaN, isSyntheticEvent } from './is';\nimport { memoBuilder, MemoFunc } from './memo';\nimport { convertToPlainObject } from './object';\nimport { getFunctionName } from './stacktrace';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we\n// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this\n// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them\n// might be arrays.\ntype ObjOrArray<T> = { [key: string]: T };\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function normalize(input: unknown, depth: number = +Infinity, maxProperties: number = +Infinity): any {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nexport function normalizeToSize<T>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object: { [key: string]: any },\n  // Default Node.js REPL depth\n  depth: number = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize: number = 100 * 1024,\n): T {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key: string,\n  value: unknown,\n  depth: number = +Infinity,\n  maxProperties: number = +Infinity,\n  memo: MemoFunc = memoBuilder(),\n): Primitive | ObjOrArray<unknown> {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\n    return value as Primitive;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value as ObjOrArray<unknown>)['__sentry_skip_normalization__']) {\n    return value as ObjOrArray<unknown>;\n  }\n\n  // We're also done if we've reached the max depth\n  if (depth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value as unknown & { toJSON?: () => unknown };\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, depth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray<unknown>;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value as ObjOrArray<unknown>);\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n// TODO remove this in v7 (this means the method will no longer be exported, under any name)\nexport { visit as walk };\n\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key: unknown,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value: Exclude<unknown, string | number | boolean | null>,\n): string {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value as { _events: unknown })._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(Object.getPrototypeOf(value) as Prototype).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value: string): number {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value: any): number {\n  return utf8Length(JSON.stringify(value));\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport type MemoFunc = [\n  // memoize\n  (obj: any) => boolean,\n  // unmemoize\n  (obj: any) => void,\n];\n\n/**\n * Helper to decycle json objects\n */\nexport function memoBuilder(): MemoFunc {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner: any = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj: any): boolean {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj: any): void {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n","'use strict';\n\n$(document).ready(function () {\n    require('./sentry/main').init();\n});\n","'use strict';\n\nconst { init } = require('@sentry/browser');\n\n/**\n * Determine the instance type of the current Salesforce Commerce Cloud B2C environment.\n *\n * @return {string|*} The instance type as a string\n */\nfunction determineInstanceType() {\n    const instanceCode = $('meta[name=sentry-instance]').attr('content');\n    const instanceMapping = {\n        0: 'development',\n        1: 'staging',\n        2: 'production'\n    };\n\n    if (instanceCode) {\n        return instanceMapping[instanceCode];\n    }\n\n    return 'unknown';\n}\n\n/**\n * Initializes Sentry\n */\nfunction initSentry() {\n    const DSN = $('meta[name=sentry-dsn]').attr('content');\n    const codeVersion = $('meta[name=sentry-version]').attr('content');\n\n    init({\n        dsn: DSN,\n        release: codeVersion,\n        environment: determineInstanceType()\n    });\n}\n\nmodule.exports = {\n    init: initSentry\n};\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString: () => void;\n\n/** Patch toString calls to return proper name for wrapped functions */\nexport class FunctionToString implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'FunctionToString';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = FunctionToString.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    originalFunctionToString = Function.prototype.toString;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Function.prototype.toString = function (this: WrappedFunction, ...args: any[]): string {\n      const context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n}\n","import { WrappedFunction } from '@sentry/types';\n\nimport { getGlobalSingleton, GLOBAL_OBJ } from './worldwide';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nexport const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] as const;\nexport type ConsoleLevel = typeof CONSOLE_LEVELS[number];\n\ntype LoggerMethod = (...args: unknown[]) => void;\ntype LoggerConsoleMethods = Record<typeof CONSOLE_LEVELS[number], LoggerMethod>;\n\n/** JSDoc */\ninterface Logger extends LoggerConsoleMethods {\n  disable(): void;\n  enable(): void;\n}\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox<T>(callback: () => T): T {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const originalConsole = GLOBAL_OBJ.console as Console & Record<string, unknown>;\n  const wrappedLevels: Partial<LoggerConsoleMethods> = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] as WrappedFunction).__sentry_original__;\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] as LoggerConsoleMethods[typeof level];\n      originalConsole[level] = originalWrappedFunc as Console[typeof level];\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level as typeof CONSOLE_LEVELS[number]];\n    });\n  }\n}\n\nfunction makeLogger(): Logger {\n  let enabled = false;\n  const logger: Partial<Logger> = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if (__DEBUG_BUILD__) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args: any[]) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger as Logger;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger: Logger;\nif (__DEBUG_BUILD__) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { logger };\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Event, Exception, Mechanism, StackFrame } from '@sentry/types';\n\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\nimport { GLOBAL_OBJ } from './worldwide';\n\ninterface CryptoInternal {\n  getRandomValues(array: Uint8Array): Uint8Array;\n  randomUUID?(): string;\n}\n\n/** An interface for common properties on global */\ninterface CryptoGlobal {\n  msCrypto?: CryptoInternal;\n  crypto?: CryptoInternal;\n}\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4(): string {\n  const gbl = GLOBAL_OBJ as typeof GLOBAL_OBJ & CryptoGlobal;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  const getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] as unknown as string) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c as unknown as number) ^ ((getRandomByte() & 15) >> ((c as unknown as number) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event: Event): Exception | undefined {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event: Event): string {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event: Event, value?: string, type?: string): void {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event: Event, newMechanism?: Partial<Mechanism>): void {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\ninterface SemVer {\n  major?: number;\n  minor?: number;\n  patch?: number;\n  prerelease?: string;\n  buildmetadata?: string;\n}\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input: string): SemVer {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: number = 5): void {\n  const lineno = frame.lineno || 0;\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception as any).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nexport function arrayify<T = unknown>(maybeArray: T | T[]): T[] {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n","import { Event, EventProcessor, Hub, Integration, StackFrame } 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/** Options for the InboundFilters integration */\nexport interface InboundFiltersOptions {\n  allowUrls: Array<string | RegExp>;\n  denyUrls: Array<string | RegExp>;\n  ignoreErrors: Array<string | RegExp>;\n  ignoreInternal: boolean;\n}\n\n/** Inbound filters configurable by the user */\nexport class InboundFilters implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'InboundFilters';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = InboundFilters.id;\n\n  public constructor(private readonly _options: Partial<InboundFiltersOptions> = {}) {}\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (processor: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const eventProcess: EventProcessor = (event: Event) => {\n      const hub = getCurrentHub();\n      if (hub) {\n        const self = hub.getIntegration(InboundFilters);\n        if (self) {\n          const client = hub.getClient();\n          const clientOptions = client ? client.getOptions() : {};\n          const options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n}\n\n/** JSDoc */\nexport function _mergeOptions(\n  internalOptions: Partial<InboundFiltersOptions> = {},\n  clientOptions: Partial<InboundFiltersOptions> = {},\n): Partial<InboundFiltersOptions> {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nexport function _shouldDropEvent(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    __DEBUG_BUILD__ &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): boolean {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message =>\n    ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n  );\n}\n\nfunction _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event: Event, allowUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event: Event): string[] {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      __DEBUG_BUILD__ && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event: Event): boolean {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames: StackFrame[] = []): string | null {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event: Event): string | null {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    __DEBUG_BUILD__ && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst enum States {\n  /** Pending */\n  PENDING = 0,\n  /** Resolved / OK */\n  RESOLVED = 1,\n  /** Rejected / Error */\n  REJECTED = 2,\n}\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike<void>;\nexport function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise<T> implements PromiseLike<T> {\n  private _state: States = States.PENDING;\n  private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]> = [];\n  private _value: any;\n\n  public constructor(\n    executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,\n  ) {\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n  public then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n  public catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,\n  ): PromiseLike<T | TResult> {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n  public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {\n    return new SyncPromise<TResult>((resolve, reject) => {\n      let val: TResult | any;\n      let isRejected: boolean;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val as unknown as any);\n      });\n    });\n  }\n\n  /** JSDoc */\n  private readonly _resolve = (value?: T | PromiseLike<T> | null) => {\n    this._setResult(States.RESOLVED, value);\n  };\n\n  /** JSDoc */\n  private readonly _reject = (reason?: any) => {\n    this._setResult(States.REJECTED, reason);\n  };\n\n  /** JSDoc */\n  private readonly _setResult = (state: States, value?: T | PromiseLike<T> | any) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value as PromiseLike<T>).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };\n\n  /** JSDoc */\n  private readonly _executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value as unknown as any);\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };\n}\n\nexport { SyncPromise };\n","import { SerializedSession, Session, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session: Session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n","/* eslint-disable max-lines */\nimport {\n  Attachment,\n  Breadcrumb,\n  CaptureContext,\n  Context,\n  Contexts,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Primitive,\n  RequestSession,\n  Scope as ScopeInterface,\n  ScopeContext,\n  Session,\n  Severity,\n  SeverityLevel,\n  Span,\n  Transaction,\n  User,\n} from '@sentry/types';\nimport {\n  arrayify,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  isPlainObject,\n  isThenable,\n  logger,\n  SyncPromise,\n} from '@sentry/utils';\n\nimport { updateSession } from './session';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nexport class Scope implements ScopeInterface {\n  /** Flag if notifying is happening. */\n  protected _notifyingListeners: boolean;\n\n  /** Callback for client to receive scope changes. */\n  protected _scopeListeners: Array<(scope: Scope) => void>;\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  protected _eventProcessors: EventProcessor[];\n\n  /** Array of breadcrumbs. */\n  protected _breadcrumbs: Breadcrumb[];\n\n  /** User */\n  protected _user: User;\n\n  /** Tags */\n  protected _tags: { [key: string]: Primitive };\n\n  /** Extra */\n  protected _extra: Extras;\n\n  /** Contexts */\n  protected _contexts: Contexts;\n\n  /** Attachments */\n  protected _attachments: Attachment[];\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  protected _sdkProcessingMetadata: { [key: string]: unknown };\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n  protected _level?: Severity | SeverityLevel;\n\n  /** Transaction Name */\n  protected _transactionName?: string;\n\n  /** Span */\n  protected _span?: Span;\n\n  /** Session */\n  protected _session?: Session;\n\n  /** Request Mode Session Status */\n  protected _requestSession?: RequestSession;\n\n  public constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n  public static clone(scope?: Scope): Scope {\n    const newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n  public addScopeListener(callback: (scope: Scope) => void): void {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addEventProcessor(callback: EventProcessor): this {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): this {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getUser(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getRequestSession(): RequestSession | undefined {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setRequestSession(requestSession?: RequestSession): this {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): this {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): this {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): this {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setFingerprint(fingerprint: string[]): this {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setLevel(\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel,\n  ): this {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTransactionName(name?: string): this {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSpan(span?: Span): this {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSpan(): Span | undefined {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransaction(): Transaction | undefined {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSession(session?: Session): this {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSession(): Session | undefined {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public update(captureContext?: CaptureContext): this {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      const updatedScope = (captureContext as <T>(scope: T) => T)(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n      // eslint-disable-next-line no-param-reassign\n      captureContext = captureContext as ScopeContext;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clear(): this {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearBreadcrumbs(): this {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addAttachment(attachment: Attachment): this {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getAttachments(): Attachment[] {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearAttachments(): this {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   */\n  public applyToEvent(event: Event, hint: EventHint = {}): PromiseLike<Event | null> {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n  public setSDKProcessingMetadata(newData: { [key: string]: unknown }): this {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n  protected _notifyEventProcessors(\n    processors: EventProcessor[],\n    event: Event | null,\n    hint: EventHint,\n    index: number = 0,\n  ): PromiseLike<Event | null> {\n    return new SyncPromise<Event | null>((resolve, reject) => {\n      const processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        const result = processor({ ...event }, hint) as Event | null;\n\n        __DEBUG_BUILD__ &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n  protected _notifyScopeListeners(): void {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n  private _applyFingerprint(event: Event): void {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors(): EventProcessor[] {\n  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n  getGlobalEventProcessors().push(callback);\n}\n","/* eslint-disable max-lines */\nimport {\n  Breadcrumb,\n  BreadcrumbHint,\n  Client,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Hub as HubInterface,\n  Integration,\n  IntegrationClass,\n  Primitive,\n  Session,\n  SessionContext,\n  Severity,\n  SeverityLevel,\n  Transaction,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport {\n  consoleSandbox,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  GLOBAL_OBJ,\n  isNodeEnv,\n  logger,\n  uuid4,\n} from '@sentry/utils';\n\nimport { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\nexport interface Layer {\n  client?: Client;\n  scope?: Scope;\n}\n\n/**\n * An object that contains a hub and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n  __SENTRY__?: {\n    hub?: Hub;\n    /**\n     * Extra Hub properties injected by various SDKs\n     */\n    integrations?: Integration[];\n    extensions?: {\n      /** Hack to prevent bundlers from breaking our usage of the domain package in the cross-platform Hub package */\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      domain?: { [key: string]: any };\n    } & {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n}\n\n/**\n * @inheritDoc\n */\nexport class Hub implements HubInterface {\n  /** Is a {@link Layer}[] containing the client and scope */\n  private readonly _stack: Layer[] = [{}];\n\n  /** Contains the last event id of a captured event.  */\n  private _lastEventId?: string;\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n  public constructor(client?: Client, scope: Scope = new Scope(), private readonly _version: number = API_VERSION) {\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isOlderThan(version: number): boolean {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public bindClient(client?: Client): void {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public pushScope(): Scope {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public popScope(): boolean {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public withScope(callback: (scope: Scope) => void): void {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this.getStackTop().client as C;\n  }\n\n  /** Returns the scope of the top stack. */\n  public getScope(): Scope | undefined {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n  public getStack(): Layer[] {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n  ): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== 'transaction') {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): void {\n    const scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): void {\n    const scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): void {\n    const scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public setContext(name: string, context: { [key: string]: any } | null): void {\n    const scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public configureScope(callback: (scope: Scope) => void): void {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public run(callback: (hub: Hub) => void): void {\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startTransaction(context: TransactionContext, customSamplingContext?: CustomSamplingContext): Transaction {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public traceHeaders(): { [key: string]: string } {\n    return this._callExtensionMethod<{ [key: string]: string }>('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureSession(endSession: boolean = false): void {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public endSession(): void {\n    const layer = this.getStackTop();\n    const scope = layer && layer.scope;\n    const session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startSession(context?: SessionContext): Session {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      const currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n  public shouldSendDefaultPii(): boolean {\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n  private _sendSessionUpdate(): void {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n  private _withClient(callback: (client: Client, scope: Scope | undefined) => void): void {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    __DEBUG_BUILD__ && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return GLOBAL_OBJ;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub: Hub): Hub {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub(): Hub {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry: Carrier): Hub {\n  try {\n    const sentry = getMainCarrier().__SENTRY__;\n    const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier: Carrier): boolean {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier: Carrier): Hub {\n  return getGlobalSingleton<Hub>('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n","export const SDK_VERSION = '7.16.0';\n","import {\n  Breadcrumb,\n  CaptureContext,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Primitive,\n  Severity,\n  SeverityLevel,\n  TransactionContext,\n  User,\n} from '@sentry/types';\n\nimport { getCurrentHub, Hub } from './hub';\nimport { Scope } from './scope';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception: any, captureContext?: CaptureContext): ReturnType<Hub['captureException']> {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(\n  message: string,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext?: CaptureContext | Severity | SeverityLevel,\n): ReturnType<Hub['captureMessage']> {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event: Event, hint?: EventHint): ReturnType<Hub['captureEvent']> {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']> {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb: Breadcrumb): ReturnType<Hub['addBreadcrumb']> {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name: string, context: { [key: string]: any } | null): ReturnType<Hub['setContext']> {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']> {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['setTags']> {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']> {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user: User | null): ReturnType<Hub['setUser']> {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback: (scope: Scope) => void): ReturnType<Hub['withScope']> {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(\n  context: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n): ReturnType<Hub['startTransaction']> {\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n","import type { ConsoleLevel } from './logger';\n\n/** An error emitted by Sentry SDKs and related utilities. */\nexport class SentryError extends Error {\n  /** Display name of this error instance. */\n  public name: string;\n\n  public logLevel: ConsoleLevel;\n\n  public constructor(public message: string, logLevel: ConsoleLevel = 'warn') {\n    super(message);\n\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n","import { SentryError } from './error';\nimport { rejectedSyncPromise, resolvedSyncPromise, SyncPromise } from './syncpromise';\n\nexport interface PromiseBuffer<T> {\n  // exposes the internal array so tests can assert on the state of it.\n  // XXX: this really should not be public api.\n  $: Array<PromiseLike<T>>;\n  add(taskProducer: () => PromiseLike<T>): PromiseLike<T>;\n  drain(timeout?: number): PromiseLike<boolean>;\n}\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nexport function makePromiseBuffer<T>(limit?: number): PromiseBuffer<T> {\n  const buffer: Array<PromiseLike<T>> = [];\n\n  function isReady(): boolean {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task: PromiseLike<T>): PromiseLike<T> {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer: () => PromiseLike<T>): PromiseLike<T> {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise<boolean>((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          // eslint-disable-next-line no-plusplus\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n","import {\n  DsnComponents,\n  Event,\n  EventEnvelope,\n  EventEnvelopeHeaders,\n  EventItem,\n  SdkInfo,\n  SdkMetadata,\n  Session,\n  SessionAggregates,\n  SessionEnvelope,\n  SessionItem,\n} from '@sentry/types';\nimport { createEnvelope, dropUndefinedKeys, dsnToString } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata?: SdkMetadata): SdkInfo | undefined {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n  const { name, version } = metadata.sdk;\n  return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nexport function createSessionEnvelope(\n  session: Session | SessionAggregates,\n  dsn: DsnComponents,\n  metadata?: SdkMetadata,\n  tunnel?: string,\n): SessionEnvelope {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n  };\n\n  const envelopeItem: SessionItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n  return createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nexport function createEventEnvelope(\n  event: Event,\n  dsn: DsnComponents,\n  metadata?: SdkMetadata,\n  tunnel?: string,\n): EventEnvelope {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const eventType = event.type || 'event';\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  const eventItem: EventItem = [{ type: eventType }, event];\n  return createEnvelope<EventEnvelope>(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event: Event,\n  sdkInfo: SdkInfo | undefined,\n  tunnel: string | undefined,\n  dsn: DsnComponents,\n): EventEnvelopeHeaders {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n\n  return {\n    event_id: event.event_id as string,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n      }),\n  };\n}\n","import { TransportMakeRequestResponse } from '@sentry/types';\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nexport type RateLimits = Record<string, number>;\n\nexport const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nexport function parseRetryAfterHeader(header: string, now: number = Date.now()): number {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\nexport function disabledUntil(limits: RateLimits, category: string): number {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nexport function isRateLimited(limits: RateLimits, category: string, now: number = Date.now()): boolean {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\nexport function updateRateLimits(\n  limits: RateLimits,\n  { statusCode, headers }: TransportMakeRequestResponse,\n  now: number = Date.now(),\n): RateLimits {\n  const updatedRateLimits: RateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n","import {\n  Envelope,\n  EnvelopeItem,\n  EventDropReason,\n  InternalBaseTransportOptions,\n  Transport,\n  TransportRequestExecutor,\n} from '@sentry/types';\nimport {\n  createEnvelope,\n  envelopeItemTypeToDataCategory,\n  forEachEnvelopeItem,\n  isRateLimited,\n  logger,\n  makePromiseBuffer,\n  PromiseBuffer,\n  RateLimits,\n  resolvedSyncPromise,\n  SentryError,\n  serializeEnvelope,\n  updateRateLimits,\n} from '@sentry/utils';\n\nexport const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nexport function createTransport(\n  options: InternalBaseTransportOptions,\n  makeRequest: TransportRequestExecutor,\n  buffer: PromiseBuffer<void> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n): Transport {\n  let rateLimits: RateLimits = {};\n\n  const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);\n\n  function send(envelope: Envelope): PromiseLike<void> {\n    const filteredEnvelopeItems: EnvelopeItem[] = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as any);\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason: EventDropReason): void => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    const requestTask = (): PromiseLike<void> =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            __DEBUG_BUILD__ && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          __DEBUG_BUILD__ && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          __DEBUG_BUILD__ && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n","import { WINDOW } from './browser';\nimport { logger } from './logger';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent(): boolean {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError(): boolean {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException(): boolean {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch(): boolean {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFetch(func: Function): boolean {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch(): boolean {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement as unknown) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      __DEBUG_BUILD__ &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver(): boolean {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy(): boolean {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' as ReferrerPolicy,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory(): boolean {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chrome = (WINDOW as any).chrome;\n  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport { WrappedFunction } from '@sentry/types';\n\nimport { WINDOW } from './browser';\nimport { isInstanceOf, isString } from './is';\nimport { CONSOLE_LEVELS, logger } from './logger';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\n\nexport type InstrumentHandlerType =\n  | 'console'\n  | 'dom'\n  | 'fetch'\n  | 'history'\n  | 'sentry'\n  | 'xhr'\n  | 'error'\n  | 'unhandledrejection';\nexport type InstrumentHandlerCallback = (data: any) => void;\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nconst handlers: { [key in InstrumentHandlerType]?: InstrumentHandlerCallback[] } = {};\nconst instrumented: { [key in InstrumentHandlerType]?: boolean } = {};\n\n/** Instruments given API */\nfunction instrument(type: InstrumentHandlerType): void {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      __DEBUG_BUILD__ && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(type: InstrumentHandlerType, callback: InstrumentHandlerCallback): void {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] as InstrumentHandlerCallback[]).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type: InstrumentHandlerType, data: any): void {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (const handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      __DEBUG_BUILD__ &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole(): void {\n  if (!('console' in WINDOW)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level: string): void {\n    if (!(level in WINDOW.console)) {\n      return;\n    }\n\n    fill(WINDOW.console, level, function (originalConsoleMethod: () => any): Function {\n      return function (...args: any[]): void {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(WINDOW.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch(): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(WINDOW, 'fetch', function (originalFetch: () => void): () => void {\n    return function (...args: any[]): void {\n      const handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(WINDOW, args).then(\n        (response: Response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error: Error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\ntype XHRSendInput = null | Blob | BufferSource | FormData | URLSearchParams | string;\n\n/** JSDoc */\ninterface SentryWrappedXMLHttpRequest extends XMLHttpRequest {\n  [key: string]: any;\n  __sentry_xhr__?: {\n    method?: string;\n    url?: string;\n    status_code?: number;\n    body?: XHRSendInput;\n  };\n}\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs: any[] = []): string {\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs: any[] = []): string {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\nfunction instrumentXHR(): void {\n  if (!('XMLHttpRequest' in WINDOW)) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen: () => void): () => void {\n    return function (this: SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const xhr = this;\n      const url = args[1];\n      const xhrInfo: SentryWrappedXMLHttpRequest['__sentry_xhr__'] = (xhr.__sentry_xhr__ = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = function (): void {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original: WrappedFunction): Function {\n          return function (...readyStateArgs: any[]): void {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend: () => void): () => void {\n    return function (this: SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref: string;\n\n/** JSDoc */\nfunction instrumentHistory(): void {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function (this: WindowEventHandlers, ...args: any[]): any {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction: () => void): () => void {\n    return function (this: History, ...args: any[]): void {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nconst debounceDuration = 1000;\nlet debounceTimerID: number | undefined;\nlet lastCapturedEvent: Event | undefined;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous: Event | undefined, current: Event): boolean {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event: Event): boolean {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    const target = event.target as HTMLElement;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler: Function, globalListener: boolean = false): (event: Event) => void {\n  return (event: Event): void => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\ntype AddEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | AddEventListenerOptions,\n) => void;\ntype RemoveEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | EventListenerOptions,\n) => void;\n\ntype InstrumentedElement = Element & {\n  __sentry_instrumentation_handlers__?: {\n    [key in 'click' | 'keypress']?: {\n      handler?: Function;\n      /** The number of custom listeners attached to this element */\n      refCount: number;\n    };\n  };\n};\n\n/** JSDoc */\nfunction instrumentDOM(): void {\n  if (!('document' in WINDOW)) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target: string) => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = (WINDOW as any)[target] && (WINDOW as any)[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener: AddEventListener): AddEventListener {\n      return function (\n        this: Element,\n        type: string,\n        listener: EventListenerOrEventListenerObject,\n        options?: boolean | AddEventListenerOptions,\n      ): AddEventListener {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const el = this as InstrumentedElement;\n            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener: RemoveEventListener): RemoveEventListener {\n        return function (\n          this: Element,\n          type: string,\n          listener: EventListenerOrEventListenerObject,\n          options?: boolean | EventListenerOptions,\n        ): () => void {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const el = this as InstrumentedElement;\n              const handlers = el.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount -= 1;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler: OnErrorEventHandler = null;\n/** JSDoc */\nfunction instrumentError(): void {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg: any, url: any, line: any, column: any, error: any): boolean {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler: ((e: any) => void) | null = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection(): void {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e: any): boolean {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n","import { getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, Severity, SeverityLevel, StackFrame, StackParser } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nexport function eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const hub = getCurrentHub();\n  const client = hub.getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  const event: Event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception, normalizeDepth),\n    },\n  };\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception as { values: Exception[] }).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nexport function parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex: Error & { framesToPop?: number }): number {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  stackParser: StackParser,\n  message: string,\n  // eslint-disable-next-line deprecation/deprecation\n  level: Severity | SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  stackParser: StackParser,\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(stackParser, errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception as DOMError) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromString(\n  stackParser: StackParser,\n  input: string,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n","import { captureException, withScope } from '@sentry/core';\nimport { DsnLike, Event as SentryEvent, Mechanism, Scope, WrappedFunction } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  getOriginalFunction,\n  markFunctionWrapped,\n} 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. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(\n  fn: WrappedFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n  before?: WrappedFunction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  /* eslint-disable prefer-rest-params */\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped: WrappedFunction = function (this: unknown): void {\n    const args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n      const wrappedArguments = args.map((arg: any) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope: Scope) => {\n        scope.addEventProcessor((event: SentryEvent) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} // eslint-disable-line no-empty\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') as PropertyDescriptor;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n    // eslint-disable-next-line no-empty\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\nexport interface ReportDialogOptions {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n  eventId?: string;\n  dsn?: DsnLike;\n  user?: {\n    email?: string;\n    name?: string;\n  };\n  lang?: string;\n  title?: string;\n  subtitle?: string;\n  subtitle2?: string;\n  labelName?: string;\n  labelEmail?: string;\n  labelComments?: string;\n  labelClose?: string;\n  labelSubmit?: string;\n  errorGeneric?: string;\n  errorFormEntry?: string;\n  successMessage?: string;\n  /** Callback after reportDialog showed up */\n  onLoad?(): void;\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Hub, Integration, Primitive, StackParser } from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addInstrumentationHandler,\n  getLocationHref,\n  isErrorEvent,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\n/** JSDoc */\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\n/** Global handlers */\nexport class GlobalHandlers implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'GlobalHandlers';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = GlobalHandlers.id;\n\n  /** JSDoc */\n  private readonly _options: GlobalHandlersIntegrations;\n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n  private _installFunc: Record<GlobalHandlersIntegrationsOptionKeys, (() => void) | undefined> = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };\n\n  /** JSDoc */\n  public constructor(options?: GlobalHandlersIntegrations) {\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    Error.stackTraceLimit = 50;\n    const options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n    // eslint-disable-next-line guard-for-in\n    for (const key in options) {\n      const installFunc = this._installFunc[key as GlobalHandlersIntegrationsOptionKeys];\n      if (installFunc && options[key as GlobalHandlersIntegrationsOptionKeys]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key as GlobalHandlersIntegrationsOptionKeys] = undefined;\n      }\n    }\n  }\n}\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler(): void {\n  addInstrumentationHandler(\n    'error',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (data: { msg: any; url: any; line: any; column: any; error: any }) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      const event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler(): void {\n  addInstrumentationHandler(\n    'unhandledrejection',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (e: any) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      const event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason: Primitive): Event {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg: any, url: any, line: any, column: any): Event {\n  const ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  const groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event: Event, url: any, line: any, column: any): Event {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  __DEBUG_BUILD__ && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub: Hub, error: EventHint['originalException'], event: Event, type: string): void {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions(): [Hub, StackParser, boolean | undefined] {\n  const hub = getCurrentHub();\n  const client = hub.getClient<BrowserClient>();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { fill, getFunctionName, getOriginalFunction, WINDOW } 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    if (this._options.setTimeout) {\n      fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(WINDOW, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    const eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n}\n\n/** JSDoc */\nfunction _wrapTimeFunction(original: () => void): () => number {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, ...args: any[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original: any): (callback: () => void) => any {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, callback: () => void): () => void {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend: () => void): () => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: XMLHttpRequest, ...args: any[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        fill(xhr, prop, function (original: WrappedFunction): () => any {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target: string): void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObject = WINDOW as { [key: string]: any };\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const proto = globalObject[target] && globalObject[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: () => void): (\n    eventName: string,\n    fn: EventListenerObject,\n    options?: boolean | AddEventListenerOptions,\n  ) => void {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this: any,\n      eventName: string,\n      fn: EventListenerObject,\n      options?: boolean | AddEventListenerOptions,\n    ): (eventName: string, fn: EventListenerObject, capture?: boolean, secure?: boolean) => void {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        wrap(fn as any as WrappedFunction, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener: () => void,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): (this: any, eventName: string, fn: EventListenerObject, options?: boolean | EventListenerOptions) => () => void {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this: any,\n        eventName: string,\n        fn: EventListenerObject,\n        options?: boolean | EventListenerOptions,\n      ): () => void {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        const wrappedEventHandler = fn as unknown as WrappedFunction;\n        try {\n          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n","/* eslint-disable deprecation/deprecation */\nimport { Severity, SeverityLevel } from '@sentry/types';\n\n// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nexport const validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nexport function severityFromString(level: Severity | SeverityLevel | string): Severity {\n  return severityLevelFromString(level) as Severity;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nexport function severityLevelFromString(level: SeverityLevel | string): SeverityLevel {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') as SeverityLevel;\n}\n","/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url: string): {\n  host?: string;\n  path?: string;\n  protocol?: string;\n  relative?: string;\n} {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath: string): string {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nexport function getNumberOfUrlSegments(url: string): number {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Integration } from '@sentry/types';\nimport {\n  addInstrumentationHandler,\n  htmlTreeAsString,\n  parseUrl,\n  safeJoin,\n  severityLevelFromString,\n  WINDOW,\n} from '@sentry/utils';\n\n/** JSDoc */\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom: boolean | { serializeAttribute: string | string[] };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\nexport const BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nexport class Breadcrumbs implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = BREADCRUMB_INTEGRATION_ID;\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Breadcrumbs.id;\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n  public readonly options: Readonly<BreadcrumbsOptions>;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options?: Partial<BreadcrumbsOptions>) {\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n  public setupOnce(): void {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n}\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom: BreadcrumbsOptions['dom']): (handlerData: { [key: string]: any }) => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function _innerDomBreadcrumb(handlerData: { [key: string]: any }): void {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target as Node, keyAttrs)\n        : htmlTreeAsString(handlerData.event as unknown as Node, keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData: { [key: string]: any }): void {\n  const breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData: { [key: string]: any }): void {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData: { [key: string]: any }): void {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData: { [key: string]: any }): void {\n  let from = handlerData.from;\n  let to = handlerData.to;\n  const parsedLoc = parseUrl(WINDOW.location.href);\n  let parsedFrom = parseUrl(from);\n  const parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { exceptionFromError } from '../eventbuilder';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\ninterface LinkedErrorsOptions {\n  key: string;\n  limit: number;\n}\n\n/** Adds SDK info to an event. */\nexport class LinkedErrors implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'LinkedErrors';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = LinkedErrors.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _key: LinkedErrorsOptions['key'];\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: LinkedErrorsOptions['limit'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: Partial<LinkedErrorsOptions> = {}) {\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    const client = getCurrentHub().getClient<BrowserClient>();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n}\n\n/**\n * @inheritDoc\n */\nexport function _handler(\n  parser: StackParser,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): Event | null {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(parser, limit, hint.originalException as ExtendedError, key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nexport function _walkErrorTree(\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  stack: Exception[] = [],\n): Exception[] {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, Integration } from '@sentry/types';\nimport { WINDOW } from '@sentry/utils';\n\n/** HttpContext integration collects information about HTTP request headers */\nexport class HttpContext implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'HttpContext';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = HttpContext.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    addGlobalEventProcessor((event: Event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n        const { referrer } = WINDOW.document || {};\n        const { userAgent } = WINDOW.navigator || {};\n\n        const headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        const request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n}\n","import { Event, EventProcessor, Exception, Hub, Integration, StackFrame } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nexport class Dedupe implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Dedupe';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Dedupe.id;\n\n  /**\n   * @inheritDoc\n   */\n  private _previousEvent?: Event;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const eventProcessor: EventProcessor = currentEvent => {\n      const self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            __DEBUG_BUILD__ && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames as StackFrame[];\n  previousFrames = previousFrames as StackFrame[];\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    const frameA = previousFrames[i];\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint as string[];\n  previousFingerprint = previousFingerprint as string[];\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event: Event): Exception | undefined {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event: Event): StackFrame[] | undefined {\n  const exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n","import { DsnComponents, DsnLike, DsnProtocol } from '@sentry/types';\n\nimport { SentryError } from './error';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol?: string): protocol is DsnProtocol {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nexport function dsnToString(dsn: DsnComponents, withPassword: boolean = false): string {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\nexport function dsnFromString(str: string): DsnComponents {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() as string;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, publicKey });\n}\n\nfunction dsnFromComponents(components: DsnComponents): DsnComponents {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn: DsnComponents): boolean | void {\n  if (!__DEBUG_BUILD__) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents: ReadonlyArray<keyof DsnComponents> = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nexport function makeDsn(from: DsnLike): DsnComponents {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n","import { ClientOptions, DsnComponents, DsnLike, SdkInfo } from '@sentry/types';\nimport { dsnToString, makeDsn, urlEncode } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn: DsnComponents): string {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn: DsnComponents): string {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nexport function getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn: DsnComponents,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions: string | ClientOptions = {} as ClientOptions,\n): string {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  const sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nexport function getReportDialogEndpoint(\n  dsnLike: DsnLike,\n  dialogOptions: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n    user?: { name?: string; email?: string };\n  },\n): string {\n  const dsn = makeDsn(dsnLike);\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n","import { Integration, Options } from '@sentry/types';\nimport { arrayify, logger } from '@sentry/utils';\n\nimport { getCurrentHub } from './hub';\nimport { addGlobalEventProcessor } from './scope';\n\ndeclare module '@sentry/types' {\n  interface Integration {\n    isDefaultInstance?: boolean;\n  }\n}\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport type IntegrationIndex = {\n  [key: string]: Integration;\n};\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations: Integration[]): Integration[] {\n  const integrationsByName: { [key: string]: Integration } = {};\n\n  integrations.forEach(currentInstance => {\n    const { name } = currentInstance;\n\n    const existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nexport function getIntegrationsToSetup(options: Options): Integration[] {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach(integration => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations: Integration[];\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  const finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend`. It therefore\n  // has to run after all other integrations, so that the changes of all event processors will be reflected in the\n  // printed values. For lack of a more elegant way to guarantee that, we therefore locate it and, assuming it exists,\n  // pop it out of its current spot and shove it onto the end of the array.\n  const debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n  if (debugIndex !== -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(integrations: Integration[]): IntegrationIndex {\n  const integrationIndex: IntegrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      __DEBUG_BUILD__ && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n","/* eslint-disable max-lines */\nimport {\n  Client,\n  ClientOptions,\n  DataCategory,\n  DsnComponents,\n  Envelope,\n  Event,\n  EventDropReason,\n  EventHint,\n  Integration,\n  IntegrationClass,\n  Outcome,\n  Session,\n  SessionAggregates,\n  Severity,\n  SeverityLevel,\n  Transport,\n} from '@sentry/types';\nimport {\n  addItemToEnvelope,\n  checkOrSetAlreadyCaught,\n  createAttachmentEnvelopeItem,\n  dateTimestampInSeconds,\n  isPlainObject,\n  isPrimitive,\n  isThenable,\n  logger,\n  makeDsn,\n  normalize,\n  rejectedSyncPromise,\n  resolvedSyncPromise,\n  SentryError,\n  SyncPromise,\n  truncate,\n  uuid4,\n} from '@sentry/utils';\n\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope';\nimport { IntegrationIndex, setupIntegrations } from './integration';\nimport { Scope } from './scope';\nimport { updateSession } from './session';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nexport abstract class BaseClient<O extends ClientOptions> implements Client<O> {\n  /** Options passed to the SDK. */\n  protected readonly _options: O;\n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  protected readonly _dsn?: DsnComponents;\n\n  protected readonly _transport?: Transport;\n\n  /** Array of set up integrations. */\n  protected _integrations: IntegrationIndex = {};\n\n  /** Indicates whether this client's integrations have been set up. */\n  protected _integrationsInitialized: boolean = false;\n\n  /** Number of calls being processed */\n  protected _numProcessing: number = 0;\n\n  /** Holds flushable  */\n  private _outcomes: { [key: string]: number } = {};\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n  protected constructor(options: O) {\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      __DEBUG_BUILD__ && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n    scope?: Scope,\n  ): string | undefined {\n    let eventId: string | undefined = hint && hint.event_id;\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined = 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 (!this._isEnabled()) {\n      __DEBUG_BUILD__ && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      __DEBUG_BUILD__ && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getDsn(): DsnComponents | undefined {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getOptions(): O {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransport(): Transport | undefined {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public flush(timeout?: number): PromiseLike<boolean> {\n    const transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n  public setupIntegrations(): void {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n  public getIntegrationById(integrationId: string): Integration | undefined {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    try {\n      return (this._integrations[integration.id] as T) || null;\n    } catch (_oO) {\n      __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event, hint: EventHint = {}): void {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (const attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(\n            attachment,\n            this._options.transportOptions && this._options.transportOptions.textEncoder,\n          ),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session | SessionAggregates): void {\n    if (this._dsn) {\n      const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public recordDroppedEvent(reason: EventDropReason, category: DataCategory): void {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      __DEBUG_BUILD__ && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n  protected _updateSessionFromEvent(session: Session, event: Event): void {\n    let crashed = false;\n    let errored = false;\n    const exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n  protected _isClientDoneProcessing(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise(resolve => {\n      let ticked: number = 0;\n      const tick: number = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n  protected _isEnabled(): boolean {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = this.getOptions();\n    const prepared: Event = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\n\n    // If we have scope given to us, use it as the base for further modifications.\n    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise<Event | null>(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    if (finalScope) {\n      // Collect attachments from the hint and scope\n      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n   * Normalized keys:\n   * - `breadcrumbs.data`\n   * - `user`\n   * - `contexts`\n   * - `extra`\n   * @param event Event\n   * @returns Normalized event\n   */\n  protected _normalizeEvent(event: Event | null, depth: number, maxBreadth: number): Event | null {\n    if (!event) {\n      return null;\n    }\n\n    const normalized: Event = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth, maxBreadth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth, maxBreadth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth),\n      }),\n    };\n\n    // event.contexts.trace stores information about a Transaction. Similarly,\n    // event.spans[] stores information about child Spans. Given that a\n    // Transaction is conceptually a Span, normalization should apply to both\n    // Transactions and Spans consistently.\n    // For now the decision is to skip normalization of Transactions and Spans,\n    // so this block overwrites the normalized event to add back the original\n    // Transaction information prior to normalization.\n    if (event.contexts && event.contexts.trace && normalized.contexts) {\n      normalized.contexts.trace = event.contexts.trace;\n\n      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n      if (event.contexts.trace.data) {\n        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n      }\n    }\n\n    // event.spans[].data may contain circular/dangerous data so we need to normalize it\n    if (event.spans) {\n      normalized.spans = event.spans.map(span => {\n        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\n  }\n\n  /**\n   *  Enhances event using the client configuration.\n   *  It takes care of all \"static\" values like environment, release and `dist`,\n   *  as well as truncating overly long values.\n   * @param event event instance to be enhanced\n   */\n  protected _applyClientOptions(event: Event): void {\n    const options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    const exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    const request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n  }\n\n  /**\n   * This function adds all used integrations to the SDK info in the event.\n   * @param event The event that will be filled with all integrations.\n   */\n  protected _applyIntegrationsMetadata(event: Event): void {\n    const integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n  protected _captureEvent(event: Event, hint: EventHint = {}, scope?: Scope): PromiseLike<string | undefined> {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if (__DEBUG_BUILD__) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          const sentryError = reason as SentryError;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n  protected _processEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event> {\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));\n    }\n\n    const isTransaction = event.type === 'transaction';\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned null, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        const beforeSendResult = beforeSend(prepared, hint);\n        return _ensureBeforeSendRv(beforeSendResult);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError('`beforeSend` returned `null`, will not send event.', 'log');\n        }\n\n        const session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n            changes: [\n              ...transactionInfo.changes,\n              {\n                source,\n                // use the same timestamp as the processed event.\n                timestamp: processedEvent.timestamp as number,\n                propagations: transactionInfo.propagations,\n              },\n            ],\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason as Error,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n  protected _process<T>(promise: PromiseLike<T>): void {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected _sendEnvelope(envelope: Envelope): void {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        __DEBUG_BUILD__ && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      __DEBUG_BUILD__ && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n  protected _clearOutcomes(): Outcome[] {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') as [EventDropReason, DataCategory];\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public abstract eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event>;\n\n  /**\n   * @inheritDoc\n   */\n  public abstract eventFromMessage(\n    _message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    _level?: Severity | SeverityLevel,\n    _hint?: EventHint,\n  ): PromiseLike<Event>;\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv: PromiseLike<Event | null> | Event | null): PromiseLike<Event | null> | Event | null {\n  const nullErr = '`beforeSend` method has to return `null` or a valid event.';\n  if (isThenable(rv)) {\n    return rv.then(\n      event => {\n        if (!(isPlainObject(event) || event === null)) {\n          throw new SentryError(nullErr);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`beforeSend rejected with ${e}`);\n      },\n    );\n  } else if (!(isPlainObject(rv) || rv === null)) {\n    throw new SentryError(nullErr);\n  }\n  return rv;\n}\n","import { BaseClient, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth, Scope, SDK_VERSION } from '@sentry/core';\nimport { ClientOptions, Event, EventHint, Options, Severity, SeverityLevel } from '@sentry/types';\nimport {\n  createClientReportEnvelope,\n  dsnToString,\n  getEventDescription,\n  logger,\n  serializeEnvelope,\n  WINDOW,\n} from '@sentry/utils';\n\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { Breadcrumbs } from './integrations';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs';\nimport { BrowserTransportOptions } from './transports/types';\n\nexport interface BaseBrowserOptions {\n  /**\n   * A pattern for error URLs which should exclusively be sent to Sentry.\n   * This is the opposite of {@link Options.denyUrls}.\n   * By default, all errors will be sent.\n   */\n  allowUrls?: Array<string | RegExp>;\n\n  /**\n   * A pattern for error URLs which should not be sent to Sentry.\n   * To allow certain errors instead, use {@link Options.allowUrls}.\n   * By default, all errors will be sent.\n   */\n  denyUrls?: Array<string | RegExp>;\n}\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/types Options for more information.\n */\nexport interface BrowserOptions extends Options<BrowserTransportOptions>, BaseBrowserOptions {}\n\n/**\n * Configuration options for the Sentry Browser SDK Client class\n * @see BrowserClient for more information.\n */\nexport interface BrowserClientOptions extends ClientOptions<BrowserTransportOptions>, BaseBrowserOptions {}\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nexport class BrowserClient extends BaseClient<BrowserClientOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserClientOptions) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel = 'info',\n    hint?: EventHint,\n  ): PromiseLike<Event> {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event, hint?: EventHint): void {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    const breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) as Breadcrumbs | null;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n  private _flushOutcomes(): void {\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      __DEBUG_BUILD__ && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      __DEBUG_BUILD__ && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    __DEBUG_BUILD__ && logger.log('Sending outcomes:', outcomes);\n\n    const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      const isRealNavigator = Object.prototype.toString.call(WINDOW && WINDOW.navigator) === '[object Navigator]';\n      const hasSendBeacon = isRealNavigator && typeof WINDOW.navigator.sendBeacon === 'function';\n      // Make sure beacon is not used if user configures custom transport options\n      if (hasSendBeacon && !this._options.transportOptions) {\n        // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n        const sendBeacon = WINDOW.navigator.sendBeacon.bind(WINDOW.navigator);\n        sendBeacon(url, serializeEnvelope(envelope));\n      } else {\n        // If beacon is not supported or if they are using the tunnel option\n        // use our regular transport to send client reports to Sentry.\n        this._sendEnvelope(envelope);\n      }\n    } catch (e) {\n      __DEBUG_BUILD__ && logger.error(e);\n    }\n  }\n}\n","import { isNativeFetch, logger, WINDOW } from '@sentry/utils';\n\nlet cachedFetchImpl: FetchImpl;\n\nexport type FetchImpl = typeof fetch;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nexport function getNativeFetchImplementation(): FetchImpl {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  /* eslint-disable @typescript-eslint/unbound-method */\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(WINDOW.fetch)) {\n    return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));\n  }\n\n  const document = WINDOW.document;\n  let fetchImpl = WINDOW.fetch;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      __DEBUG_BUILD__ &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(WINDOW));\n  /* eslint-enable @typescript-eslint/unbound-method */\n}\n","import { ClientReport, ClientReportEnvelope, ClientReportItem } from '@sentry/types';\n\nimport { createEnvelope } from './envelope';\nimport { dateTimestampInSeconds } from './time';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nexport function createClientReportEnvelope(\n  discarded_events: ClientReport['discarded_events'],\n  dsn?: string,\n  timestamp?: number,\n): ClientReportEnvelope {\n  const clientReportItem: ClientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope<ClientReportEnvelope>(dsn ? { dsn } : {}, [clientReportItem]);\n}\n","import { createTransport } from '@sentry/core';\nimport { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\n\nimport { BrowserTransportOptions } from './types';\nimport { FetchImpl, getNativeFetchImplementation } from './utils';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeFetchTransport(\n  options: BrowserTransportOptions,\n  nativeFetch: FetchImpl = getNativeFetchImplementation(),\n): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch), a request with `keepalive: true`\n      //   and a content length of > 64 kibibytes returns a network error. We will therefore only activate the flag when\n      //   we're below that limit.\n      keepalive: request.body.length <= 65536,\n      ...options.fetchOptions,\n    };\n\n    return nativeFetch(options.url, requestOptions).then(response => ({\n      statusCode: response.status,\n      headers: {\n        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n        'retry-after': response.headers.get('Retry-After'),\n      },\n    }));\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import { createTransport } from '@sentry/core';\nimport { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n\nimport { BrowserTransportOptions } from './types';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nexport function makeXHRTransport(options: BrowserTransportOptions): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    return new SyncPromise((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = (): void => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (const header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import { StackFrame, StackLineParser, StackLineParserFn } from '@sentry/types';\nimport { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {\n  const frame: StackFrame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n  /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nconst chrome: StackLineParserFn = line => {\n  const parts = chromeRegex.exec(line);\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nexport const chromeStackLineParser: StackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko: StackLineParserFn = line => {\n  const parts = geckoREgex.exec(line);\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nexport const geckoStackLineParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nexport const winjsStackLineParser: StackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10: StackLineParserFn = line => {\n  const parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackLineParser: StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11: StackLineParserFn = line => {\n  const parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackLineParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\nexport const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nexport const defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","import { Client, ClientOptions } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { getCurrentHub } from './hub';\n\n/** A class object that can instantiate Client objects. */\nexport type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind<F extends Client, O extends ClientOptions>(\n  clientClass: ClientClass<F, O>,\n  options: O,\n): void {\n  if (options.debug === true) {\n    if (__DEBUG_BUILD__) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      // eslint-disable-next-line no-console\n      console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  const hub = getCurrentHub();\n  const scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  const client = new clientClass(options);\n  hub.bindClient(client);\n}\n","import {\n  getCurrentHub,\n  getIntegrationsToSetup,\n  getReportDialogEndpoint,\n  Hub,\n  initAndBind,\n  Integrations as CoreIntegrations,\n} from '@sentry/core';\nimport {\n  addInstrumentationHandler,\n  logger,\n  resolvedSyncPromise,\n  stackParserFromStackParserOptions,\n  supportsFetch,\n  WINDOW,\n} from '@sentry/utils';\n\nimport { BrowserClient, BrowserClientOptions, BrowserOptions } from './client';\nimport { ReportDialogOptions, wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, Dedupe, GlobalHandlers, HttpContext, LinkedErrors, TryCatch } from './integrations';\nimport { defaultStackParser } from './stack-parsers';\nimport { makeFetchTransport, makeXHRTransport } from './transports';\n\nexport const defaultIntegrations = [\n  new CoreIntegrations.InboundFilters(),\n  new CoreIntegrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options: BrowserOptions = {}): void {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    // This supports the variable that sentry-webpack-plugin injects\n    if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {\n      options.release = WINDOW.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  const clientOptions: BrowserClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options: ReportDialogOptions = {}, hub: Hub = getCurrentHub()): void {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    __DEBUG_BUILD__ && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  const dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    __DEBUG_BUILD__ && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    script.onload = options.onLoad;\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    __DEBUG_BUILD__ && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId(): string | undefined {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad(): void {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback: () => void): void {\n  callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function flush(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.flush(timeout);\n  }\n  __DEBUG_BUILD__ && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function close(timeout?: number): PromiseLike<boolean> {\n  const client = getCurrentHub().getClient<BrowserClient>();\n  if (client) {\n    return client.close(timeout);\n  }\n  __DEBUG_BUILD__ && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn: (...args: any) => any): any {\n  return internalWrap(fn)();\n}\n\nfunction startSessionOnHub(hub: Hub): void {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  if (typeof WINDOW.document === 'undefined') {\n    __DEBUG_BUILD__ &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  const hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n","export * from './exports';\n\nimport { Integrations as CoreIntegrations } from '@sentry/core';\nimport { WINDOW } from '@sentry/utils';\n\nimport * as BrowserIntegrations from './integrations';\n\nlet windowIntegrations = {};\n\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nif (WINDOW.Sentry && WINDOW.Sentry.Integrations) {\n  windowIntegrations = WINDOW.Sentry.Integrations;\n}\n\nconst INTEGRATIONS = {\n  ...windowIntegrations,\n  ...CoreIntegrations,\n  ...BrowserIntegrations,\n};\n\nexport { INTEGRATIONS as Integrations };\n","import { isString } from './is';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/**\n * TODO: Move me to @sentry/browser when @sentry/utils no longer contains any browser code\n */\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem: unknown, keyAttrs?: string[]): string {\n  type SimpleNode = {\n    parentNode: SimpleNode;\n  } | null;\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem as SimpleNode;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const MAX_OUTPUT_LEN = 80;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n\n    // eslint-disable-next-line no-plusplus\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el: unknown, keyAttrs?: string[]): string {\n  const elem = el as {\n    tagName?: string;\n    id?: string;\n    className?: string;\n    getAttribute(key: string): string;\n  };\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getDomElement<E = any>(selector: string): E | null {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector) as unknown as E;\n  }\n  return null;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n\nimport { PolymorphicEvent, Primitive } from '@sentry/types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record<string, unknown> {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike<any> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isNaN(wat: unknown): boolean {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n"],"sourceRoot":""}