{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/@sentry/utils/esm/url.js","webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/utils/esm/severity.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/utils/esm/clientreport.js","webpack:///./node_modules/@sentry/browser/esm/stack-parsers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack:///./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack:///./node_modules/@sentry/browser/esm/transports/utils.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js","webpack:///./node_modules/@sentry/utils/esm/baggage.js","webpack:///./node_modules/@sentry/tracing/esm/browser/types.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getActivationStart.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js","webpack:///./node_modules/@sentry/tracing/esm/browser/metrics/utils.js","webpack:///./node_modules/@sentry/tracing/esm/browser/metrics/index.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/request.js","webpack:///./node_modules/@sentry/tracing/esm/browser/browsertracing.js","webpack:///./node_modules/@sentry/tracing/esm/browser/router.js","webpack:///./node_modules/@sentry/tracing/esm/browser/backgroundtab.js","webpack:///./node_modules/@sentry/integrations/esm/captureconsole.js","webpack:///./node_modules/@sentry/tracing/esm/index.js","webpack:///./app/javascript/packs/error_tracking.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/core/esm/exports.js","webpack:///./node_modules/@sentry/core/esm/session.js","webpack:///./node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/core/esm/scope.js","webpack:///./node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/tracing/esm/span.js","webpack:///./node_modules/@sentry/tracing/esm/idletransaction.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/@sentry/tracing/esm/hubextensions.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/tracing/esm/transaction.js","webpack:///./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack:///(webpack)/buildin/harmony-module.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/utils/esm/stacktrace.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/tracing/esm/utils.js","webpack:///./node_modules/@sentry/core/esm/hub.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/utils/esm/tracing.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/core/esm/version.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/utils/esm/ratelimit.js","webpack:///./node_modules/@sentry/core/esm/transports/base.js","webpack:///./node_modules/@sentry/core/esm/envelope.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/utils/esm/env.js","webpack:///./node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/tracing/esm/errors.js","webpack:///./node_modules/@sentry/utils/esm/normalize.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/utils/esm/envelope.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/worldwide.js"],"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","_typeof","obj","iterator","constructor","g","this","Function","e","window","parseUrl","url","match","query","fragment","host","path","protocol","relative","ownKeys","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread","target","arguments","length","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","configurable","writable","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","type","extractMessage","stacktrace","undefined","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","error","level","hint","attachStacktrace","syntheticException","event","eventFromString","event_id","eventFromUnknownInput","isUnhandledRejection","is","domException","concat","tags","code","client","getClient","normalizeDepth","getOptions","extra","__serialized__","normalize","eventFromPlainObject","synthetic","input","WINDOW","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","options","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","slice","wrappedArguments","map","arg","scope","addEventProcessor","mechanism","_oO","descriptor","validSeverityLevels","severityLevelFromString","includes","_defineProperties","props","Breadcrumbs","instance","Constructor","TypeError","_classCallCheck","__init","console","dom","fetch","history","sentry","xhr","protoProps","staticProps","id","_consoleBreadcrumb","handlerData","keyAttrs","serializeAttribute","addBreadcrumb","category","global","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","data","logger","endTimestamp","__sentry_own_request__","_ref","__sentry_xhr__","method","status_code","body","fetchData","response","status","from","to","parsedLoc","location","href","parsedFrom","parsedTo","_get","Reflect","receiver","base","_superPropBase","desc","_getPrototypeOf","_setPrototypeOf","setPrototypeOf","__proto__","_createSuper","Derived","hasNativeReflectConstruct","construct","sham","Proxy","Boolean","valueOf","_isNativeReflectConstruct","result","Super","NewTarget","_possibleConstructorReturn","self","ReferenceError","_assertThisInitialized","getPrototypeOf","__initStatic","_BaseClient","subClass","superClass","_inherits","BrowserClient","_super","_this","_metadata","sdk","packages","version","sendClientReports","document","addEventListener","visibilityState","_flushOutcomes","_options","breadcrumbIntegration","getIntegrationById","platform","outcomes","_clearOutcomes","_dsn","__SENTRY_DEBUG__","log","discarded_events","dsn","timestamp","clientReportItem","envelope","tunnel","toString","navigator","sendBeacon","transportOptions","_sendEnvelope","_slicedToArray","arr","isArray","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","next","done","err","_iterableToArrayLimit","minLen","_arrayLikeToArray","_unsupportedIterableToArray","_nonIterableRest","len","arr2","createFrame","filename","func","lineno","colno","frame","function","in_app","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackLineParsers","line","parts","exec","indexOf","subMatch","_extractSafariExtensi2","extractSafariExtensionDetails","_extractSafariExtensi4","defaultStackParser","isSafariExtension","isSafariWebExtension","split","DEFAULT_EVENT_TARGET","TryCatch","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","original","_len","_key","originalCallback","handled","callback","handler","originalSend","xmlHttpRequestProps","prop","wrapOptions","originalFunction","_len2","_key2","globalObject","proto","eventName","handleEvent","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","__init2","onerror","onunhandledrejection","_installFunc","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","installFunc","_getHubAndOptions2","getHubAndOptions","hub","getIntegration","msg","column","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","_getHubAndOptions4","reason","detail","String","ev","ev0","ev0s","ev0sf","isNaN","parseInt","captureEvent","originalException","_toConsumableArray","_arrayWithoutHoles","iter","_iterableToArray","_nonIterableSpread","LinkedErrors","_limit","limit","parser","linkedErrors","_walkErrorTree","_handler","Dedupe","addGlobalEventProcessor","getCurrentHub","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_previousEvent","warn","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","HttpContext","request","referrer","userAgent","headers","Referer","cachedFetchImpl","getNativeFetchImplementation","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","clearCachedFetchImplementation","makeFetchTransport","nativeFetch","makeRequest","requestOptions","referrerPolicy","keepalive","fetchOptions","then","statusCode","makeXHRTransport","resolve","reject","header","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","send","defaultIntegrations","InboundFilters","FunctionToString","startSessionOnHub","startSession","ignoreDuration","captureSession","startSessionTracking","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","dynamicSamplingContextToSentryBaggageHeader","dynamicSamplingContext","entries","reduce","baggageHeader","_ref7","currentIndex","_ref8","objectKey","objectValue","baggageEntry","encodeURIComponent","newBaggageHeader","objectToBaggageHeader","acc","_ref3","_ref4","dscKey","dscValue","baggageHeaderToObject","keyOrValue","decodeURIComponent","trim","_ref5","_ref6","bindReporter","metric","reportAllChanges","prevValue","delta","forceReport","__WEB_VITALS_POLYFILL__","performance","getEntriesByType","timing","navigation","navigationEntry","entryType","startTime","Math","max","navigationStart","navEntry","activationStart","navigationType","prerendering","replace","rating","Date","now","floor","random","observe","opts","PerformanceObserver","supportedEntryTypes","po","list","getEntries","assign","buffered","cb","once","onHiddenOrPageHide","removeEventListener","firstHiddenTime","getVisibilityWatcher","Infinity","timeStamp","reportedMetricIDs","_excluded","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","isMeasurementValue","isFinite","_startChild","transaction","startTimestamp","ctx","startChild","_createForOfIteratorHelper","allowArrayLike","it","F","f","normalCompletion","didErr","step","_e2","return","getBrowserPerformanceAPI","_lcpEntry","_clsEntry","_performanceCursor","_measurements","_trackCLS","onReport","report","sessionValue","sessionEntries","handleEntries","entry","hadRecentInput","firstSessionEntry","lastSessionEntry","takeRecords","pop","unit","_trackLCP","visibilityWatcher","lastEntry","stopListening","disconnect","capture","_trackFID","handleEntry","processingStart","timeOrigin","addPerformanceEntries","responseStartTimestamp","requestStartTimestamp","performanceEntries","duration","op","_addPerformanceNavigationTiming","description","requestStart","responseEnd","responseStart","_addRequest","_addNavigationSpans","measureStartTimestamp","measureEndTimestamp","_addMeasureSpans","firstHidden","shouldRecord","resourceName","origin","initiatorType","transferSize","encodedBodySize","decodedBodySize","_addResourceSpans","connection","effectiveType","setTag","rtt","deviceMemory","hardwareConcurrency","_trackNavigator","oldValue","measurementTimestamp","normalizedValue","abs","fidMark","cls","measurementName","setMeasurement","element","size","sources","index","node","_tagMetricInfo","eventEnd","end","start","_nullishCoalesce","DEFAULT_TRACE_PROPAGATION_TARGETS","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","tracePropagationTargets","instrumentOutgoingRequests","_traceFetch$traceXHR$","shouldCreateSpanForRequest","shouldCreateSpan","_","shouldAttachHeadersWithTargets","string","spans","shouldAttachHeaders","spanId","__span","span","setHttpStatus","setStatus","finish","activeTransaction","_span","sentryBaggageHeader","sentryTraceHeader","toTraceparent","Request","Headers","newHeaders","append","_newHeaders","existingBaggageHeader","baggage","newBaggageHeaders","addTracingHeadersToFetchRequest","getDynamicSamplingContext","metadata","propagations","fetchCallback","__sentry_xhr_span_id__","_span2","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","idleTimeout","finalTimeout","heartbeatInterval","markBackgroundTransactions","routingInstrumentation","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","pathname","_experiments","enableLongTask","BrowserTracing","_metricOptions","mark","startTrackingWebVitals","_reportAllChanges","_optionalChain","_2","_3","_4","_step","_iterator","_getCurrentHub","_this$options","instrumentRouting","context","_createRouteTransaction","_this2","_this$options2","beforeNavigate","isPageloadTransaction","sentryTraceMetaTagValue","getMetaContent","baggageMetaTagValue","traceParentData","baggageObject","curr","currBaggageObject","_ref2","baggageHeaderToDynamicSamplingContext","expandedContext","trimEnd","modifiedContext","finalContext","sampled","idleTransaction","registerBeforeFinishCallback","metaName","metaTag","getAttribute","__SENTRY_TRACING__","CaptureConsole","levels","_levels","originalConsoleMethod","withScope","setLevel","setExtra","captureMessage","captureException","setSentryUrlHash","organization_slug","Sentry","release","SENTRY_RELEASE","autoSessionTracking","clientOptions","integrations","transport","supports","environment","gon","tracesSampleRate","originalFunctionToString","DEFAULT_IGNORE_ERRORS","eventProcess","ignoreInternal","_isSentryError","ignoreErrors","_ref$type","_ref$value","oO","_getPossibleEventMessages","some","_isIgnoredError","denyUrls","_getEventFilterUrl","_isDeniedUrl","allowUrls","_isAllowedUrl","internalOptions","_mergeOptions","_getLastValidUrl","captureContext","makeSession","startingTime","session","sid","init","started","errors","toJSON","toISOString","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","user","email","username","closeSession","dateTimestampSource","nowSeconds","platformPerformance","getNodePerformance","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","browserPerformanceTimeOrigin","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStartDelta","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_session","_transactionName","_fingerprint","_requestSession","_notifyScopeListeners","requestSession","extras","getSpan","updatedScope","contexts","maxBreadcrumbs","maxCrumbs","mergedBreadcrumb","attachment","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","newData","processors","processor","final","isNodeEnv","process","dynamicRequire","mod","require","loadModule","moduleName","cwd","uuid4","gbl","crypto","msCrypto","randomUUID","getRandomByte","getRandomValues","Uint8Array","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","arrayify","maybeArray","_createClass","SpanRecorder","maxlen","_maxlen","spanRecorder","Span","spanContext","__init3","__init4","__init5","__init6","__init7","traceId","parentSpanId","instrumenter","substring","childSpan","add","opStr","nameStr","idStr","logMessage","spanMetadata","httpStatus","spanStatus","spanStatusfromHttpCode","sampledString","parent_span_id","span_id","trace_id","start_timestamp","DEFAULT_IDLE_TIMEOUT","DEFAULT_FINAL_TIMEOUT","DEFAULT_HEARTBEAT_INTERVAL","IdleTransactionSpanRecorder","_SpanRecorder","_pushActivity","_popActivity","transactionSpanId","IdleTransaction","_Transaction","_super2","transactionContext","_idleHub","_this3","_idleTimeout","_finalTimeout","_heartbeatInterval","_onScope","clearActiveTransaction","configureScope","setSpan","_startIdleTimeout","_finished","activities","_heartbeatCounter","_beforeFinishCallbacks","_this4","JSON","stringify","keepSpan","_this5","_pingHeartbeat","_idleTimeoutID","clearTimeout","_this6","_cancelIdleTimeout","heartbeatString","_prevHeartbeatString","_this7","_beat","getScope","getTransaction","_wrapNativeSuper","Class","_cache","Map","has","set","Wrapper","_construct","Parent","a","SentryError","_Error","logLevel","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","array","noop","nextTick","title","browser","env","argv","versions","on","addListener","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","dir","umask","traceHeaders","sample","samplingContext","setMetadata","sampleRate","Number","tracesSampler","parentSampled","rate","isValidSampleRate","_startTransaction","customSamplingContext","configInstrumenter","transactionInstrumenter","initSpanRecorder","maxSpans","startIdleTransaction","onScope","addExtensionMethods","carrier","__SENTRY__","extensions","startTransaction","packageToIntegrationMapping","mongodb","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","pkg","_autoloadDatabaseIntegrations","truncate","str","substr","snipLine","newLine","lineLength","min","safeJoin","delimiter","output","isMatchingPattern","pattern","requireExactStringMatch","stringMatchesSomePattern","testString","patterns","Transaction","_Span","_hub","_name","changes","_trimEnd","incomingDynamicSamplingContext","_frozenDynamicSamplingContext","newName","setName","newMetadata","finishedSpans","prev","current","transaction_info","measurements","recordDroppedEvent","public_key","getDsn","publicKey","maybeSampleRate","sample_rate","user_segment","getUser","segment","lhs","rhsFn","originalModule","webpackPolyfill","children","getBaseApiEndpoint","port","_getIngestEndpoint","projectId","_encodedAuth","sdkInfo","sentry_key","sentry_version","sentry_client","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","executor","_resolve","_reject","_state","PENDING","_handlers","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","installedIntegrations","getIntegrationsToSetup","userIntegrations","integration","isDefaultInstance","finalIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","debugIndex","findIndex","debugInstance","splice","setupIntegrations","integrationIndex","setupOnce","createStackParser","parsers","sortedParsers","sort","b","skipFirst","_step2","cleanedLine","_iterator2","stripSentryFramesAndReverse","stackParserFromStackParserOptions","localStack","firstFrameFunction","lastFrameFunction","reverse","getFunctionName","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enabled","enable","disable","_GLOBAL_OBJ$console","hasTracingEnabled","maybeOptions","getActiveTransaction","maybeHub","msToSec","time","Hub","_version","getStackTop","bindClient","_stack","clone","getStack","pushScope","popScope","_lastEventId","_withClient","_this$getStackTop","_ref$beforeBreadcrumb","beforeBreadcrumb","_ref$maxBreadcrumbs","finalBreadcrumb","setUser","setTags","setExtras","setContext","_this$getStackTop2","oldHub","makeMain","_callExtensionMethod","endSession","_sendSessionUpdate","layer","getSession","setSession","_this$getStackTop3","currentSession","sendDefaultPii","_this$getStackTop4","_this$getStackTop5","getMainCarrier","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","isOlderThan","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","supportsFetch","Response","isNativeFetch","supportsNativeFetch","doc","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","objectToString","isError","wat","isInstanceOf","isBuiltin","className","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","TRACEPARENT_REGEXP","RegExp","extractTraceparentData","traceparent","matches","initAndBind","clientClass","debug","update","initialScope","SDK_VERSION","makePromiseBuffer","buffer","remove","task","$","taskProducer","drain","counter","capturedSetTimeout","item","_e3","parseRetryAfterHeader","headerDelay","headerDate","parse","disabledUntil","limits","all","isRateLimited","updateRateLimits","updatedRateLimits","rateLimitHeader","retryAfterHeader","_limit$split","_limit$split2","retryAfter","categories","delay","createTransport","bufferSize","rateLimits","flush","filteredEnvelopeItems","envelopeItemDataCategory","filteredEnvelope","recordEnvelopeLoss","textEncoder","getSdkMetadataForEnvelopeHeader","_metadata$sdk","createEventEnvelope","eventType","enhanceEventWithSdkInfo","envelopeHeaders","sent_at","createEventEnvelopeHeaders","eventItem","ALREADY_SEEN_ERROR","BaseClient","_transport","_integrations","_integrationsInitialized","_numProcessing","_outcomes","_process","eventFromException","_captureEvent","promisedEvent","eventFromMessage","_isEnabled","sendSession","_isClientDoneProcessing","clientFinished","transportFlushed","integrationId","attachments","envelopeItem","createSessionEnvelope","crashed","errored","exceptions","sessionNonTerminal","ticked","interval","clearInterval","_this$getOptions","_this$getOptions$norm","_this$getOptions$norm2","normalizeMaxBreadth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","getAttachments","applyToEvent","evt","_normalizeEvent","depth","maxBreadth","normalized","dist","_options$maxValueLeng","maxValueLength","integrationsArray","_processEvent","finalEvent","sentryError","isTransaction","beforeSendProcessorName","beforeSendProcessor","_prepareEvent","__sentry__","beforeSendResult","invalidValueError","_validateBeforeSendResult","processedEvent","_updateSessionFromEvent","transactionInfo","sendEvent","promise","_key$split2","quantity","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","htmlTreeAsString","elem","nextStr","currentElem","out","height","sepLength","_htmlElementAsString","parentNode","el","classes","attr","tagName","toLowerCase","keyAttrPairs","keyAttr","keyAttrPair","allowedAttrs","getLocationHref","getDomElement","selector","querySelector","registerErrorInstrumentation","errorCallback","maxProperties","visit","ERROR","normalizeToSize","maxSize","jsonSize","memo","_memo","memoize","unmemoize","stringified","stringifyValue","startsWith","valueWithToJSON","jsonValue","numAdded","visitable","visitKey","visitValue","_events","encodeURI","utf8Length","memoBuilder","hasWeakSet","WeakSet","inner","delete","createEnvelope","items","addItemToEnvelope","newItem","_envelope","forEachEnvelopeItem","envelopeItemType","encodeUTF8","TextEncoder","encode","serializeEnvelope","_envelope2","envHeaders","_item","itemHeaders","payload","stringifiedPayload","buffers","totalLength","buf","merged","offset","concatBuffers","createAttachmentEnvelopeItem","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","lastHref","handlers","instrumented","instrument","triggerHandlers","instrumentConsole","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","_handlers2","instrumentDOM","xhrproto","originalOpen","_len3","_key3","xhrInfo","toUpperCase","onreadystatechangeHandler","_len4","readyStateArgs","_key4","_len5","_key5","instrumentXHR","originalFetch","getFetchMethod","getFetchUrl","instrumentFetch","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","_len7","_key7","_len6","_key6","instrumentHistory","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","addInstrumentationHandler","fetchArgs","debounceTimerID","lastCapturedEvent","shouldShortcircuitPreviousDebounce","previous","shouldSkipDOMEvent","isContentEditable","globalListener","ops","lastAccessLHS","DSN_REGEX","dsnToString","withPassword","pass","dsnFromComponents","components","makeDsn","_match$slice2","_match$slice2$","_match$slice2$2","projectMatch","dsnFromString","component","isValidProtocol","validateDsn","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","getOriginalFunction","urlEncode","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","extractedProps","extractExceptionKeysForMessage","maxLength","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","memoizationMap","memoVal","returnValue","_Object$keys","_memoVal","_returnValue","isGlobalObj","GLOBAL_OBJ","globalThis","getGlobalObject","getGlobalSingleton","creator"],"mappings":"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","file":"js/error_tracking-425bd2df3c098a92ed4e.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 = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1129);\n","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nvar g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\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\n\nmodule.exports = g;","/**\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 */\nfunction parseUrl(url) {\n  if (!url) {\n    return {};\n  }\n\n  var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  } // coerce to undefined values to empty string so we don't get 'undefined'\n\n\n  var query = match[6] || '';\n  var 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 */\n\n\nfunction stripUrlQueryAndFragment(urlPath) {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n/**\n * Returns number of URL segments of a passed string URL.\n */\n\n\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(function (s) {\n    return s.length > 0 && s !== ',';\n  }).length;\n}\n\nexport { getNumberOfUrlSegments, parseUrl, stripUrlQueryAndFragment };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { getCurrentHub } from '@sentry/core';\nimport { isEvent, extractExceptionKeysForMessage, normalizeToSize, addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject } from '@sentry/utils';\n/**\n * This function creates an exception from a JavaScript Error\n */\n\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  var frames = parseStackFrames(stackParser, ex);\n  var exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex)\n  };\n\n  if (frames.length) {\n    exception.stacktrace = {\n      frames: frames\n    };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n/**\n * @hidden\n */\n\n\nfunction eventFromPlainObject(stackParser, exception, syntheticException, isUnhandledRejection) {\n  var hub = getCurrentHub();\n  var client = hub.getClient();\n  var normalizeDepth = client && client.getOptions().normalizeDepth;\n  var event = {\n    exception: {\n      values: [{\n        type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n        value: \"Non-Error \".concat(isUnhandledRejection ? 'promise rejection' : 'exception', \" captured with keys: \").concat(extractExceptionKeysForMessage(exception))\n      }]\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception, normalizeDepth)\n    }\n  };\n\n  if (syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      event.exception.values[0].stacktrace = {\n        frames: frames\n      };\n    }\n  }\n\n  return event;\n}\n/**\n * @hidden\n */\n\n\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)]\n    }\n  };\n}\n/** Parses stack frames from an error */\n\n\nfunction parseStackFrames(stackParser, ex) {\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  var stacktrace = ex.stacktrace || ex.stack || '';\n  var popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {// no-empty\n  }\n\n  return [];\n} // Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\n\n\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\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 * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\n\n\nfunction extractMessage(ex) {\n  var message = ex && ex.message;\n\n  if (!message) {\n    return 'No error message';\n  }\n\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n\n  return message;\n}\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\n\n\nfunction eventFromException(stackParser, exception, hint, attachStacktrace) {\n  var syntheticException = hint && hint.syntheticException || undefined;\n  var event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n\n  event.level = 'error';\n\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n\n  return resolvedSyncPromise(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\n\n\nfunction eventFromMessage(stackParser, message) {\n  var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'info';\n  var hint = arguments.length > 3 ? arguments[3] : undefined;\n  var attachStacktrace = arguments.length > 4 ? arguments[4] : undefined;\n  var syntheticException = hint && hint.syntheticException || undefined;\n  var event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n\n  return resolvedSyncPromise(event);\n}\n/**\n * @hidden\n */\n\n\nfunction eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace, isUnhandledRejection) {\n  var event;\n\n  if (isErrorEvent(exception) && exception.error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    var errorEvent = exception;\n    return eventFromError(stackParser, errorEvent.error);\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\n\n  if (isDOMError(exception) || isDOMException(exception)) {\n    var domException = exception;\n\n    if ('stack' in exception) {\n      event = eventFromError(stackParser, exception);\n    } else {\n      var name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      var message = domException.message ? \"\".concat(name, \": \").concat(domException.message) : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n\n    if ('code' in domException) {\n      event.tags = _objectSpread(_objectSpread({}, event.tags), {}, {\n        'DOMException.code': \"\".concat(domException.code)\n      });\n    }\n\n    return event;\n  }\n\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\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    var objectException = exception;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true\n    });\n    return event;\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\n\n  event = eventFromString(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, \"\".concat(exception), undefined);\n  addExceptionMechanism(event, {\n    synthetic: true\n  });\n  return event;\n}\n/**\n * @hidden\n */\n\n\nfunction eventFromString(stackParser, input, syntheticException, attachStacktrace) {\n  var event = {\n    message: input\n  };\n\n  if (attachStacktrace && syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n\n    if (frames.length) {\n      event.exception = {\n        values: [{\n          value: input,\n          stacktrace: {\n            frames: frames\n          }\n        }]\n      };\n    }\n  }\n\n  return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { withScope, captureException } from '@sentry/core';\nimport { GLOBAL_OBJ, getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\nvar WINDOW = GLOBAL_OBJ;\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\n\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\n\n\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(function () {\n    ignoreOnError -= 1;\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 */\n\n\nfunction wrap(fn) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var before // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  = arguments.length > 2 ? arguments[2] : undefined;\n\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  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    var wrapper = fn.__sentry_wrapped__;\n\n    if (wrapper) {\n      return wrapper;\n    } // We don't wanna wrap it twice\n\n\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  /* eslint-disable prefer-rest-params */\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n\n\n  var sentryWrapped = function sentryWrapped() {\n    var args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      } // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n\n\n      var wrappedArguments = args.map(function (arg) {\n        return wrap(arg, options);\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\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n      withScope(function (scope) {\n        scope.addEventProcessor(function (event) {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = _objectSpread(_objectSpread({}, event.extra), {}, {\n            arguments: args\n          });\n          return event;\n        });\n        captureException(ex);\n      });\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n\n\n  try {\n    for (var 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  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n\n\n  markFunctionWrapped(sentryWrapped, fn);\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped); // Restore original function name (not all browsers allow that)\n\n  try {\n    var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get: function get() {\n          return fn.name;\n        }\n      });\n    } // eslint-disable-next-line no-empty\n\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n/**\n * All properties the report dialog supports\n */\n\n\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };","// 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.\nvar validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\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 */\n\nfunction severityFromString(level) {\n  return severityLevelFromString(level);\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 */\n\n\nfunction severityLevelFromString(level) {\n  return level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log';\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, parseUrl } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\n\nvar BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\n\nvar Breadcrumbs = /*#__PURE__*/function () {\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\n  /**\n   * @inheritDoc\n   */\n  function Breadcrumbs(options) {\n    _classCallCheck(this, Breadcrumbs);\n\n    ;\n\n    Breadcrumbs.prototype.__init.call(this);\n\n    this.options = _objectSpread({\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true\n    }, options);\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\n\n  _createClass(Breadcrumbs, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = Breadcrumbs.id;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\n      if (this.options.console) {\n        addInstrumentationHandler('console', _consoleBreadcrumb);\n      }\n\n      if (this.options.dom) {\n        addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n      }\n\n      if (this.options.xhr) {\n        addInstrumentationHandler('xhr', _xhrBreadcrumb);\n      }\n\n      if (this.options.fetch) {\n        addInstrumentationHandler('fetch', _fetchBreadcrumb);\n      }\n\n      if (this.options.history) {\n        addInstrumentationHandler('history', _historyBreadcrumb);\n      }\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = BREADCRUMB_INTEGRATION_ID;\n    }\n  }]);\n\n  return Breadcrumbs;\n}();\n\nBreadcrumbs.__initStatic();\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\n\n\nfunction _domBreadcrumb(dom) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function _innerDomBreadcrumb(handlerData) {\n    var target;\n    var keyAttrs = _typeof(dom) === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    } // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n\n\n    try {\n      target = handlerData.event.target ? htmlTreeAsString(handlerData.event.target, keyAttrs) : htmlTreeAsString(handlerData.event, keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb({\n      category: \"ui.\".concat(handlerData.name),\n      message: target\n    }, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global\n    });\n  }\n\n  return _innerDomBreadcrumb;\n}\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _consoleBreadcrumb(handlerData) {\n  // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n  // console warnings. This happens when a Vue template is rendered with\n  // an undeclared variable, which we try to stringify, ultimately causing\n  // Vue to issue another warning which repeats indefinitely.\n  // see: https://github.com/getsentry/sentry-javascript/pull/6010\n  // see: https://github.com/getsentry/sentry-javascript/issues/5916\n  for (var i = 0; i < handlerData.args.length; i++) {\n    if (handlerData.args[i] === 'ref=Ref<') {\n      handlerData.args[i + 1] = 'viewRef';\n      break;\n    }\n  }\n\n  var 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: \".concat(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 * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _xhrBreadcrumb(handlerData) {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    var _ref = handlerData.xhr.__sentry_xhr__ || {},\n        method = _ref.method,\n        url = _ref.url,\n        status_code = _ref.status_code,\n        body = _ref.body;\n\n    getCurrentHub().addBreadcrumb({\n      category: 'xhr',\n      data: {\n        method: method,\n        url: url,\n        status_code: status_code\n      },\n      type: 'http'\n    }, {\n      xhr: handlerData.xhr,\n      input: body\n    });\n    return;\n  }\n}\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _fetchBreadcrumb(handlerData) {\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      category: 'fetch',\n      data: handlerData.fetchData,\n      level: 'error',\n      type: 'http'\n    }, {\n      data: handlerData.error,\n      input: handlerData.args\n    });\n  } else {\n    getCurrentHub().addBreadcrumb({\n      category: 'fetch',\n      data: _objectSpread(_objectSpread({}, handlerData.fetchData), {}, {\n        status_code: handlerData.response.status\n      }),\n      type: 'http'\n    }, {\n      input: handlerData.args,\n      response: handlerData.response\n    });\n  }\n}\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _historyBreadcrumb(handlerData) {\n  var from = handlerData.from;\n  var to = handlerData.to;\n  var parsedLoc = parseUrl(WINDOW.location.href);\n  var parsedFrom = parseUrl(from);\n  var parsedTo = parseUrl(to); // Initial pushState doesn't provide `from` information\n\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\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\n\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\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: from,\n      to: to\n    }\n  });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nfunction _get() { if (typeof Reflect !== \"undefined\" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }\n\nfunction _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nimport { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException as _eventFromException, eventFromMessage as _eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\n\nvar BrowserClient = /*#__PURE__*/function (_BaseClient) {\n  _inherits(BrowserClient, _BaseClient);\n\n  var _super = _createSuper(BrowserClient);\n\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  function BrowserClient(options) {\n    var _this;\n\n    _classCallCheck(this, BrowserClient);\n\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [{\n        name: 'npm:@sentry/browser',\n        version: SDK_VERSION\n      }],\n      version: SDK_VERSION\n    };\n    _this = _super.call(this, options);\n\n    if (options.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', function () {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          _this._flushOutcomes();\n        }\n      });\n    }\n\n    return _this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(BrowserClient, [{\n    key: \"eventFromException\",\n    value: function eventFromException(exception, hint) {\n      return _eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"eventFromMessage\",\n    value: function eventFromMessage(message) {\n      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'info';\n      var hint = arguments.length > 2 ? arguments[2] : undefined;\n      return _eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"sendEvent\",\n    value: function sendEvent(event, hint) {\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      var breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID);\n\n      if (breadcrumbIntegration && // 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 && breadcrumbIntegration.options.sentry) {\n        getCurrentHub().addBreadcrumb({\n          category: \"sentry.\".concat(event.type === 'transaction' ? 'transaction' : 'event'),\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event)\n        }, {\n          event: event\n        });\n      }\n\n      _get(_getPrototypeOf(BrowserClient.prototype), \"sendEvent\", this).call(this, event, hint);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"_prepareEvent\",\n    value: function _prepareEvent(event, hint, scope) {\n      event.platform = event.platform || 'javascript';\n      return _get(_getPrototypeOf(BrowserClient.prototype), \"_prepareEvent\", this).call(this, event, hint, scope);\n    }\n    /**\n     * Sends client reports as an envelope.\n     */\n\n  }, {\n    key: \"_flushOutcomes\",\n    value: function _flushOutcomes() {\n      var outcomes = this._clearOutcomes();\n\n      if (outcomes.length === 0) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n        return;\n      }\n\n      if (!this._dsn) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n        return;\n      }\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n      var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n      var envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n      try {\n        var isRealNavigator = Object.prototype.toString.call(WINDOW && WINDOW.navigator) === '[object Navigator]';\n        var hasSendBeacon = isRealNavigator && typeof WINDOW.navigator.sendBeacon === 'function'; // Make sure beacon is not used if user configures custom transport options\n\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          var 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        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n      }\n    }\n  }]);\n\n  return BrowserClient;\n}(BaseClient);\n\nexport { BrowserClient };","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\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 */\n\nfunction createClientReportEnvelope(discarded_events, dsn, timestamp) {\n  var clientReportItem = [{\n    type: 'client_report'\n  }, {\n    timestamp: timestamp || dateTimestampInSeconds(),\n    discarded_events: discarded_events\n  }];\n  return createEnvelope(dsn ? {\n    dsn: dsn\n  } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nimport { createStackParser } from '@sentry/utils'; // global reference to slice\n\nvar UNKNOWN_FUNCTION = '?';\nvar OPERA10_PRIORITY = 10;\nvar OPERA11_PRIORITY = 20;\nvar CHROME_PRIORITY = 30;\nvar WINJS_PRIORITY = 40;\nvar GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  var frame = {\n    filename: 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} // Chromium based browsers: Chrome, Brave, new Opera, new Edge\n\n\nvar chromeRegex = /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nvar chrome = function chrome(line) {\n  var parts = chromeRegex.exec(line);\n\n  if (parts) {\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      var 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\n        parts[3] = subMatch[2]; // line\n\n        parts[4] = subMatch[3]; // column\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\n\n    var _extractSafariExtensi = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]),\n        _extractSafariExtensi2 = _slicedToArray(_extractSafariExtensi, 2),\n        func = _extractSafariExtensi2[0],\n        filename = _extractSafariExtensi2[1];\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nvar chromeStackLineParser = [CHROME_PRIORITY, chrome]; // 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.\n\nvar geckoREgex = /^\\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;\nvar geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nvar gecko = function gecko(line) {\n  var parts = geckoREgex.exec(line);\n\n  if (parts) {\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n\n    if (isEval) {\n      var 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    var filename = parts[3];\n    var func = parts[1] || UNKNOWN_FUNCTION;\n\n    var _extractSafariExtensi3 = extractSafariExtensionDetails(func, filename);\n\n    var _extractSafariExtensi4 = _slicedToArray(_extractSafariExtensi3, 2);\n\n    func = _extractSafariExtensi4[0];\n    filename = _extractSafariExtensi4[1];\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nvar geckoStackLineParser = [GECKO_PRIORITY, gecko];\nvar winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nvar winjs = function winjs(line) {\n  var parts = winjsRegex.exec(line);\n  return parts ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined) : undefined;\n};\n\nvar winjsStackLineParser = [WINJS_PRIORITY, winjs];\nvar opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nvar opera10 = function opera10(line) {\n  var parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nvar opera10StackLineParser = [OPERA10_PRIORITY, opera10];\nvar opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nvar opera11 = function opera11(line) {\n  var parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nvar opera11StackLineParser = [OPERA11_PRIORITY, opera11];\nvar defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\nvar defaultStackParser = createStackParser.apply(void 0, defaultStackLineParsers);\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 */\n\nvar extractSafariExtensionDetails = function extractSafariExtensionDetails(func, filename) {\n  var isSafariExtension = func.indexOf('safari-extension') !== -1;\n  var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n  return isSafariExtension || isSafariWebExtension ? [func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION, isSafariExtension ? \"safari-extension:\".concat(filename) : \"safari-web-extension:\".concat(filename)] : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { WINDOW, wrap } from '../helpers.js';\nvar DEFAULT_EVENT_TARGET = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\n\nvar TryCatch = /*#__PURE__*/function () {\n  /** JSDoc */\n\n  /**\n   * @inheritDoc\n   */\n  function TryCatch(options) {\n    _classCallCheck(this, TryCatch);\n\n    ;\n\n    TryCatch.prototype.__init.call(this);\n\n    this._options = _objectSpread({\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true\n    }, options);\n  }\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n\n\n  _createClass(TryCatch, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = TryCatch.id;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\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      var eventTargetOption = this._options.eventTarget;\n\n      if (eventTargetOption) {\n        var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = 'TryCatch';\n    }\n  }]);\n\n  return TryCatch;\n}();\n\nTryCatch.__initStatic();\n/** JSDoc */\n\n\nfunction _wrapTimeFunction(original) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: {\n          function: getFunctionName(original)\n        },\n        handled: true,\n        type: 'instrument'\n      }\n    });\n    return original.apply(this, args);\n  };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _wrapRAF(original) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (callback) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [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/** JSDoc */\n\n\nfunction _wrapXHR(originalSend) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function () {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    var xhr = this;\n    var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n    xmlHttpRequestProps.forEach(function (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) {\n          var wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original)\n              },\n              handled: true,\n              type: 'instrument'\n            }\n          }; // If Instrument integration has been called before TryCatch, get the name of original function\n\n          var originalFunction = getOriginalFunction(original);\n\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          } // Otherwise wrap directly\n\n\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    return originalSend.apply(this, args);\n  };\n}\n/** JSDoc */\n\n\nfunction _wrapEventTarget(target) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  var globalObject = WINDOW; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n  var proto = globalObject[target] && globalObject[target].prototype; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original) {\n    return function ( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    eventName, fn, options) {\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: target\n              },\n              handled: true,\n              type: 'instrument'\n            }\n          });\n        }\n      } catch (err) {// can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [eventName, // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      wrap(fn, {\n        mechanism: {\n          data: {\n            function: 'addEventListener',\n            handler: getFunctionName(fn),\n            target: target\n          },\n          handled: true,\n          type: 'instrument'\n        }\n      }), options]);\n    };\n  });\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ) {\n    return function ( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    eventName, fn, options) {\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      var wrappedEventHandler = fn;\n\n      try {\n        var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n\n        if (originalEventHandler) {\n          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n        }\n      } catch (e) {// ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n      }\n\n      return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n    };\n  });\n}\n\nexport { TryCatch };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** Global handlers */\n\nvar GlobalHandlers = /*#__PURE__*/function () {\n  /** JSDoc */\n  function GlobalHandlers(options) {\n    _classCallCheck(this, GlobalHandlers);\n\n    ;\n\n    GlobalHandlers.prototype.__init.call(this);\n\n    GlobalHandlers.prototype.__init2.call(this);\n\n    this._options = _objectSpread({\n      onerror: true,\n      onunhandledrejection: true\n    }, options);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(GlobalHandlers, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = GlobalHandlers.id;\n    }\n    /** JSDoc */\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\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._installFunc = {\n        onerror: _installGlobalOnErrorHandler,\n        onunhandledrejection: _installGlobalOnUnhandledRejectionHandler\n      };\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\n      Error.stackTraceLimit = 50;\n      var options = this._options; // 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\n      for (var key in options) {\n        var installFunc = this._installFunc[key];\n\n        if (installFunc && options[key]) {\n          globalHandlerLog(key);\n          installFunc();\n          this._installFunc[key] = undefined;\n        }\n      }\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = 'GlobalHandlers';\n    }\n  }]);\n\n  return GlobalHandlers;\n}();\n\nGlobalHandlers.__initStatic();\n/** JSDoc */\n\n\nfunction _installGlobalOnErrorHandler() {\n  addInstrumentationHandler('error', // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function (data) {\n    var _getHubAndOptions = getHubAndOptions(),\n        _getHubAndOptions2 = _slicedToArray(_getHubAndOptions, 3),\n        hub = _getHubAndOptions2[0],\n        stackParser = _getHubAndOptions2[1],\n        attachStacktrace = _getHubAndOptions2[2];\n\n    if (!hub.getIntegration(GlobalHandlers)) {\n      return;\n    }\n\n    var msg = data.msg,\n        url = data.url,\n        line = data.line,\n        column = data.column,\n        error = data.error;\n\n    if (shouldIgnoreOnError() || error && error.__sentry_own_request__) {\n      return;\n    }\n\n    var event = error === undefined && isString(msg) ? _eventFromIncompleteOnError(msg, url, line, column) : _enhanceEventWithInitialFrame(eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false), url, line, column);\n    event.level = 'error';\n    addMechanismAndCapture(hub, error, event, 'onerror');\n  });\n}\n/** JSDoc */\n\n\nfunction _installGlobalOnUnhandledRejectionHandler() {\n  addInstrumentationHandler('unhandledrejection', // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function (e) {\n    var _getHubAndOptions3 = getHubAndOptions(),\n        _getHubAndOptions4 = _slicedToArray(_getHubAndOptions3, 3),\n        hub = _getHubAndOptions4[0],\n        stackParser = _getHubAndOptions4[1],\n        attachStacktrace = _getHubAndOptions4[2];\n\n    if (!hub.getIntegration(GlobalHandlers)) {\n      return;\n    }\n\n    var error = e; // dig the object of the rejection out of known event types\n\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      } // 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) {// no-empty\n    }\n\n    if (shouldIgnoreOnError() || error && error.__sentry_own_request__) {\n      return true;\n    }\n\n    var event = isPrimitive(error) ? _eventFromRejectionWithPrimitive(error) : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n    event.level = 'error';\n    addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n    return;\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 */\n\n\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [{\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: \".concat(String(reason))\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\n\n\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n  var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i; // If 'message' is ErrorEvent, get real message from inside\n\n  var message = isErrorEvent(msg) ? msg.message : msg;\n  var name = 'Error';\n  var groups = message.match(ERROR_TYPES_RE);\n\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  var event = {\n    exception: {\n      values: [{\n        type: name,\n        value: message\n      }]\n    }\n  };\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n  // event.exception\n  var e = event.exception = event.exception || {}; // event.exception.values\n\n  var ev = e.values = e.values || []; // event.exception.values[0]\n\n  var ev0 = ev[0] = ev[0] || {}; // event.exception.values[0].stacktrace\n\n  var ev0s = ev0.stacktrace = ev0.stacktrace || {}; // event.exception.values[0].stacktrace.frames\n\n  var ev0sf = ev0s.frames = ev0s.frames || [];\n  var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  var filename = isString(url) && url.length > 0 ? url : getLocationHref(); // event.exception.values[0].stacktrace.frames\n\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno: colno,\n      filename: filename,\n      function: '?',\n      in_app: true,\n      lineno: lineno\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"Global Handler attached: \".concat(type));\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n  addExceptionMechanism(event, {\n    handled: false,\n    type: type\n  });\n  hub.captureEvent(event, {\n    originalException: error\n  });\n}\n\nfunction getHubAndOptions() {\n  var hub = getCurrentHub();\n  var client = hub.getClient();\n  var options = client && client.getOptions() || {\n    stackParser: function stackParser() {\n      return [];\n    },\n    attachStacktrace: false\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\n\nvar LinkedErrors = /*#__PURE__*/function () {\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n  function LinkedErrors() {\n    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, LinkedErrors);\n\n    ;\n\n    LinkedErrors.prototype.__init.call(this);\n\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(LinkedErrors, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = LinkedErrors.id;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\n      var client = getCurrentHub().getClient();\n\n      if (!client) {\n        return;\n      }\n\n      addGlobalEventProcessor(function (event, hint) {\n        var self = getCurrentHub().getIntegration(LinkedErrors);\n        return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n      });\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = 'LinkedErrors';\n    }\n  }]);\n\n  return LinkedErrors;\n}();\n\nLinkedErrors.__initStatic();\n/**\n * @inheritDoc\n */\n\n\nfunction _handler(parser, key, limit, event, hint) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n\n  var linkedErrors = _walkErrorTree(parser, limit, hint.originalException, key);\n\n  event.exception.values = [].concat(_toConsumableArray(linkedErrors), _toConsumableArray(event.exception.values));\n  return event;\n}\n/**\n * JSDOC\n */\n\n\nfunction _walkErrorTree(parser, limit, error, key) {\n  var stack = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];\n\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n\n  var exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception].concat(_toConsumableArray(stack)));\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { logger } from '@sentry/utils';\n/** Deduplication filter */\n\nvar Dedupe = /*#__PURE__*/function () {\n  function Dedupe() {\n    _classCallCheck(this, Dedupe);\n\n    Dedupe.prototype.__init.call(this);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(Dedupe, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = Dedupe.id;\n    }\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce(addGlobalEventProcessor, getCurrentHub) {\n      var eventProcessor = function eventProcessor(currentEvent) {\n        var self = getCurrentHub().getIntegration(Dedupe);\n\n        if (self) {\n          // Juuust in case something goes wrong\n          try {\n            if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n              (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && 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\n        return currentEvent;\n      };\n\n      eventProcessor.id = this.name;\n      addGlobalEventProcessor(eventProcessor);\n    }\n  }], [{\n    key: \"__initStatic\",\n    value: function __initStatic() {\n      this.id = 'Dedupe';\n    }\n  }]);\n\n  return Dedupe;\n}();\n\nDedupe.__initStatic();\n/** JSDoc */\n\n\nfunction _shouldDropEvent(currentEvent, previousEvent) {\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/** JSDoc */\n\n\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  var currentMessage = currentEvent.message;\n  var previousMessage = previousEvent.message; // If neither event has a message property, they were both exceptions, so bail out\n\n  if (!currentMessage && !previousMessage) {\n    return false;\n  } // If only one event has a stacktrace, but not the other one, they are not the same\n\n\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/** JSDoc */\n\n\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  var previousException = _getExceptionFromEvent(previousEvent);\n\n  var 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/** JSDoc */\n\n\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  var currentFrames = _getFramesFromEvent(currentEvent);\n\n  var previousFrames = _getFramesFromEvent(previousEvent); // If neither event has a stacktrace, they are assumed to be the same\n\n\n  if (!currentFrames && !previousFrames) {\n    return true;\n  } // If only one event has a stacktrace, but not the other one, they are not the same\n\n\n  if (currentFrames && !previousFrames || !currentFrames && previousFrames) {\n    return false;\n  }\n\n  currentFrames = currentFrames;\n  previousFrames = previousFrames; // If number of frames differ, they are not the same\n\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  } // Otherwise, compare the two\n\n\n  for (var i = 0; i < previousFrames.length; i++) {\n    var frameA = previousFrames[i];\n    var frameB = currentFrames[i];\n\n    if (frameA.filename !== frameB.filename || frameA.lineno !== frameB.lineno || frameA.colno !== frameB.colno || frameA.function !== frameB.function) {\n      return false;\n    }\n  }\n\n  return true;\n}\n/** JSDoc */\n\n\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  var currentFingerprint = currentEvent.fingerprint;\n  var previousFingerprint = previousEvent.fingerprint; // If neither event has a fingerprint, they are assumed to be the same\n\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  } // If only one event has a fingerprint, but not the other one, they are not the same\n\n\n  if (currentFingerprint && !previousFingerprint || !currentFingerprint && previousFingerprint) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint;\n  previousFingerprint = previousFingerprint; // Otherwise, compare the two\n\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n/** JSDoc */\n\n\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n/** JSDoc */\n\n\nfunction _getFramesFromEvent(event) {\n  var 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\n  return undefined;\n}\n\nexport { Dedupe };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n/** HttpContext integration collects information about HTTP request headers */\n\nvar HttpContext = /*#__PURE__*/function () {\n  function HttpContext() {\n    _classCallCheck(this, HttpContext);\n\n    HttpContext.prototype.__init.call(this);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(HttpContext, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = HttpContext.id;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\n      addGlobalEventProcessor(function (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          } // grab as much info as exists and add it to the event\n\n\n          var url = event.request && event.request.url || WINDOW.location && WINDOW.location.href;\n\n          var _ref = WINDOW.document || {},\n              referrer = _ref.referrer;\n\n          var _ref2 = WINDOW.navigator || {},\n              userAgent = _ref2.userAgent;\n\n          var headers = _objectSpread(_objectSpread(_objectSpread({}, event.request && event.request.headers), referrer && {\n            Referer: referrer\n          }), userAgent && {\n            'User-Agent': userAgent\n          });\n\n          var request = _objectSpread(_objectSpread({}, url && {\n            url: url\n          }), {}, {\n            headers: headers\n          });\n\n          return _objectSpread(_objectSpread({}, event), {}, {\n            request: request\n          });\n        }\n\n        return event;\n      });\n    }\n  }], [{\n    key: \"__initStatic\",\n    value: function __initStatic() {\n      this.id = 'HttpContext';\n    }\n  }]);\n\n  return HttpContext;\n}();\n\nHttpContext.__initStatic();\n\nexport { HttpContext };","import { isNativeFetch, logger } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\nvar cachedFetchImpl = undefined;\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 */\n\nfunction getNativeFetchImplementation() {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n  /* eslint-disable @typescript-eslint/unbound-method */\n  // Fast path to avoid DOM I/O\n\n\n  if (isNativeFetch(WINDOW.fetch)) {\n    return cachedFetchImpl = WINDOW.fetch.bind(WINDOW);\n  }\n\n  var document = WINDOW.document;\n  var fetchImpl = WINDOW.fetch; // eslint-disable-next-line deprecation/deprecation\n\n  if (document && typeof document.createElement === 'function') {\n    try {\n      var sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      var contentWindow = sandbox.contentWindow;\n\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && 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/** Clears cached fetch impl */\n\n\nfunction clearCachedFetchImplementation() {\n  cachedFetchImpl = undefined;\n}\n\nexport { clearCachedFetchImplementation, getNativeFetchImplementation };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { createTransport } from '@sentry/core';\nimport { rejectedSyncPromise } from '@sentry/utils';\nimport { clearCachedFetchImplementation, getNativeFetchImplementation } from './utils.js';\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\n\nfunction makeFetchTransport(options) {\n  var nativeFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getNativeFetchImplementation();\n\n  function makeRequest(request) {\n    var requestOptions = _objectSpread({\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    try {\n      return nativeFetch(options.url, requestOptions).then(function (response) {\n        return {\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    } catch (e) {\n      clearCachedFetchImplementation();\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\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 */\n\nvar XHR_READYSTATE_DONE = 4;\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\n\nfunction makeXHRTransport(options) {\n  function makeRequest(request) {\n    return new SyncPromise(function (resolve, reject) {\n      var xhr = new XMLHttpRequest();\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = function () {\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 (var 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\nexport { makeXHRTransport };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { Integrations, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub } from '@sentry/core';\nimport { stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { WINDOW, wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\nvar defaultIntegrations = [new Integrations.InboundFilters(), new Integrations.FunctionToString(), new TryCatch(), new Breadcrumbs(), new GlobalHandlers(), new LinkedErrors(), new Dedupe(), new HttpContext()];\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 */\n\nfunction init() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\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\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  var clientOptions = _objectSpread(_objectSpread({}, 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 * 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 */\n\n\nfunction showReportDialog() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var hub = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getCurrentHub();\n\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  var _hub$getStackTop = hub.getStackTop(),\n      client = _hub$getStackTop.client,\n      scope = _hub$getStackTop.scope;\n\n  var dsn = options.dsn || client && client.getDsn();\n\n  if (!dsn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = _objectSpread(_objectSpread({}, scope.getUser()), options.user);\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  var 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  var injectionPoint = WINDOW.document.head || WINDOW.document.body;\n\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\n\n\nfunction lastEventId() {\n  return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\n\n\nfunction forceLoad() {// Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\n\n\nfunction onLoad(callback) {\n  callback();\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 */\n\n\nfunction flush(timeout) {\n  var client = getCurrentHub().getClient();\n\n  if (client) {\n    return client.flush(timeout);\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\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 */\n\n\nfunction close(timeout) {\n  var client = getCurrentHub().getClient();\n\n  if (client) {\n    return client.close(timeout);\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\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\n\n\nfunction wrap(fn) {\n  return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n  hub.startSession({\n    ignoreDuration: true\n  });\n  hub.captureSession();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\n\n\nfunction startSessionTracking() {\n  if (typeof WINDOW.document === 'undefined') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  var hub = getCurrentHub(); // 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\n  if (!hub.captureSession) {\n    return;\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\n\n  startSessionOnHub(hub); // We want to create a session for every navigation as well\n\n  addInstrumentationHandler('history', function (_ref) {\n    var from = _ref.from,\n        to = _ref.to;\n\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\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { isString } from './is.js';\nimport { logger } from './logger.js';\nvar BAGGAGE_HEADER_NAME = 'baggage';\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\nvar SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\n\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\n\nfunction baggageHeaderToDynamicSamplingContext( // Very liberal definition of what any incoming header might look like\nbaggageHeader) {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  } // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n\n\n  var baggageObject = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce(function (acc, curr) {\n      var currBaggageObject = baggageHeaderToObject(curr);\n      return _objectSpread(_objectSpread({}, acc), currBaggageObject);\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  } // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n\n\n  var dynamicSamplingContext = Object.entries(baggageObject).reduce(function (acc, _ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        key = _ref2[0],\n        value = _ref2[1];\n\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      var nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n\n    return acc;\n  }, {}); // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext;\n  } else {\n    return undefined;\n  }\n}\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\n\n\nfunction dynamicSamplingContextToSentryBaggageHeader( // this also takes undefined for convenience and bundle size in other places\ndynamicSamplingContext) {\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  var sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(function (acc, _ref3) {\n    var _ref4 = _slicedToArray(_ref3, 2),\n        dscKey = _ref4[0],\n        dscValue = _ref4[1];\n\n    if (dscValue) {\n      acc[\"\".concat(SENTRY_BAGGAGE_KEY_PREFIX).concat(dscKey)] = dscValue;\n    }\n\n    return acc;\n  }, {});\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\n\n\nfunction baggageHeaderToObject(baggageHeader) {\n  return baggageHeader.split(',').map(function (baggageEntry) {\n    return baggageEntry.split('=').map(function (keyOrValue) {\n      return decodeURIComponent(keyOrValue.trim());\n    });\n  }).reduce(function (acc, _ref5) {\n    var _ref6 = _slicedToArray(_ref5, 2),\n        key = _ref6[0],\n        value = _ref6[1];\n\n    acc[key] = value;\n    return acc;\n  }, {});\n}\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\n\n\nfunction objectToBaggageHeader(object) {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce(function (baggageHeader, _ref7, currentIndex) {\n    var _ref8 = _slicedToArray(_ref7, 2),\n        objectKey = _ref8[0],\n        objectValue = _ref8[1];\n\n    var baggageEntry = \"\".concat(encodeURIComponent(objectKey), \"=\").concat(encodeURIComponent(objectValue));\n    var newBaggageHeader = currentIndex === 0 ? baggageEntry : \"\".concat(baggageHeader, \",\").concat(baggageEntry);\n\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Not adding key: \".concat(objectKey, \" with val: \").concat(objectValue, \" to baggage header due to exceeding baggage size limits.\"));\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader };","import { GLOBAL_OBJ } from '@sentry/utils';\nvar WINDOW = GLOBAL_OBJ;\nexport { WINDOW };","var bindReporter = function bindReporter(callback, metric, reportAllChanges) {\n  var prevValue;\n  var delta;\n  return function (forceReport) {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0); // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };","import { WINDOW } from '../../types.js';\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar getNavigationEntryFromPerformanceTiming = function getNavigationEntryFromPerformanceTiming() {\n  // eslint-disable-next-line deprecation/deprecation\n  var timing = WINDOW.performance.timing; // eslint-disable-next-line deprecation/deprecation\n\n  var type = WINDOW.performance.navigation.type;\n  var navigationEntry = {\n    entryType: 'navigation',\n    startTime: 0,\n    type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate'\n  };\n\n  for (var key in timing) {\n    if (key !== 'navigationStart' && key !== 'toJSON') {\n      navigationEntry[key] = Math.max(timing[key] - timing.navigationStart, 0);\n    }\n  }\n\n  return navigationEntry;\n};\n\nvar getNavigationEntry = function getNavigationEntry() {\n  if (WINDOW.__WEB_VITALS_POLYFILL__) {\n    return WINDOW.performance && (performance.getEntriesByType && performance.getEntriesByType('navigation')[0] || getNavigationEntryFromPerformanceTiming());\n  } else {\n    return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];\n  }\n};\n\nexport { getNavigationEntry };","import { getNavigationEntry } from './getNavigationEntry.js';\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar getActivationStart = function getActivationStart() {\n  var navEntry = getNavigationEntry();\n  return navEntry && navEntry.activationStart || 0;\n};\n\nexport { getActivationStart };","import { WINDOW } from '../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar initMetric = function initMetric(name, value) {\n  var navEntry = getNavigationEntry();\n  var navigationType = 'navigate';\n\n  if (navEntry) {\n    if (WINDOW.document.prerendering || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else {\n      navigationType = navEntry.type.replace(/_/g, '-');\n    }\n  }\n\n  return {\n    name: name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good',\n    // Will be updated if the value changes.\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n    navigationType: navigationType\n  };\n};\n\nexport { initMetric };","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nvar generateUniqueID = function generateUniqueID() {\n  return \"v3-\".concat(Date.now(), \"-\").concat(Math.floor(Math.random() * (9e12 - 1)) + 1e12);\n};\n\nexport { generateUniqueID };","/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nvar observe = function observe(type, callback, opts) {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      var po = new PerformanceObserver(function (list) {\n        callback(list.getEntries());\n      });\n      po.observe(Object.assign({\n        type: type,\n        buffered: true\n      }, opts || {}));\n      return po;\n    }\n  } catch (e) {// Do nothing.\n  }\n\n  return;\n};\n\nexport { observe };","import { WINDOW } from '../../types.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar onHidden = function onHidden(cb, once) {\n  var onHiddenOrPageHide = function onHiddenOrPageHide(event) {\n    if (event.type === 'pagehide' || WINDOW.document.visibilityState === 'hidden') {\n      cb(event);\n\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n\n  addEventListener('visibilitychange', onHiddenOrPageHide, true); // Some browsers have buggy implementations of visibilitychange,\n  // so we use pagehide in addition, just to be safe.\n\n  addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n\nexport { onHidden };","import { WINDOW } from '../../types.js';\nimport { onHidden } from './onHidden.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar firstHiddenTime = -1;\n\nvar initHiddenTime = function initHiddenTime() {\n  // If the document is hidden and not prerendering, assume it was always\n  // hidden and the page was loaded in the background.\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nvar trackChanges = function trackChanges() {\n  // Update the time if/when the document becomes hidden.\n  onHidden(function (_ref) {\n    var timeStamp = _ref.timeStamp;\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nvar getVisibilityWatcher = function getVisibilityWatcher() {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    trackChanges();\n  }\n\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    }\n\n  };\n};\n\nexport { getVisibilityWatcher };","import { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar reportedMetricIDs = {};\n/**\n * Calculates the [LCP](https://web.dev/lcp/) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called any time a new `largest-contentful-paint`\n * performance entry is dispatched, or once the final value of the metric has\n * been determined.\n */\n\nvar onLCP = function onLCP(onReport) {\n  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var visibilityWatcher = getVisibilityWatcher();\n  var metric = initMetric('LCP');\n  var report;\n\n  var handleEntries = function handleEntries(entries) {\n    var lastEntry = entries[entries.length - 1];\n\n    if (lastEntry) {\n      // The startTime attribute returns the value of the renderTime if it is\n      // not 0, and the value of the loadTime otherwise. The activationStart\n      // reference is used because LCP should be relative to page activation\n      // rather than navigation start if the page was prerendered.\n      var value = Math.max(lastEntry.startTime - getActivationStart(), 0); // Only report if the page wasn't hidden prior to LCP.\n\n      if (value < visibilityWatcher.firstHiddenTime) {\n        metric.value = value;\n        metric.entries = [lastEntry];\n        report();\n      }\n    }\n  };\n\n  var po = observe('largest-contentful-paint', handleEntries);\n\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n    var stopListening = function stopListening() {\n      if (!reportedMetricIDs[metric.id]) {\n        handleEntries(po.takeRecords());\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    }; // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n\n\n    ['keydown', 'click'].forEach(function (type) {\n      addEventListener(type, stopListening, {\n        once: true,\n        capture: true\n      });\n    });\n    onHidden(stopListening, true);\n  }\n};\n\nexport { onLCP };","var _excluded = [\"startTimestamp\"];\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\n\n\nfunction _startChild(transaction, _ref) {\n  var startTimestamp = _ref.startTimestamp,\n      ctx = _objectWithoutProperties(_ref, _excluded);\n\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild(_objectSpread({\n    startTimestamp: startTimestamp\n  }, ctx));\n}\n\nexport { _startChild, isMeasurementValue };","function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';\nimport { getActiveTransaction, msToSec } from '../../utils.js';\nimport { WINDOW } from '../types.js';\nimport { onCLS } from '../web-vitals/getCLS.js';\nimport { onFID } from '../web-vitals/getFID.js';\nimport { onLCP } from '../web-vitals/getLCP.js';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher.js';\nimport { observe } from '../web-vitals/lib/observe.js';\nimport { _startChild, isMeasurementValue } from './utils.js';\n\nfunction getBrowserPerformanceAPI() {\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\nvar _performanceCursor = 0;\nvar _measurements = {};\n\nvar _lcpEntry;\n\nvar _clsEntry;\n/**\n * Start tracking web vitals\n */\n\n\nfunction startTrackingWebVitals() {\n  var reportAllChanges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n  var performance = getBrowserPerformanceAPI();\n\n  if (performance && browserPerformanceTimeOrigin) {\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n\n    _trackCLS();\n\n    _trackLCP(reportAllChanges);\n\n    _trackFID();\n  }\n}\n/**\n * Start tracking long tasks.\n */\n\n\nfunction startTrackingLongTasks() {\n  var entryHandler = function entryHandler(entries) {\n    var _iterator = _createForOfIteratorHelper(entries),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var entry = _step.value;\n        var transaction = getActiveTransaction();\n\n        if (!transaction) {\n          return;\n        }\n\n        var startTime = msToSec(browserPerformanceTimeOrigin + entry.startTime);\n        var duration = msToSec(entry.duration);\n        transaction.startChild({\n          description: 'Main UI thread blocked',\n          op: 'ui.long-task',\n          startTimestamp: startTime,\n          endTimestamp: startTime + duration\n        });\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  };\n\n  observe('longtask', entryHandler);\n}\n/** Starts tracking the Cumulative Layout Shift on the current page. */\n\n\nfunction _trackCLS() {\n  // See:\n  // https://web.dev/evolving-cls/\n  // https://web.dev/cls-web-tooling/\n  onCLS(function (metric) {\n    var entry = metric.entries.pop();\n\n    if (!entry) {\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS');\n    _measurements['cls'] = {\n      value: metric.value,\n      unit: ''\n    };\n    _clsEntry = entry;\n  });\n}\n/** Starts tracking the Largest Contentful Paint on the current page. */\n\n\nfunction _trackLCP(reportAllChanges) {\n  onLCP(function (metric) {\n    var entry = metric.entries.pop();\n\n    if (!entry) {\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP');\n    _measurements['lcp'] = {\n      value: metric.value,\n      unit: 'millisecond'\n    };\n    _lcpEntry = entry;\n  }, {\n    reportAllChanges: reportAllChanges\n  });\n}\n/** Starts tracking the First Input Delay on the current page. */\n\n\nfunction _trackFID() {\n  onFID(function (metric) {\n    var entry = metric.entries.pop();\n\n    if (!entry) {\n      return;\n    }\n\n    var timeOrigin = msToSec(browserPerformanceTimeOrigin);\n    var startTime = msToSec(entry.startTime);\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FID');\n    _measurements['fid'] = {\n      value: metric.value,\n      unit: 'millisecond'\n    };\n    _measurements['mark.fid'] = {\n      value: timeOrigin + startTime,\n      unit: 'second'\n    };\n  });\n}\n/** Add performance related spans to a transaction */\n\n\nfunction addPerformanceEntries(transaction) {\n  var performance = getBrowserPerformanceAPI();\n\n  if (!performance || !WINDOW.performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n  var timeOrigin = msToSec(browserPerformanceTimeOrigin);\n  var performanceEntries = performance.getEntries();\n  var responseStartTimestamp;\n  var requestStartTimestamp; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  performanceEntries.slice(_performanceCursor).forEach(function (entry) {\n    var startTime = msToSec(entry.startTime);\n    var duration = msToSec(entry.duration);\n\n    if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation':\n        {\n          _addNavigationSpans(transaction, entry, timeOrigin);\n\n          responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);\n          requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);\n          break;\n        }\n\n      case 'mark':\n      case 'paint':\n      case 'measure':\n        {\n          _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin); // capture web vitals\n\n\n          var firstHidden = getVisibilityWatcher(); // Only report if the page wasn't hidden prior to the web vital.\n\n          var shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n          if (entry.name === 'first-paint' && shouldRecord) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FP');\n            _measurements['fp'] = {\n              value: entry.startTime,\n              unit: 'millisecond'\n            };\n          }\n\n          if (entry.name === 'first-contentful-paint' && shouldRecord) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FCP');\n            _measurements['fcp'] = {\n              value: entry.startTime,\n              unit: 'millisecond'\n            };\n          }\n\n          break;\n        }\n\n      case 'resource':\n        {\n          var resourceName = entry.name.replace(WINDOW.location.origin, '');\n\n          _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n\n          break;\n        }\n\n      default: // Ignore other entry types.\n\n    }\n  });\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(transaction); // Measurements are only available for pageload transactions\n\n\n  if (transaction.op === 'pageload') {\n    // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n    // start of the response in milliseconds\n    if (typeof responseStartTimestamp === 'number') {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding TTFB');\n      _measurements['ttfb'] = {\n        value: (responseStartTimestamp - transaction.startTimestamp) * 1000,\n        unit: 'millisecond'\n      };\n\n      if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n        // Capture the time spent making the request and receiving the first byte of the response.\n        // This is the time between the start of the request and the start of the response in milliseconds.\n        _measurements['ttfb.requestTime'] = {\n          value: (responseStartTimestamp - requestStartTimestamp) * 1000,\n          unit: 'millisecond'\n        };\n      }\n    }\n\n    ['fcp', 'fp', 'lcp'].forEach(function (name) {\n      if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {\n        return;\n      } // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n      // to be adjusted to be relative to transaction.startTimestamp.\n\n\n      var oldValue = _measurements[name].value;\n      var measurementTimestamp = timeOrigin + msToSec(oldValue); // normalizedValue should be in milliseconds\n\n      var normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n      var delta = normalizedValue - oldValue;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Measurements] Normalized \".concat(name, \" from \").concat(oldValue, \" to \").concat(normalizedValue, \" (\").concat(delta, \")\"));\n      _measurements[name].value = normalizedValue;\n    });\n    var fidMark = _measurements['mark.fid'];\n\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      _startChild(transaction, {\n        description: 'first input delay',\n        endTimestamp: fidMark.value + msToSec(_measurements['fid'].value),\n        op: 'ui.action',\n        startTimestamp: fidMark.value\n      }); // Delete mark.fid as we don't want it to be part of final payload\n\n\n      delete _measurements['mark.fid'];\n    } // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n\n\n    if (!('fcp' in _measurements)) {\n      delete _measurements.cls;\n    }\n\n    Object.keys(_measurements).forEach(function (measurementName) {\n      transaction.setMeasurement(measurementName, _measurements[measurementName].value, _measurements[measurementName].unit);\n    });\n\n    _tagMetricInfo(transaction);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n/** Create measure related spans */\n\n\nfunction _addMeasureSpans(transaction, // eslint-disable-next-line @typescript-eslint/no-explicit-any\nentry, startTime, duration, timeOrigin) {\n  var measureStartTimestamp = timeOrigin + startTime;\n  var measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType,\n    startTimestamp: measureStartTimestamp\n  });\n\n  return measureStartTimestamp;\n}\n/** Instrument navigation entries */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _addNavigationSpans(transaction, entry, timeOrigin) {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(function (event) {\n    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n\n  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n\n  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n\n  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n\n  _addRequest(transaction, entry, timeOrigin);\n}\n/** Create performance navigation related spans */\n\n\nfunction _addPerformanceNavigationTiming(transaction, // eslint-disable-next-line @typescript-eslint/no-explicit-any\nentry, event, timeOrigin, description, eventEnd) {\n  var end = eventEnd ? entry[eventEnd] : entry[\"\".concat(event, \"End\")];\n  var start = entry[\"\".concat(event, \"Start\")];\n\n  if (!start || !end) {\n    return;\n  }\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: _nullishCoalesce(description, function () {\n      return event;\n    }),\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end)\n  });\n}\n/** Create request and response related spans */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction _addRequest(transaction, entry, timeOrigin) {\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'request',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd)\n  });\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'response',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd)\n  });\n}\n/** Create resource-related spans */\n\n\nfunction _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n  var data = {};\n\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  var startTimestamp = timeOrigin + startTime;\n  var endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp: endTimestamp,\n    op: entry.initiatorType ? \"resource.\".concat(entry.initiatorType) : 'resource.other',\n    startTimestamp: startTimestamp,\n    data: data\n  });\n}\n/**\n * Capture the information of the user agent.\n */\n\n\nfunction _trackNavigator(transaction) {\n  var navigator = WINDOW.navigator;\n\n  if (!navigator) {\n    return;\n  } // track network connectivity\n\n\n  var connection = navigator.connection;\n\n  if (connection) {\n    if (connection.effectiveType) {\n      transaction.setTag('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      transaction.setTag('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = {\n        value: connection.rtt,\n        unit: 'millisecond'\n      };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    transaction.setTag('deviceMemory', \"\".concat(navigator.deviceMemory, \" GB\"));\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n/** Add LCP / CLS data to transaction to allow debugging */\n\n\nfunction _tagMetricInfo(transaction) {\n  if (_lcpEntry) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP Data'); // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      transaction.setTag('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    transaction.setTag('lcp.size', _lcpEntry.size);\n  } // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n\n\n  if (_clsEntry && _clsEntry.sources) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS Data');\n\n    _clsEntry.sources.forEach(function (source, index) {\n      return transaction.setTag(\"cls.source.\".concat(index + 1), htmlTreeAsString(source.node));\n    });\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingLongTasks, startTrackingWebVitals };","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Calculates the [CLS](https://web.dev/cls/) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/cls/#layout-shift-score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\n\nvar onCLS = function onCLS(onReport) {\n  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var metric = initMetric('CLS', 0);\n  var report;\n  var sessionValue = 0;\n  var sessionEntries = []; // const handleEntries = (entries: Metric['entries']) => {\n\n  var handleEntries = function handleEntries(entries) {\n    entries.forEach(function (entry) {\n      // Only count layout shifts without recent user input.\n      if (!entry.hadRecentInput) {\n        var firstSessionEntry = sessionEntries[0];\n        var lastSessionEntry = sessionEntries[sessionEntries.length - 1]; // If the entry occurred less than 1 second after the previous entry and\n        // less than 5 seconds after the first entry in the session, include the\n        // entry in the current session. Otherwise, start a new session.\n\n        if (sessionValue && sessionEntries.length !== 0 && entry.startTime - lastSessionEntry.startTime < 1000 && entry.startTime - firstSessionEntry.startTime < 5000) {\n          sessionValue += entry.value;\n          sessionEntries.push(entry);\n        } else {\n          sessionValue = entry.value;\n          sessionEntries = [entry];\n        } // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n\n\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n\n          if (report) {\n            report();\n          }\n        }\n      }\n    });\n  };\n\n  var po = observe('layout-shift', handleEntries);\n\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n    onHidden(function () {\n      handleEntries(po.takeRecords());\n      report(true);\n    });\n  }\n};\n\nexport { onCLS };","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Calculates the [FID](https://web.dev/fid/) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\n\nvar onFID = function onFID(onReport) {\n  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var visibilityWatcher = getVisibilityWatcher();\n  var metric = initMetric('FID'); // eslint-disable-next-line prefer-const\n\n  var report;\n\n  var handleEntry = function handleEntry(entry) {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  var handleEntries = function handleEntries(entries) {\n    entries.forEach(handleEntry);\n  };\n\n  var po = observe('first-input', handleEntries);\n  report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n  if (po) {\n    onHidden(function () {\n      handleEntries(po.takeRecords());\n      po.disconnect();\n    }, true);\n  }\n};\n\nexport { onFID };","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { addInstrumentationHandler, stringMatchesSomePattern, dynamicSamplingContextToSentryBaggageHeader, isInstanceOf, BAGGAGE_HEADER_NAME } from '@sentry/utils';\nimport { hasTracingEnabled, getActiveTransaction } from '../utils.js';\nvar DEFAULT_TRACE_PROPAGATION_TARGETS = ['localhost', /^\\//];\n/** Options for Request Instrumentation */\n\nvar defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  // TODO (v8): Remove this property\n  tracingOrigins: DEFAULT_TRACE_PROPAGATION_TARGETS,\n  tracePropagationTargets: DEFAULT_TRACE_PROPAGATION_TARGETS\n};\n/** Registers span creators for xhr and fetch requests  */\n\nfunction instrumentOutgoingRequests(_options) {\n  // eslint-disable-next-line deprecation/deprecation\n  var _traceFetch$traceXHR$ = _objectSpread({\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR\n  }, _options),\n      traceFetch = _traceFetch$traceXHR$.traceFetch,\n      traceXHR = _traceFetch$traceXHR$.traceXHR,\n      tracingOrigins = _traceFetch$traceXHR$.tracingOrigins,\n      tracePropagationTargets = _traceFetch$traceXHR$.tracePropagationTargets,\n      shouldCreateSpanForRequest = _traceFetch$traceXHR$.shouldCreateSpanForRequest;\n\n  var shouldCreateSpan = typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : function (_) {\n    return true;\n  };\n\n  var shouldAttachHeadersWithTargets = function shouldAttachHeadersWithTargets(url) {\n    return shouldAttachHeaders(url, tracingOrigins, tracePropagationTargets);\n  };\n\n  var spans = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', function (handlerData) {\n      fetchCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', function (handlerData) {\n      xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n    });\n  }\n}\n/**\n * A function that determines whether to attach tracing headers to a request.\n * This was extracted from `instrumentOutgoingRequests` to make it easier to test shouldAttachHeaders.\n * We only export this fuction for testing purposes.\n *\n * TODO (v8): Remove `tracingOrigins` which should drastically simplify this function.\n */\n\n\nfunction shouldAttachHeaders(url, tracePropagationTargets, tracingOrigins) {\n  // TODO (v8): Replace the entire code below with this one-liner:\n  // return stringMatchesSomePattern(url, tracePropagationTargets || DEFAULT_TRACE_PROPAGATION_TARGETS);\n  if (tracePropagationTargets || tracingOrigins) {\n    return stringMatchesSomePattern(url, tracePropagationTargets || tracingOrigins);\n  }\n\n  return stringMatchesSomePattern(url, DEFAULT_TRACE_PROPAGATION_TARGETS);\n}\n/**\n * Create and track fetch request spans\n */\n\n\nfunction fetchCallback(handlerData, shouldCreateSpan, shouldAttachHeaders, spans) {\n  if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp) {\n    var spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n    var span = spans[spanId];\n\n    if (span) {\n      if (handlerData.response) {\n        // TODO (kmclb) remove this once types PR goes through\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        span.setHttpStatus(handlerData.response.status);\n      } else if (handlerData.error) {\n        span.setStatus('internal_error');\n      }\n\n      span.finish(); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n      delete spans[spanId];\n    }\n\n    return;\n  }\n\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    var _span = activeTransaction.startChild({\n      data: _objectSpread(_objectSpread({}, handlerData.fetchData), {}, {\n        type: 'fetch'\n      }),\n      description: \"\".concat(handlerData.fetchData.method, \" \").concat(handlerData.fetchData.url),\n      op: 'http.client'\n    });\n\n    handlerData.fetchData.__span = _span.spanId;\n    spans[_span.spanId] = _span;\n    var request = handlerData.args[0]; // In case the user hasn't set the second argument of a fetch call we default it to `{}`.\n\n    handlerData.args[1] = handlerData.args[1] || {}; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n    var options = handlerData.args[1];\n\n    if (shouldAttachHeaders(handlerData.fetchData.url)) {\n      options.headers = addTracingHeadersToFetchRequest(request, activeTransaction.getDynamicSamplingContext(), _span, options);\n      activeTransaction.metadata.propagations += 1;\n    }\n  }\n}\n\nfunction addTracingHeadersToFetchRequest(request, dynamicSamplingContext, span, options) {\n  var sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n  var sentryTraceHeader = span.toTraceparent();\n  var headers = typeof Request !== 'undefined' && isInstanceOf(request, Request) ? request.headers : options.headers;\n\n  if (!headers) {\n    return {\n      'sentry-trace': sentryTraceHeader,\n      baggage: sentryBaggageHeader\n    };\n  } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {\n    var newHeaders = new Headers(headers);\n    newHeaders.append('sentry-trace', sentryTraceHeader);\n\n    if (sentryBaggageHeader) {\n      // If the same header is appended miultiple times the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.append(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n    }\n\n    return newHeaders;\n  } else if (Array.isArray(headers)) {\n    var _newHeaders = [].concat(_toConsumableArray(headers), [['sentry-trace', sentryTraceHeader]]);\n\n    if (sentryBaggageHeader) {\n      // If there are multiple entries with the same key, the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      _newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);\n    }\n\n    return _newHeaders;\n  } else {\n    var existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    var newBaggageHeaders = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders.push.apply(newBaggageHeaders, _toConsumableArray(existingBaggageHeader));\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(existingBaggageHeader);\n    }\n\n    if (sentryBaggageHeader) {\n      newBaggageHeaders.push(sentryBaggageHeader);\n    }\n\n    return _objectSpread(_objectSpread({}, headers), {}, {\n      'sentry-trace': sentryTraceHeader,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined\n    });\n  }\n}\n/**\n * Create and track xhr request spans\n */\n\n\nfunction xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeaders, spans) {\n  if (!hasTracingEnabled() || handlerData.xhr && handlerData.xhr.__sentry_own_request__ || !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))) {\n    return;\n  }\n\n  var xhr = handlerData.xhr.__sentry_xhr__; // check first if the request has finished and is tracked by an existing span which should now end\n\n  if (handlerData.endTimestamp) {\n    var spanId = handlerData.xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n    var span = spans[spanId];\n\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish(); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n      delete spans[spanId];\n    }\n\n    return;\n  } // if not, create a new span to track it\n\n\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    var _span2 = activeTransaction.startChild({\n      data: _objectSpread(_objectSpread({}, xhr.data), {}, {\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url\n      }),\n      description: \"\".concat(xhr.method, \" \").concat(xhr.url),\n      op: 'http.client'\n    });\n\n    handlerData.xhr.__sentry_xhr_span_id__ = _span2.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = _span2;\n\n    if (handlerData.xhr.setRequestHeader && shouldAttachHeaders(handlerData.xhr.__sentry_xhr__.url)) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', _span2.toTraceparent());\n        var dynamicSamplingContext = activeTransaction.getDynamicSamplingContext();\n        var sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n\n        if (sentryBaggageHeader) {\n          // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n          // We can therefore simply set a baggage header without checking what was there before\n          // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n          handlerData.xhr.setRequestHeader(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n        }\n\n        activeTransaction.metadata.propagations += 1;\n      } catch (_) {// Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}\n\nexport { DEFAULT_TRACE_PROPAGATION_TARGETS, defaultRequestInstrumentationOptions, fetchCallback, instrumentOutgoingRequests, shouldAttachHeaders, xhrCallback };","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { _optionalChain } from '@sentry/utils/esm/buildPolyfills';\nimport { logger, extractTraceparentData, baggageHeaderToDynamicSamplingContext, getDomElement } from '@sentry/utils';\nimport { startIdleTransaction } from '../hubextensions.js';\nimport { DEFAULT_IDLE_TIMEOUT, DEFAULT_FINAL_TIMEOUT, DEFAULT_HEARTBEAT_INTERVAL } from '../idletransaction.js';\nimport '../utils.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { startTrackingWebVitals, startTrackingLongTasks, addPerformanceEntries } from './metrics/index.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\nimport { instrumentRoutingWithDefaults } from './router.js';\nimport { WINDOW } from './types.js';\nvar BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n/** Options for Browser Tracing integration */\n\nvar DEFAULT_BROWSER_TRACING_OPTIONS = _objectSpread({\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  finalTimeout: DEFAULT_FINAL_TIMEOUT,\n  heartbeatInterval: DEFAULT_HEARTBEAT_INTERVAL,\n  markBackgroundTransactions: true,\n  routingInstrumentation: instrumentRoutingWithDefaults,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true,\n  _experiments: {\n    enableLongTask: true\n  }\n}, defaultRequestInstrumentationOptions);\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\n\n\nvar BrowserTracing = /*#__PURE__*/function () {\n  function BrowserTracing(_options) {\n    _classCallCheck(this, BrowserTracing);\n\n    ;\n\n    BrowserTracing.prototype.__init.call(this);\n\n    this.options = _objectSpread(_objectSpread({}, DEFAULT_BROWSER_TRACING_OPTIONS), _options);\n    var _metricOptions = this.options._metricOptions;\n    startTrackingWebVitals(_metricOptions && _metricOptions._reportAllChanges);\n\n    if (_optionalChain([this, 'access', function (_2) {\n      return _2.options;\n    }, 'access', function (_3) {\n      return _3._experiments;\n    }, 'optionalAccess', function (_4) {\n      return _4.enableLongTask;\n    }])) {\n      startTrackingLongTasks();\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(BrowserTracing, [{\n    key: \"__init\",\n    value: // This class currently doesn't have a static `id` field like the other integration classes, because it prevented\n    // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.\n    // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all\n    // integrations.\n\n    /** Browser Tracing integration options */\n\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = BROWSER_TRACING_INTEGRATION_ID;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce(_, getCurrentHub) {\n      var _this = this;\n\n      this._getCurrentHub = getCurrentHub; // eslint-disable-next-line @typescript-eslint/unbound-method\n\n      var _this$options = this.options,\n          instrumentRouting = _this$options.routingInstrumentation,\n          startTransactionOnLocationChange = _this$options.startTransactionOnLocationChange,\n          startTransactionOnPageLoad = _this$options.startTransactionOnPageLoad,\n          markBackgroundTransactions = _this$options.markBackgroundTransactions,\n          traceFetch = _this$options.traceFetch,\n          traceXHR = _this$options.traceXHR,\n          tracingOrigins = _this$options.tracingOrigins,\n          shouldCreateSpanForRequest = _this$options.shouldCreateSpanForRequest;\n      instrumentRouting(function (context) {\n        return _this._createRouteTransaction(context);\n      }, startTransactionOnPageLoad, startTransactionOnLocationChange);\n\n      if (markBackgroundTransactions) {\n        registerBackgroundTabDetection();\n      }\n\n      instrumentOutgoingRequests({\n        traceFetch: traceFetch,\n        traceXHR: traceXHR,\n        tracingOrigins: tracingOrigins,\n        shouldCreateSpanForRequest: shouldCreateSpanForRequest\n      });\n    }\n    /** Create routing idle transaction. */\n\n  }, {\n    key: \"_createRouteTransaction\",\n    value: function _createRouteTransaction(context) {\n      var _this2 = this;\n\n      if (!this._getCurrentHub) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"[Tracing] Did not create \".concat(context.op, \" transaction because _getCurrentHub is invalid.\"));\n        return undefined;\n      } // eslint-disable-next-line @typescript-eslint/unbound-method\n\n\n      var _this$options2 = this.options,\n          beforeNavigate = _this$options2.beforeNavigate,\n          idleTimeout = _this$options2.idleTimeout,\n          finalTimeout = _this$options2.finalTimeout,\n          heartbeatInterval = _this$options2.heartbeatInterval;\n      var isPageloadTransaction = context.op === 'pageload';\n      var sentryTraceMetaTagValue = isPageloadTransaction ? getMetaContent('sentry-trace') : null;\n      var baggageMetaTagValue = isPageloadTransaction ? getMetaContent('baggage') : null;\n      var traceParentData = sentryTraceMetaTagValue ? extractTraceparentData(sentryTraceMetaTagValue) : undefined;\n      var dynamicSamplingContext = baggageMetaTagValue ? baggageHeaderToDynamicSamplingContext(baggageMetaTagValue) : undefined;\n\n      var expandedContext = _objectSpread(_objectSpread(_objectSpread({}, context), traceParentData), {}, {\n        metadata: _objectSpread(_objectSpread({}, context.metadata), {}, {\n          dynamicSamplingContext: traceParentData && !dynamicSamplingContext ? {} : dynamicSamplingContext\n        }),\n        trimEnd: true\n      });\n\n      var modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext; // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n      // from being sent to Sentry).\n\n      var finalContext = modifiedContext === undefined ? _objectSpread(_objectSpread({}, expandedContext), {}, {\n        sampled: false\n      }) : modifiedContext; // If `beforeNavigate` set a custom name, record that fact\n\n      finalContext.metadata = finalContext.name !== expandedContext.name ? _objectSpread(_objectSpread({}, finalContext.metadata), {}, {\n        source: 'custom'\n      }) : finalContext.metadata;\n\n      if (finalContext.sampled === false) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Will not send \".concat(finalContext.op, \" transaction because of beforeNavigate.\"));\n      }\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Starting \".concat(finalContext.op, \" transaction on scope\"));\n\n      var hub = this._getCurrentHub();\n\n      var location = WINDOW.location;\n      var idleTransaction = startIdleTransaction(hub, finalContext, idleTimeout, finalTimeout, true, {\n        location: location\n      }, // for use in the tracesSampler\n      heartbeatInterval);\n      idleTransaction.registerBeforeFinishCallback(function (transaction) {\n        addPerformanceEntries(transaction);\n        transaction.setTag('sentry_reportAllChanges', Boolean(_this2.options._metricOptions && _this2.options._metricOptions._reportAllChanges));\n      });\n      return idleTransaction;\n    }\n  }]);\n\n  return BrowserTracing;\n}();\n/** Returns the value of a meta tag */\n\n\nfunction getMetaContent(metaName) {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  var metaTag = getDomElement(\"meta[name=\".concat(metaName, \"]\")); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n  return metaTag ? metaTag.getAttribute('content') : null;\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, getMetaContent };","import { logger, addInstrumentationHandler } from '@sentry/utils';\nimport { WINDOW } from './types.js';\n/**\n * Default function implementing pageload and navigation transactions\n */\n\nfunction instrumentRoutingWithDefaults(customStartTransaction) {\n  var startTransactionOnPageLoad = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n  var startTransactionOnLocationChange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n  if (!WINDOW || !WINDOW.location) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  var startingUrl = WINDOW.location.href;\n  var activeTransaction;\n\n  if (startTransactionOnPageLoad) {\n    activeTransaction = customStartTransaction({\n      name: WINDOW.location.pathname,\n      op: 'pageload',\n      metadata: {\n        source: 'url'\n      }\n    });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler('history', function (_ref) {\n      var to = _ref.to,\n          from = _ref.from;\n\n      /**\n       * This early return is there to account for some cases where a navigation transaction starts right after\n       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n       * create an uneccessary navigation transaction.\n       *\n       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n       * only be caused in certain development environments where the usage of a hot module reloader is causing\n       * errors.\n       */\n      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n        startingUrl = undefined;\n        return;\n      }\n\n      if (from !== to) {\n        startingUrl = undefined;\n\n        if (activeTransaction) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Finishing current transaction with op: \".concat(activeTransaction.op)); // If there's an open transaction on the scope, we need to finish it before creating an new one.\n\n          activeTransaction.finish();\n        }\n\n        activeTransaction = customStartTransaction({\n          name: WINDOW.location.pathname,\n          op: 'navigation',\n          metadata: {\n            source: 'url'\n          }\n        });\n      }\n    });\n  }\n}\n\nexport { instrumentRoutingWithDefaults };","import { logger } from '@sentry/utils';\nimport { getActiveTransaction } from '../utils.js';\nimport { WINDOW } from './types.js';\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\n\nfunction registerBackgroundTabDetection() {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', function () {\n      var activeTransaction = getActiveTransaction();\n\n      if (WINDOW.document.hidden && activeTransaction) {\n        var statusType = 'cancelled';\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Transaction: \".concat(statusType, \" -> since tab moved to the background, op: \").concat(activeTransaction.op)); // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(statusType);\n        }\n\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { CONSOLE_LEVELS, GLOBAL_OBJ, fill, severityLevelFromString, safeJoin } from '@sentry/utils';\n/** Send Console API calls as Sentry Events */\n\nvar CaptureConsole = /*#__PURE__*/function () {\n  /**\n   * @inheritDoc\n   */\n  function CaptureConsole() {\n    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, CaptureConsole);\n\n    ;\n\n    CaptureConsole.prototype.__init.call(this);\n\n    CaptureConsole.prototype.__init2.call(this);\n\n    if (options.levels) {\n      this._levels = options.levels;\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(CaptureConsole, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = CaptureConsole.id;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._levels = CONSOLE_LEVELS;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce(_, getCurrentHub) {\n      if (!('console' in GLOBAL_OBJ)) {\n        return;\n      }\n\n      this._levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n        if (!(level in GLOBAL_OBJ.console)) {\n          return;\n        } // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n\n\n        fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {\n          return function () {\n            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n              args[_key] = arguments[_key];\n            }\n\n            var hub = getCurrentHub();\n\n            if (hub.getIntegration(CaptureConsole)) {\n              hub.withScope(function (scope) {\n                scope.setLevel(severityLevelFromString(level));\n                scope.setExtra('arguments', args);\n                scope.addEventProcessor(function (event) {\n                  event.logger = 'console';\n                  return event;\n                });\n                var message = safeJoin(args, ' ');\n\n                if (level === 'assert') {\n                  if (args[0] === false) {\n                    message = \"Assertion failed: \".concat(safeJoin(args.slice(1), ' ') || 'console.assert');\n                    scope.setExtra('arguments', args.slice(1));\n                    hub.captureMessage(message);\n                  }\n                } else if (level === 'error' && args[0] instanceof Error) {\n                  hub.captureException(args[0]);\n                } else {\n                  hub.captureMessage(message);\n                }\n              });\n            } // this fails for some browsers. :(\n\n\n            if (originalConsoleMethod) {\n              originalConsoleMethod.apply(GLOBAL_OBJ.console, args);\n            }\n          };\n        });\n      });\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = 'CaptureConsole';\n    }\n  }]);\n\n  return CaptureConsole;\n}();\n\nCaptureConsole.__initStatic();\n\nexport { CaptureConsole };","import { addExtensionMethods } from './hubextensions.js';\nexport { addExtensionMethods, startIdleTransaction } from './hubextensions.js';\nimport * as index from './integrations/index.js';\nexport { index as Integrations };\nimport './browser/index.js';\nexport { Span, spanStatusfromHttpCode } from './span.js';\nexport { SpanStatus } from './spanstatus.js';\nexport { Transaction } from './transaction.js';\nexport { IdleTransaction } from './idletransaction.js';\nexport { getActiveTransaction, hasTracingEnabled } from './utils.js';\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing } from './browser/browsertracing.js';\nexport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './browser/request.js';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n;\n; // Treeshakable guard to remove all code related to tracing\n// Guard for tree\n\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n  // We are patching the global object with our hub extension methods\n  addExtensionMethods();\n}","import * as Sentry from '@sentry/browser';\nimport { BrowserTracing } from '@sentry/tracing';\nimport { CaptureConsole } from '@sentry/integrations';\n\nwindow.setSentryUrlHash = function (organization_slug) {\n  Sentry.setTag(\"organization\", organization_slug);\n}\n\nSentry.init({\n  dsn: 'https://9baa4e393db847e197a673dd1b85be4b@o688802.ingest.sentry.io/6761874',\n  environment: window.gon?.environment ? window.gon.environment : 'unknown',\n  release: 'smaply@1.0.0',\n  integrations: [\n    new BrowserTracing(),\n    new CaptureConsole({\n      levels: ['error']\n    })\n  ],\n\n  // Choose a sampling rate with the goal of finding a balance between\n  // performance and volume concerns with data accuracy. You don't want to\n  // collect too much data, but you want to collect sufficient data from\n  // which to draw meaningful conclusions. If you’re not sure what rate to\n  // choose, start with a low value and gradually increase it as you learn\n  // more about your traffic patterns and volume.\n  // https://docs.sentry.io/platforms/javascript/configuration/sampling/#sampling-transaction-events\n  tracesSampleRate: 0.1,\n});\n","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { getOriginalFunction } from '@sentry/utils';\nvar originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\n\nvar FunctionToString = /*#__PURE__*/function () {\n  function FunctionToString() {\n    _classCallCheck(this, FunctionToString);\n\n    FunctionToString.prototype.__init.call(this);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(FunctionToString, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce() {\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      originalFunctionToString = Function.prototype.toString; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n      Function.prototype.toString = function () {\n        var context = getOriginalFunction(this) || this;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return originalFunctionToString.apply(context, args);\n      };\n    }\n  }], [{\n    key: \"__initStatic\",\n    value: function __initStatic() {\n      this.id = 'FunctionToString';\n    }\n  }]);\n\n  return FunctionToString;\n}();\n\nFunctionToString.__initStatic();\n\nexport { FunctionToString };","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { logger, getEventDescription, stringMatchesSomePattern } from '@sentry/utils'; // \"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.\n\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Options for the InboundFilters integration */\n\n/** Inbound filters configurable by the user */\n\nvar InboundFilters = /*#__PURE__*/function () {\n  function InboundFilters() {\n    var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, InboundFilters);\n\n    ;\n    this._options = _options;\n\n    InboundFilters.prototype.__init.call(this);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(InboundFilters, [{\n    key: \"__init\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init() {\n      this.name = InboundFilters.id;\n    }\n  }, {\n    key: \"setupOnce\",\n    value: function setupOnce(addGlobalEventProcessor, getCurrentHub) {\n      var eventProcess = function eventProcess(event) {\n        var hub = getCurrentHub();\n\n        if (hub) {\n          var self = hub.getIntegration(InboundFilters);\n\n          if (self) {\n            var client = hub.getClient();\n            var clientOptions = client ? client.getOptions() : {};\n\n            var options = _mergeOptions(self._options, clientOptions);\n\n            return _shouldDropEvent(event, options) ? null : event;\n          }\n        }\n\n        return event;\n      };\n\n      eventProcess.id = this.name;\n      addGlobalEventProcessor(eventProcess);\n    }\n  }], [{\n    key: \"__initStatic\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __initStatic() {\n      this.id = 'InboundFilters';\n    }\n  }]);\n\n  return InboundFilters;\n}();\n\nInboundFilters.__initStatic();\n/** JSDoc */\n\n\nfunction _mergeOptions() {\n  var internalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var clientOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return {\n    allowUrls: [].concat(_toConsumableArray(internalOptions.allowUrls || []), _toConsumableArray(clientOptions.allowUrls || [])),\n    denyUrls: [].concat(_toConsumableArray(internalOptions.denyUrls || []), _toConsumableArray(clientOptions.denyUrls || [])),\n    ignoreErrors: [].concat(_toConsumableArray(internalOptions.ignoreErrors || []), _toConsumableArray(clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true\n  };\n}\n/** JSDoc */\n\n\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \".concat(getEventDescription(event)));\n    return true;\n  }\n\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \".concat(getEventDescription(event)));\n    return true;\n  }\n\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \".concat(getEventDescription(event), \".\\nUrl: \").concat(_getEventFilterUrl(event)));\n    return true;\n  }\n\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \".concat(getEventDescription(event), \".\\nUrl: \").concat(_getEventFilterUrl(event)));\n    return true;\n  }\n\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(function (message) {\n    return stringMatchesSomePattern(message, ignoreErrors);\n  });\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n\n  var url = _getEventFilterUrl(event);\n\n  return !url ? false : stringMatchesSomePattern(url, denyUrls);\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n\n  var url = _getEventFilterUrl(event);\n\n  return !url ? true : stringMatchesSomePattern(url, allowUrls);\n}\n\nfunction _getPossibleEventMessages(event) {\n  if (event.message) {\n    return [event.message];\n  }\n\n  if (event.exception) {\n    try {\n      var _ref = event.exception.values && event.exception.values[0] || {},\n          _ref$type = _ref.type,\n          type = _ref$type === void 0 ? '' : _ref$type,\n          _ref$value = _ref.value,\n          value = _ref$value === void 0 ? '' : _ref$value;\n\n      return [\"\".concat(value), \"\".concat(type, \": \").concat(value)];\n    } catch (oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(\"Cannot extract message for event \".concat(getEventDescription(event)));\n      return [];\n    }\n  }\n\n  return [];\n}\n\nfunction _isSentryError(event) {\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) {// ignore\n  }\n\n  return false;\n}\n\nfunction _getLastValidUrl() {\n  var frames = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n  for (var i = frames.length - 1; i >= 0; i--) {\n    var 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) {\n  try {\n    var frames;\n\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) {// ignore\n    }\n\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(\"Cannot extract url for event \".concat(getEventDescription(event)));\n    return null;\n  }\n}\n\nexport { InboundFilters, _mergeOptions, _shouldDropEvent };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { getCurrentHub } from './hub.js'; // 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\n\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, {\n    captureContext: 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 */\n\n\nfunction captureMessage(message, // eslint-disable-next-line deprecation/deprecation\ncaptureContext) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  var level = typeof captureContext === 'string' ? captureContext : undefined;\n  var context = typeof captureContext !== 'string' ? {\n    captureContext: captureContext\n  } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\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 */\n\n\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\n\n\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\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 */\n\n\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\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\n\n\nfunction setContext(name, context) {\n  getCurrentHub().setContext(name, context);\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 */\n\n\nfunction setExtras(extras) {\n  getCurrentHub().setExtras(extras);\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 */\n\n\nfunction setExtra(key, extra) {\n  getCurrentHub().setExtra(key, extra);\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 */\n\n\nfunction setTags(tags) {\n  getCurrentHub().setTags(tags);\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 */\n\n\nfunction setTag(key, value) {\n  getCurrentHub().setTag(key, value);\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 */\n\n\nfunction setUser(user) {\n  getCurrentHub().setUser(user);\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 */\n\n\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\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 */\n\n\nfunction startTransaction(context, customSamplingContext) {\n  return getCurrentHub().startTransaction(_objectSpread({}, context), customSamplingContext);\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\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 */\n\nfunction makeSession(context) {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  var startingTime = timestampInSeconds();\n  var 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: function toJSON() {\n      return sessionToJSON(session);\n    }\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\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\n\n\nfunction updateSession(session) {\n  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\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\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n\n  if (!session.did && context.did) {\n    session.did = \"\".concat(context.did);\n  }\n\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    var duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n\n  if (context.release) {\n    session.release = context.release;\n  }\n\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n\n  if (context.status) {\n    session.status = context.status;\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 */\n\n\nfunction closeSession(session, status) {\n  var context = {};\n\n  if (status) {\n    context = {\n      status: status\n    };\n  } else if (session.status === 'ok') {\n    context = {\n      status: 'exited'\n    };\n  }\n\n  updateSession(session, context);\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 */\n\n\nfunction sessionToJSON(session) {\n  return dropUndefinedKeys({\n    sid: \"\".concat(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' ? \"\".concat(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\nexport { closeSession, makeSession, updateSession };","import { dynamicRequire, isNodeEnv } from './node.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\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 */\n\nvar dateTimestampSource = {\n  nowSeconds: function nowSeconds() {\n    return 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 */\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 */\n\nfunction getBrowserPerformance() {\n  var performance = WINDOW.performance;\n\n  if (!performance || !performance.now) {\n    return undefined;\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\n\n  var timeOrigin = Date.now() - performance.now();\n  return {\n    now: function now() {\n      return performance.now();\n    },\n    timeOrigin: timeOrigin\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 */\n\n\nfunction getNodePerformance() {\n  try {\n    var perfHooks = dynamicRequire(module, 'perf_hooks');\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\n\n\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined ? dateTimestampSource : {\n  nowSeconds: function nowSeconds() {\n    return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000;\n  }\n};\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\n\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\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 */\n\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource); // Re-exported with an old name for backwards-compatibility.\n\nvar timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\n\nvar usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\n\nvar _browserPerformanceTimeOriginMode;\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 */\n\n\nvar browserPerformanceTimeOrigin = function () {\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  var performance = WINDOW.performance;\n\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  var threshold = 3600 * 1000;\n  var performanceNow = performance.now();\n  var dateNow = Date.now(); // if timeOrigin isn't available set delta to threshold so it isn't used\n\n  var timeOriginDelta = performance.timeOrigin ? Math.abs(performance.timeOrigin + performanceNow - dateNow) : threshold;\n  var timeOriginIsReliable = timeOriginDelta < threshold; // 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\n  var navigationStart = performance.timing && performance.timing.navigationStart;\n  var hasNavigationStart = typeof navigationStart === 'number'; // if navigationStart isn't available set delta to threshold so it isn't used\n\n  var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  var 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  } // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n\n\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n}();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { isPlainObject, dateTimestampInSeconds, SyncPromise, logger, isThenable, arrayify, getGlobalSingleton } from '@sentry/utils';\nimport { updateSession } from './session.js';\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\n\nvar DEFAULT_MAX_BREADCRUMBS = 100;\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\n\nvar Scope = /*#__PURE__*/function () {\n  /** Flag if notifying is happening. */\n\n  /** Callback for client to receive scope changes. */\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n\n  /** Array of breadcrumbs. */\n\n  /** User */\n\n  /** Tags */\n\n  /** Extra */\n\n  /** Contexts */\n\n  /** Attachments */\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\n  /** Fingerprint */\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n\n  /** Transaction Name */\n\n  /** Span */\n\n  /** Session */\n\n  /** Request Mode Session Status */\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n  function Scope() {\n    _classCallCheck(this, Scope);\n\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   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n\n\n  _createClass(Scope, [{\n    key: \"addScopeListener\",\n    value:\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    function addScopeListener(callback) {\n      this._scopeListeners.push(callback);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"addEventProcessor\",\n    value: function addEventProcessor(callback) {\n      this._eventProcessors.push(callback);\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setUser\",\n    value: function setUser(user) {\n      this._user = user || {};\n\n      if (this._session) {\n        updateSession(this._session, {\n          user: user\n        });\n      }\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getUser\",\n    value: function getUser() {\n      return this._user;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getRequestSession\",\n    value: function getRequestSession() {\n      return this._requestSession;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setRequestSession\",\n    value: function setRequestSession(requestSession) {\n      this._requestSession = requestSession;\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTags\",\n    value: function setTags(tags) {\n      this._tags = _objectSpread(_objectSpread({}, this._tags), tags);\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTag\",\n    value: function setTag(key, value) {\n      this._tags = _objectSpread(_objectSpread({}, this._tags), {}, _defineProperty({}, key, value));\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setExtras\",\n    value: function setExtras(extras) {\n      this._extra = _objectSpread(_objectSpread({}, this._extra), extras);\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setExtra\",\n    value: function setExtra(key, extra) {\n      this._extra = _objectSpread(_objectSpread({}, this._extra), {}, _defineProperty({}, key, extra));\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setFingerprint\",\n    value: function setFingerprint(fingerprint) {\n      this._fingerprint = fingerprint;\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setLevel\",\n    value: function setLevel( // eslint-disable-next-line deprecation/deprecation\n    level) {\n      this._level = level;\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTransactionName\",\n    value: function setTransactionName(name) {\n      this._transactionName = name;\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setContext\",\n    value: function setContext(key, context) {\n      if (context === null) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n        delete this._contexts[key];\n      } else {\n        this._contexts[key] = context;\n      }\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setSpan\",\n    value: function setSpan(span) {\n      this._span = span;\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getSpan\",\n    value: function getSpan() {\n      return this._span;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getTransaction\",\n    value: function getTransaction() {\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      var span = this.getSpan();\n      return span && span.transaction;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setSession\",\n    value: function setSession(session) {\n      if (!session) {\n        delete this._session;\n      } else {\n        this._session = session;\n      }\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getSession\",\n    value: function getSession() {\n      return this._session;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(captureContext) {\n      if (!captureContext) {\n        return this;\n      }\n\n      if (typeof captureContext === 'function') {\n        var updatedScope = captureContext(this);\n        return updatedScope instanceof Scope ? updatedScope : this;\n      }\n\n      if (captureContext instanceof Scope) {\n        this._tags = _objectSpread(_objectSpread({}, this._tags), captureContext._tags);\n        this._extra = _objectSpread(_objectSpread({}, this._extra), captureContext._extra);\n        this._contexts = _objectSpread(_objectSpread({}, this._contexts), captureContext._contexts);\n\n        if (captureContext._user && Object.keys(captureContext._user).length) {\n          this._user = captureContext._user;\n        }\n\n        if (captureContext._level) {\n          this._level = captureContext._level;\n        }\n\n        if (captureContext._fingerprint) {\n          this._fingerprint = captureContext._fingerprint;\n        }\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;\n        this._tags = _objectSpread(_objectSpread({}, this._tags), captureContext.tags);\n        this._extra = _objectSpread(_objectSpread({}, this._extra), captureContext.extra);\n        this._contexts = _objectSpread(_objectSpread({}, this._contexts), captureContext.contexts);\n\n        if (captureContext.user) {\n          this._user = captureContext.user;\n        }\n\n        if (captureContext.level) {\n          this._level = captureContext.level;\n        }\n\n        if (captureContext.fingerprint) {\n          this._fingerprint = captureContext.fingerprint;\n        }\n\n        if (captureContext.requestSession) {\n          this._requestSession = captureContext.requestSession;\n        }\n      }\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"clear\",\n    value: function clear() {\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\n      this._notifyScopeListeners();\n\n      this._attachments = [];\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"addBreadcrumb\",\n    value: function addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n      var maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS; // No data has been changed, so don't notify scope listeners\n\n      if (maxCrumbs <= 0) {\n        return this;\n      }\n\n      var mergedBreadcrumb = _objectSpread({\n        timestamp: dateTimestampInSeconds()\n      }, breadcrumb);\n\n      this._breadcrumbs = [].concat(_toConsumableArray(this._breadcrumbs), [mergedBreadcrumb]).slice(-maxCrumbs);\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"clearBreadcrumbs\",\n    value: function clearBreadcrumbs() {\n      this._breadcrumbs = [];\n\n      this._notifyScopeListeners();\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"addAttachment\",\n    value: function addAttachment(attachment) {\n      this._attachments.push(attachment);\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getAttachments\",\n    value: function getAttachments() {\n      return this._attachments;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"clearAttachments\",\n    value: function clearAttachments() {\n      this._attachments = [];\n      return this;\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\n  }, {\n    key: \"applyToEvent\",\n    value: function applyToEvent(event) {\n      var hint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (this._extra && Object.keys(this._extra).length) {\n        event.extra = _objectSpread(_objectSpread({}, this._extra), event.extra);\n      }\n\n      if (this._tags && Object.keys(this._tags).length) {\n        event.tags = _objectSpread(_objectSpread({}, this._tags), event.tags);\n      }\n\n      if (this._user && Object.keys(this._user).length) {\n        event.user = _objectSpread(_objectSpread({}, this._user), event.user);\n      }\n\n      if (this._contexts && Object.keys(this._contexts).length) {\n        event.contexts = _objectSpread(_objectSpread({}, this._contexts), event.contexts);\n      }\n\n      if (this._level) {\n        event.level = this._level;\n      }\n\n      if (this._transactionName) {\n        event.transaction = this._transactionName;\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\n\n      if (this._span) {\n        event.contexts = _objectSpread({\n          trace: this._span.getTraceContext()\n        }, event.contexts);\n        var transactionName = this._span.transaction && this._span.transaction.name;\n\n        if (transactionName) {\n          event.tags = _objectSpread({\n            transaction: transactionName\n          }, event.tags);\n        }\n      }\n\n      this._applyFingerprint(event);\n\n      event.breadcrumbs = [].concat(_toConsumableArray(event.breadcrumbs || []), _toConsumableArray(this._breadcrumbs));\n      event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n      event.sdkProcessingMetadata = _objectSpread(_objectSpread({}, event.sdkProcessingMetadata), this._sdkProcessingMetadata);\n      return this._notifyEventProcessors([].concat(_toConsumableArray(getGlobalEventProcessors()), _toConsumableArray(this._eventProcessors)), event, hint);\n    }\n    /**\n     * Add data which will be accessible during event processing but won't get sent to Sentry\n     */\n\n  }, {\n    key: \"setSDKProcessingMetadata\",\n    value: function setSDKProcessingMetadata(newData) {\n      this._sdkProcessingMetadata = _objectSpread(_objectSpread({}, this._sdkProcessingMetadata), newData);\n      return this;\n    }\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n\n  }, {\n    key: \"_notifyEventProcessors\",\n    value: function _notifyEventProcessors(processors, event, hint) {\n      var _this = this;\n\n      var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n      return new SyncPromise(function (resolve, reject) {\n        var processor = processors[index];\n\n        if (event === null || typeof processor !== 'function') {\n          resolve(event);\n        } else {\n          var result = processor(_objectSpread({}, event), hint);\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && processor.id && result === null && logger.log(\"Event processor \\\"\".concat(processor.id, \"\\\" dropped event\"));\n\n          if (isThenable(result)) {\n            void result.then(function (final) {\n              return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve);\n            }).then(null, reject);\n          } else {\n            void _this._notifyEventProcessors(processors, result, hint, index + 1).then(resolve).then(null, reject);\n          }\n        }\n      });\n    }\n    /**\n     * This will be called on every set call.\n     */\n\n  }, {\n    key: \"_notifyScopeListeners\",\n    value: function _notifyScopeListeners() {\n      var _this2 = this;\n\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\n        this._scopeListeners.forEach(function (callback) {\n          callback(_this2);\n        });\n\n        this._notifyingListeners = false;\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\n  }, {\n    key: \"_applyFingerprint\",\n    value: function _applyFingerprint(event) {\n      // Make sure it's an array first and we actually have something in place\n      event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : []; // If we have something on the scope, then merge it with event\n\n      if (this._fingerprint) {\n        event.fingerprint = event.fingerprint.concat(this._fingerprint);\n      } // If we have no data at all, remove empty array default\n\n\n      if (event.fingerprint && !event.fingerprint.length) {\n        delete event.fingerprint;\n      }\n    }\n  }], [{\n    key: \"clone\",\n    value: function clone(scope) {\n      var newScope = new Scope();\n\n      if (scope) {\n        newScope._breadcrumbs = _toConsumableArray(scope._breadcrumbs);\n        newScope._tags = _objectSpread({}, scope._tags);\n        newScope._extra = _objectSpread({}, scope._extra);\n        newScope._contexts = _objectSpread({}, 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 = _toConsumableArray(scope._eventProcessors);\n        newScope._requestSession = scope._requestSession;\n        newScope._attachments = _toConsumableArray(scope._attachments);\n        newScope._sdkProcessingMetadata = _objectSpread({}, scope._sdkProcessingMetadata);\n      }\n\n      return newScope;\n    }\n  }]);\n\n  return Scope;\n}();\n/**\n * Returns the global event processors.\n */\n\n\nfunction getGlobalEventProcessors() {\n  return getGlobalSingleton('globalEventProcessors', function () {\n    return [];\n  });\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\n\n\nfunction addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };","import { isBrowserBundle } from './env.js';\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\n\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return !isBrowserBundle() && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\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\n\n\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\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 */\n\n\nfunction loadModule(moduleName) {\n  var mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {// no-empty\n  }\n\n  try {\n    var _dynamicRequire = dynamicRequire(module, 'process'),\n        cwd = _dynamicRequire.cwd;\n\n    mod = dynamicRequire(module, \"\".concat(cwd(), \"/node_modules/\").concat(moduleName));\n  } catch (e) {// no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\n\nfunction uuid4() {\n  var gbl = GLOBAL_OBJ;\n  var crypto = gbl.crypto || gbl.msCrypto;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  var getRandomByte = crypto && crypto.getRandomValues ? function () {\n    return crypto.getRandomValues(new Uint8Array(1))[0];\n  } : function () {\n    return Math.random() * 16;\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\n  return ([1e7] + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, function (c) {\n    return (// eslint-disable-next-line no-bitwise\n      (c ^ (getRandomByte() & 15) >> c / 4).toString(16)\n    );\n  });\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\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 */\n\n\nfunction getEventDescription(event) {\n  var message = event.message,\n      eventId = event.event_id;\n\n  if (message) {\n    return message;\n  }\n\n  var firstException = getFirstException(event);\n\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return \"\".concat(firstException.type, \": \").concat(firstException.value);\n    }\n\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n\n  return eventId || '<unknown>';\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 */\n\n\nfunction addExceptionTypeValue(event, value, type) {\n  var exception = event.exception = event.exception || {};\n  var values = exception.values = exception.values || [];\n  var firstException = values[0] = values[0] || {};\n\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\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 */\n\n\nfunction addExceptionMechanism(event, newMechanism) {\n  var firstException = getFirstException(event);\n\n  if (!firstException) {\n    return;\n  }\n\n  var defaultMechanism = {\n    type: 'generic',\n    handled: true\n  };\n  var currentMechanism = firstException.mechanism;\n  firstException.mechanism = _objectSpread(_objectSpread(_objectSpread({}, defaultMechanism), currentMechanism), newMechanism);\n\n  if (newMechanism && 'data' in newMechanism) {\n    var mergedData = _objectSpread(_objectSpread({}, currentMechanism && currentMechanism.data), newMechanism.data);\n\n    firstException.mechanism.data = mergedData;\n  }\n} // https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\n\n\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\n\nfunction parseSemver(input) {\n  var match = input.match(SEMVER_REGEXP) || [];\n  var major = parseInt(match[1], 10);\n  var minor = parseInt(match[2], 10);\n  var 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 * 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 */\n\n\nfunction addContextToFrame(lines, frame) {\n  var linesOfContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;\n  var lineno = frame.lineno || 0;\n  var maxLines = lines.length;\n  var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n  frame.pre_context = lines.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map(function (line) {\n    return snipLine(line, 0);\n  });\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n  frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map(function (line) {\n    return 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 */\n\n\nfunction checkOrSetAlreadyCaught(exception) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && exception.__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, '__sentry_captured__', true);\n  } catch (err) {// `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\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 */\n\n\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { uuid4, timestampWithMs, logger, dropUndefinedKeys } from '@sentry/utils';\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\n\nvar SpanRecorder = /*#__PURE__*/function () {\n  function SpanRecorder() {\n    var maxlen = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;\n\n    _classCallCheck(this, SpanRecorder);\n\n    ;\n\n    SpanRecorder.prototype.__init.call(this);\n\n    this._maxlen = maxlen;\n  }\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n\n\n  _createClass(SpanRecorder, [{\n    key: \"__init\",\n    value: function __init() {\n      this.spans = [];\n    }\n  }, {\n    key: \"add\",\n    value: function add(span) {\n      if (this.spans.length > this._maxlen) {\n        span.spanRecorder = undefined;\n      } else {\n        this.spans.push(span);\n      }\n    }\n  }]);\n\n  return SpanRecorder;\n}();\n/**\n * Span contains all data about a span\n */\n\n\nvar Span = /*#__PURE__*/function () {\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  function Span(spanContext) {\n    _classCallCheck(this, Span);\n\n    ;\n\n    Span.prototype.__init2.call(this);\n\n    Span.prototype.__init3.call(this);\n\n    Span.prototype.__init4.call(this);\n\n    Span.prototype.__init5.call(this);\n\n    Span.prototype.__init6.call(this);\n\n    Span.prototype.__init7.call(this);\n\n    if (!spanContext) {\n      return this;\n    }\n\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    } // We want to include booleans as well here\n\n\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n\n    if (spanContext.instrumenter) {\n      this.instrumenter = spanContext.instrumenter;\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(Span, [{\n    key: \"__init2\",\n    value:\n    /**\n     * @inheritDoc\n     */\n    function __init2() {\n      this.traceId = uuid4();\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      this.spanId = uuid4().substring(16);\n    }\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * Internal keeper of the status\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * Timestamp in seconds when the span was created.\n     */\n\n  }, {\n    key: \"__init4\",\n    value: function __init4() {\n      this.startTimestamp = timestampWithMs();\n    }\n    /**\n     * Timestamp in seconds when the span ended.\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"__init5\",\n    value: function __init5() {\n      this.tags = {};\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  }, {\n    key: \"__init6\",\n    value: function __init6() {\n      this.data = {};\n    }\n    /**\n     * List of spans that were finalized\n     */\n\n    /**\n     * @inheritDoc\n     */\n\n    /**\n     * The instrumenter that created this span.\n     */\n\n  }, {\n    key: \"__init7\",\n    value: function __init7() {\n      this.instrumenter = 'sentry';\n    }\n  }, {\n    key: \"startChild\",\n    value: function startChild(spanContext) {\n      var childSpan = new Span(_objectSpread(_objectSpread({}, spanContext), {}, {\n        parentSpanId: this.spanId,\n        sampled: this.sampled,\n        traceId: this.traceId\n      }));\n      childSpan.spanRecorder = this.spanRecorder;\n\n      if (childSpan.spanRecorder) {\n        childSpan.spanRecorder.add(childSpan);\n      }\n\n      childSpan.transaction = this.transaction;\n\n      if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && childSpan.transaction) {\n        var opStr = spanContext && spanContext.op || '< unknown op >';\n        var nameStr = childSpan.transaction.name || '< unknown name >';\n        var idStr = childSpan.transaction.spanId;\n        var logMessage = \"[Tracing] Starting '\".concat(opStr, \"' span on transaction '\").concat(nameStr, \"' (\").concat(idStr, \").\");\n        childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = {\n          logMessage: logMessage\n        };\n        logger.log(logMessage);\n      }\n\n      return childSpan;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTag\",\n    value: function setTag(key, value) {\n      this.tags = _objectSpread(_objectSpread({}, this.tags), {}, _defineProperty({}, key, value));\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n  }, {\n    key: \"setData\",\n    value: function setData(key, value) {\n      this.data = _objectSpread(_objectSpread({}, this.data), {}, _defineProperty({}, key, value));\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setStatus\",\n    value: function setStatus(value) {\n      this.status = value;\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setHttpStatus\",\n    value: function setHttpStatus(httpStatus) {\n      this.setTag('http.status_code', String(httpStatus));\n      var spanStatus = spanStatusfromHttpCode(httpStatus);\n\n      if (spanStatus !== 'unknown_error') {\n        this.setStatus(spanStatus);\n      }\n\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"isSuccess\",\n    value: function isSuccess() {\n      return this.status === 'ok';\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"finish\",\n    value: function finish(endTimestamp) {\n      if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && // Don't call this for transactions\n      this.transaction && this.transaction.spanId !== this.spanId) {\n        var logMessage = this.transaction.metadata.spanMetadata[this.spanId].logMessage;\n\n        if (logMessage) {\n          logger.log(logMessage.replace('Starting', 'Finishing'));\n        }\n      }\n\n      this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"toTraceparent\",\n    value: function toTraceparent() {\n      var sampledString = '';\n\n      if (this.sampled !== undefined) {\n        sampledString = this.sampled ? '-1' : '-0';\n      }\n\n      return \"\".concat(this.traceId, \"-\").concat(this.spanId).concat(sampledString);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"toContext\",\n    value: function toContext() {\n      return dropUndefinedKeys({\n        data: this.data,\n        description: this.description,\n        endTimestamp: this.endTimestamp,\n        op: this.op,\n        parentSpanId: this.parentSpanId,\n        sampled: this.sampled,\n        spanId: this.spanId,\n        startTimestamp: this.startTimestamp,\n        status: this.status,\n        tags: this.tags,\n        traceId: this.traceId\n      });\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"updateWithContext\",\n    value: function updateWithContext(spanContext) {\n      var _this = this;\n\n      this.data = _nullishCoalesce(spanContext.data, function () {\n        return {};\n      });\n      this.description = spanContext.description;\n      this.endTimestamp = spanContext.endTimestamp;\n      this.op = spanContext.op;\n      this.parentSpanId = spanContext.parentSpanId;\n      this.sampled = spanContext.sampled;\n      this.spanId = _nullishCoalesce(spanContext.spanId, function () {\n        return _this.spanId;\n      });\n      this.startTimestamp = _nullishCoalesce(spanContext.startTimestamp, function () {\n        return _this.startTimestamp;\n      });\n      this.status = spanContext.status;\n      this.tags = _nullishCoalesce(spanContext.tags, function () {\n        return {};\n      });\n      this.traceId = _nullishCoalesce(spanContext.traceId, function () {\n        return _this.traceId;\n      });\n      return this;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getTraceContext\",\n    value: function getTraceContext() {\n      return dropUndefinedKeys({\n        data: Object.keys(this.data).length > 0 ? this.data : undefined,\n        description: this.description,\n        op: this.op,\n        parent_span_id: this.parentSpanId,\n        span_id: this.spanId,\n        status: this.status,\n        tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n        trace_id: this.traceId\n      });\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"toJSON\",\n    value: function toJSON() {\n      return dropUndefinedKeys({\n        data: Object.keys(this.data).length > 0 ? this.data : undefined,\n        description: this.description,\n        op: this.op,\n        parent_span_id: this.parentSpanId,\n        span_id: this.spanId,\n        start_timestamp: this.startTimestamp,\n        status: this.status,\n        tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n        timestamp: this.endTimestamp,\n        trace_id: this.traceId\n      });\n    }\n  }]);\n\n  return Span;\n}();\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\n\n\nfunction spanStatusfromHttpCode(httpStatus) {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n\n      case 403:\n        return 'permission_denied';\n\n      case 404:\n        return 'not_found';\n\n      case 409:\n        return 'already_exists';\n\n      case 413:\n        return 'failed_precondition';\n\n      case 429:\n        return 'resource_exhausted';\n\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n\n      case 503:\n        return 'unavailable';\n\n      case 504:\n        return 'deadline_exceeded';\n\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n\nexport { Span, SpanRecorder, spanStatusfromHttpCode };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nfunction _get() { if (typeof Reflect !== \"undefined\" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }\n\nfunction _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nimport { timestampWithMs, logger } from '@sentry/utils';\nimport { SpanRecorder } from './span.js';\nimport { Transaction } from './transaction.js';\nvar DEFAULT_IDLE_TIMEOUT = 1000;\nvar DEFAULT_FINAL_TIMEOUT = 30000;\nvar DEFAULT_HEARTBEAT_INTERVAL = 5000;\n/**\n * @inheritDoc\n */\n\nvar IdleTransactionSpanRecorder = /*#__PURE__*/function (_SpanRecorder) {\n  _inherits(IdleTransactionSpanRecorder, _SpanRecorder);\n\n  var _super = _createSuper(IdleTransactionSpanRecorder);\n\n  function IdleTransactionSpanRecorder(_pushActivity, _popActivity, transactionSpanId, maxlen) {\n    var _this;\n\n    _classCallCheck(this, IdleTransactionSpanRecorder);\n\n    _this = _super.call(this, maxlen);\n    _this._pushActivity = _pushActivity;\n    _this._popActivity = _popActivity;\n    _this.transactionSpanId = transactionSpanId;\n    ;\n    return _this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(IdleTransactionSpanRecorder, [{\n    key: \"add\",\n    value: function add(span) {\n      var _this2 = this;\n\n      // We should make sure we do not push and pop activities for\n      // the transaction that this span recorder belongs to.\n      if (span.spanId !== this.transactionSpanId) {\n        // We patch span.finish() to pop an activity after setting an endTimestamp.\n        span.finish = function (endTimestamp) {\n          span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n\n          _this2._popActivity(span.spanId);\n        }; // We should only push new activities if the span does not have an end timestamp.\n\n\n        if (span.endTimestamp === undefined) {\n          this._pushActivity(span.spanId);\n        }\n      }\n\n      _get(_getPrototypeOf(IdleTransactionSpanRecorder.prototype), \"add\", this).call(this, span);\n    }\n  }]);\n\n  return IdleTransactionSpanRecorder;\n}(SpanRecorder);\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\n\n\nvar IdleTransaction = /*#__PURE__*/function (_Transaction) {\n  _inherits(IdleTransaction, _Transaction);\n\n  var _super2 = _createSuper(IdleTransaction);\n\n  /**\n   * Timer that tracks Transaction idleTimeout\n   */\n  function IdleTransaction(transactionContext, _idleHub) {\n    var _this3;\n\n    var _idleTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_IDLE_TIMEOUT;\n\n    var _finalTimeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_FINAL_TIMEOUT;\n\n    var _heartbeatInterval = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : DEFAULT_HEARTBEAT_INTERVAL;\n\n    var _onScope = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n\n    _classCallCheck(this, IdleTransaction);\n\n    _this3 = _super2.call(this, transactionContext, _idleHub);\n    _this3._idleHub = _idleHub;\n    _this3._idleTimeout = _idleTimeout;\n    _this3._finalTimeout = _finalTimeout;\n    _this3._heartbeatInterval = _heartbeatInterval;\n    _this3._onScope = _onScope;\n\n    IdleTransaction.prototype.__init.call(_assertThisInitialized(_this3));\n\n    IdleTransaction.prototype.__init2.call(_assertThisInitialized(_this3));\n\n    IdleTransaction.prototype.__init3.call(_assertThisInitialized(_this3));\n\n    IdleTransaction.prototype.__init4.call(_assertThisInitialized(_this3));\n\n    ;\n\n    if (_onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub); // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"Setting idle transaction on scope. Span ID: \".concat(_this3.spanId));\n\n      _idleHub.configureScope(function (scope) {\n        return scope.setSpan(_assertThisInitialized(_this3));\n      });\n    }\n\n    _this3._startIdleTimeout();\n\n    setTimeout(function () {\n      if (!_this3._finished) {\n        _this3.setStatus('deadline_exceeded');\n\n        _this3.finish();\n      }\n    }, _this3._finalTimeout);\n    return _this3;\n  }\n  /** {@inheritDoc} */\n\n\n  _createClass(IdleTransaction, [{\n    key: \"__init\",\n    value: // Activities store a list of active spans\n    function __init() {\n      this.activities = {};\n    } // Track state of activities in previous heartbeat\n    // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._heartbeatCounter = 0;\n    } // We should not use heartbeat if we finished a transaction\n\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      this._finished = false;\n    }\n  }, {\n    key: \"__init4\",\n    value: function __init4() {\n      this._beforeFinishCallbacks = [];\n    }\n  }, {\n    key: \"finish\",\n    value: function finish() {\n      var _this4 = this;\n\n      var endTimestamp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : timestampWithMs();\n      this._finished = true;\n      this.activities = {};\n\n      if (this.spanRecorder) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n        var _iterator = _createForOfIteratorHelper(this._beforeFinishCallbacks),\n            _step;\n\n        try {\n          for (_iterator.s(); !(_step = _iterator.n()).done;) {\n            var callback = _step.value;\n            callback(this, endTimestamp);\n          }\n        } catch (err) {\n          _iterator.e(err);\n        } finally {\n          _iterator.f();\n        }\n\n        this.spanRecorder.spans = this.spanRecorder.spans.filter(function (span) {\n          // If we are dealing with the transaction itself, we just return it\n          if (span.spanId === _this4.spanId) {\n            return true;\n          } // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n\n\n          if (!span.endTimestamp) {\n            span.endTimestamp = endTimestamp;\n            span.setStatus('cancelled');\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n          }\n\n          var keepSpan = span.startTimestamp < endTimestamp;\n\n          if (!keepSpan) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] discarding Span since it happened after Transaction was finished', JSON.stringify(span, undefined, 2));\n          }\n\n          return keepSpan;\n        });\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] flushing IdleTransaction');\n      } else {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] No active IdleTransaction');\n      } // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n\n\n      if (this._onScope) {\n        clearActiveTransaction(this._idleHub);\n      }\n\n      return _get(_getPrototypeOf(IdleTransaction.prototype), \"finish\", this).call(this, endTimestamp);\n    }\n    /**\n     * Register a callback function that gets excecuted before the transaction finishes.\n     * Useful for cleanup or if you want to add any additional spans based on current context.\n     *\n     * This is exposed because users have no other way of running something before an idle transaction\n     * finishes.\n     */\n\n  }, {\n    key: \"registerBeforeFinishCallback\",\n    value: function registerBeforeFinishCallback(callback) {\n      this._beforeFinishCallbacks.push(callback);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"initSpanRecorder\",\n    value: function initSpanRecorder(maxlen) {\n      var _this5 = this;\n\n      if (!this.spanRecorder) {\n        var pushActivity = function pushActivity(id) {\n          if (_this5._finished) {\n            return;\n          }\n\n          _this5._pushActivity(id);\n        };\n\n        var popActivity = function popActivity(id) {\n          if (_this5._finished) {\n            return;\n          }\n\n          _this5._popActivity(id);\n        };\n\n        this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen); // Start heartbeat so that transactions do not run forever.\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Starting heartbeat');\n\n        this._pingHeartbeat();\n      }\n\n      this.spanRecorder.add(this);\n    }\n    /**\n     * Cancels the existing idletimeout, if there is one\n     */\n\n  }, {\n    key: \"_cancelIdleTimeout\",\n    value: function _cancelIdleTimeout() {\n      if (this._idleTimeoutID) {\n        clearTimeout(this._idleTimeoutID);\n        this._idleTimeoutID = undefined;\n      }\n    }\n    /**\n     * Creates an idletimeout\n     */\n\n  }, {\n    key: \"_startIdleTimeout\",\n    value: function _startIdleTimeout(endTimestamp) {\n      var _this6 = this;\n\n      this._cancelIdleTimeout();\n\n      this._idleTimeoutID = setTimeout(function () {\n        if (!_this6._finished && Object.keys(_this6.activities).length === 0) {\n          _this6.finish(endTimestamp);\n        }\n      }, this._idleTimeout);\n    }\n    /**\n     * Start tracking a specific activity.\n     * @param spanId The span id that represents the activity\n     */\n\n  }, {\n    key: \"_pushActivity\",\n    value: function _pushActivity(spanId) {\n      this._cancelIdleTimeout();\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] pushActivity: \".concat(spanId));\n      this.activities[spanId] = true;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n    /**\n     * Remove an activity from usage\n     * @param spanId The span id that represents the activity\n     */\n\n  }, {\n    key: \"_popActivity\",\n    value: function _popActivity(spanId) {\n      if (this.activities[spanId]) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] popActivity \".concat(spanId)); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n        delete this.activities[spanId];\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n      }\n\n      if (Object.keys(this.activities).length === 0) {\n        // We need to add the timeout here to have the real endtimestamp of the transaction\n        // Remember timestampWithMs is in seconds, timeout is in ms\n        var endTimestamp = timestampWithMs() + this._idleTimeout / 1000;\n\n        this._startIdleTimeout(endTimestamp);\n      }\n    }\n    /**\n     * Checks when entries of this.activities are not changing for 3 beats.\n     * If this occurs we finish the transaction.\n     */\n\n  }, {\n    key: \"_beat\",\n    value: function _beat() {\n      // We should not be running heartbeat if the idle transaction is finished.\n      if (this._finished) {\n        return;\n      }\n\n      var heartbeatString = Object.keys(this.activities).join('');\n\n      if (heartbeatString === this._prevHeartbeatString) {\n        this._heartbeatCounter += 1;\n      } else {\n        this._heartbeatCounter = 1;\n      }\n\n      this._prevHeartbeatString = heartbeatString;\n\n      if (this._heartbeatCounter >= 3) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n        this.setStatus('deadline_exceeded');\n        this.finish();\n      } else {\n        this._pingHeartbeat();\n      }\n    }\n    /**\n     * Pings the heartbeat\n     */\n\n  }, {\n    key: \"_pingHeartbeat\",\n    value: function _pingHeartbeat() {\n      var _this7 = this;\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"pinging Heartbeat -> current counter: \".concat(this._heartbeatCounter));\n      setTimeout(function () {\n        _this7._beat();\n      }, this._heartbeatInterval);\n    }\n  }]);\n\n  return IdleTransaction;\n}(Transaction);\n/**\n * Reset transaction on scope to `undefined`\n */\n\n\nfunction clearActiveTransaction(hub) {\n  var scope = hub.getScope();\n\n  if (scope) {\n    var transaction = scope.getTransaction();\n\n    if (transaction) {\n      scope.setSpan(undefined);\n    }\n  }\n}\n\nexport { DEFAULT_FINAL_TIMEOUT, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_IDLE_TIMEOUT, IdleTransaction, IdleTransactionSpanRecorder };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /*#__PURE__*/function (_Error) {\n  _inherits(SentryError, _Error);\n\n  var _super = _createSuper(SentryError);\n\n  /** Display name of this error instance. */\n  function SentryError(message) {\n    var _this;\n\n    var logLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'warn';\n\n    _classCallCheck(this, SentryError);\n\n    _this = _super.call(this, message);\n    _this.message = message;\n    ;\n    _this.name = (this instanceof SentryError ? this.constructor : void 0).prototype.constructor.name; // 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\n    Object.setPrototypeOf(_assertThisInitialized(_this), (this instanceof SentryError ? this.constructor : void 0).prototype);\n    _this.logLevel = logLevel;\n    return _this;\n  }\n\n  return SentryError;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nexport { SentryError };","// shim for using process in browser\nvar process = module.exports = {}; // 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}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\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\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\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\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\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\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\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\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\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) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nimport { getMainCarrier } from '@sentry/core';\nimport { logger, isNaN, dynamicRequire, loadModule, isNodeEnv } from '@sentry/utils';\nimport { registerErrorInstrumentation } from './errors.js';\nimport { IdleTransaction } from './idletransaction.js';\nimport { Transaction } from './transaction.js';\nimport { hasTracingEnabled } from './utils.js';\n/** Returns all trace headers that are currently on the top scope. */\n\nfunction traceHeaders() {\n  var scope = this.getScope();\n\n  if (scope) {\n    var span = scope.getSpan();\n\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent()\n      };\n    }\n  }\n\n  return {};\n}\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\n\n\nfunction sample(transaction, options, samplingContext) {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  } // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n\n\n  if (transaction.sampled !== undefined) {\n    transaction.setMetadata({\n      sampleRate: Number(transaction.sampled)\n    });\n    return transaction;\n  } // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n\n\n  var sampleRate;\n\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate)\n    });\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else {\n    sampleRate = options.tracesSampleRate;\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate)\n    });\n  } // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n\n\n  if (!isValidSampleRate(sampleRate)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    transaction.sampled = false;\n    return transaction;\n  } // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n\n\n  if (!sampleRate) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Discarding transaction because \".concat(typeof options.tracesSampler === 'function' ? 'tracesSampler returned 0 or false' : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'));\n    transaction.sampled = false;\n    return transaction;\n  } // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n\n\n  transaction.sampled = Math.random() < sampleRate; // if we're not going to keep it, we're done\n\n  if (!transaction.sampled) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = \".concat(Number(sampleRate), \")\"));\n    return transaction;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] starting \".concat(transaction.op, \" transaction - \").concat(transaction.name));\n  return transaction;\n}\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\n\n\nfunction isValidSampleRate(rate) {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got \".concat(JSON.stringify(rate), \" of type \").concat(JSON.stringify(_typeof(rate)), \".\"));\n    return false;\n  } // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n\n\n  if (rate < 0 || rate > 1) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got \".concat(rate, \".\"));\n    return false;\n  }\n\n  return true;\n}\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\n\n\nfunction _startTransaction(transactionContext, customSamplingContext) {\n  var client = this.getClient();\n  var options = client && client.getOptions() || {};\n  var configInstrumenter = options.instrumenter || 'sentry';\n  var transactionInstrumenter = transactionContext.instrumenter || 'sentry';\n\n  if (configInstrumenter !== transactionInstrumenter) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(\"A transaction was started with instrumenter=`\".concat(transactionInstrumenter, \"`, but the SDK is configured with the `\").concat(configInstrumenter, \"` instrumenter.\\nThe transaction will not be sampled. Please use the \").concat(configInstrumenter, \" instrumentation to start transactions.\"));\n    transactionContext.sampled = false;\n  }\n\n  var transaction = new Transaction(transactionContext, this);\n  transaction = sample(transaction, options, _objectSpread({\n    parentSampled: transactionContext.parentSampled,\n    transactionContext: transactionContext\n  }, customSamplingContext));\n\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && options._experiments.maxSpans);\n  }\n\n  return transaction;\n}\n/**\n * Create new idle transaction.\n */\n\n\nfunction startIdleTransaction(hub, transactionContext, idleTimeout, finalTimeout, onScope, customSamplingContext, heartbeatInterval) {\n  var client = hub.getClient();\n  var options = client && client.getOptions() || {};\n  var transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, heartbeatInterval, onScope);\n  transaction = sample(transaction, options, _objectSpread({\n    parentSampled: transactionContext.parentSampled,\n    transactionContext: transactionContext\n  }, customSamplingContext));\n\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && options._experiments.maxSpans);\n  }\n\n  return transaction;\n}\n/**\n * @private\n */\n\n\nfunction _addTracingExtensions() {\n  var carrier = getMainCarrier();\n\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n}\n/**\n * @private\n */\n\n\nfunction _autoloadDatabaseIntegrations() {\n  var carrier = getMainCarrier();\n\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  var packageToIntegrationMapping = {\n    mongodb: function mongodb() {\n      var integration = dynamicRequire(module, './integrations/node/mongo');\n      return new integration.Mongo();\n    },\n    mongoose: function mongoose() {\n      var integration = dynamicRequire(module, './integrations/node/mongo');\n      return new integration.Mongo({\n        mongoose: true\n      });\n    },\n    mysql: function mysql() {\n      var integration = dynamicRequire(module, './integrations/node/mysql');\n      return new integration.Mysql();\n    },\n    pg: function pg() {\n      var integration = dynamicRequire(module, './integrations/node/postgres');\n      return new integration.Postgres();\n    }\n  };\n  var mappedPackages = Object.keys(packageToIntegrationMapping).filter(function (moduleName) {\n    return !!loadModule(moduleName);\n  }).map(function (pkg) {\n    try {\n      return packageToIntegrationMapping[pkg]();\n    } catch (e) {\n      return undefined;\n    }\n  }).filter(function (p) {\n    return p;\n  });\n\n  if (mappedPackages.length > 0) {\n    carrier.__SENTRY__.integrations = [].concat(_toConsumableArray(carrier.__SENTRY__.integrations || []), _toConsumableArray(mappedPackages));\n  }\n}\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\n\n\nfunction addExtensionMethods() {\n  _addTracingExtensions(); // Detect and automatically load specified integrations.\n\n\n  if (isNodeEnv()) {\n    _autoloadDatabaseIntegrations();\n  } // If an error happens globally, we should make sure transaction status is set to error.\n\n\n  registerErrorInstrumentation();\n}\n\nexport { _addTracingExtensions, addExtensionMethods, startIdleTransaction };","import { isString, isRegExp } from './is.js';\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 */\n\nfunction truncate(str) {\n  var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n\n  return str.length <= max ? str : \"\".concat(str.substr(0, max), \"...\");\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 */\n\n\nfunction snipLine(line, colno) {\n  var newLine = line;\n  var lineLength = newLine.length;\n\n  if (lineLength <= 150) {\n    return newLine;\n  }\n\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  var start = Math.max(colno - 60, 0);\n\n  if (start < 5) {\n    start = 0;\n  }\n\n  var end = Math.min(start + 140, lineLength);\n\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n\n  if (start > 0) {\n    newLine = \"'{snip} \".concat(newLine);\n  }\n\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\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\n\n\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  var output = []; // eslint-disable-next-line @typescript-eslint/prefer-for-of\n\n  for (var i = 0; i < input.length; i++) {\n    var value = input[i];\n\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 * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\n\n\nfunction isMatchingPattern(value, pattern) {\n  var requireExactStringMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\n\n\nfunction stringMatchesSomePattern(testString) {\n  var patterns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  var requireExactStringMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  return patterns.some(function (pattern) {\n    return isMatchingPattern(testString, pattern, requireExactStringMatch);\n  });\n}\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\n\n\nfunction escapeStringForRegex(regexString) {\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\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nfunction _get() { if (typeof Reflect !== \"undefined\" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }\n\nfunction _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nimport { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getCurrentHub } from '@sentry/core';\nimport { timestampInSeconds, logger, dropUndefinedKeys } from '@sentry/utils';\nimport { Span, SpanRecorder } from './span.js';\n/** JSDoc */\n\nvar Transaction = /*#__PURE__*/function (_Span) {\n  _inherits(Transaction, _Span);\n\n  var _super = _createSuper(Transaction);\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  function Transaction(transactionContext, hub) {\n    var _this;\n\n    _classCallCheck(this, Transaction);\n\n    _this = _super.call(this, transactionContext);\n\n    Transaction.prototype.__init.call(_assertThisInitialized(_this));\n\n    Transaction.prototype.__init2.call(_assertThisInitialized(_this));\n\n    Transaction.prototype.__init3.call(_assertThisInitialized(_this));\n\n    ;\n    _this._hub = hub || getCurrentHub();\n    _this._name = transactionContext.name || '';\n    _this.metadata = _objectSpread(_objectSpread({\n      source: 'custom'\n    }, transactionContext.metadata), {}, {\n      spanMetadata: {},\n      changes: [],\n      propagations: 0\n    });\n    _this._trimEnd = transactionContext.trimEnd; // this is because transactions are also spans, and spans have a transaction pointer\n\n    _this.transaction = _assertThisInitialized(_this); // If Dynamic Sampling Context is provided during the creation of the transaction, we freeze it as it usually means\n    // there is incoming Dynamic Sampling Context. (Either through an incoming request, a baggage meta-tag, or other means)\n\n    var incomingDynamicSamplingContext = _this.metadata.dynamicSamplingContext;\n\n    if (incomingDynamicSamplingContext) {\n      // We shallow copy this in case anything writes to the original reference of the passed in `dynamicSamplingContext`\n      _this._frozenDynamicSamplingContext = _objectSpread({}, incomingDynamicSamplingContext);\n    }\n\n    return _this;\n  }\n  /** Getter for `name` property */\n\n\n  _createClass(Transaction, [{\n    key: \"__init\",\n    value:\n    /**\n     * The reference to the current hub.\n     */\n    function __init() {\n      this._measurements = {};\n    }\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._contexts = {};\n    }\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      this._frozenDynamicSamplingContext = undefined;\n    }\n  }, {\n    key: \"name\",\n    get: function get() {\n      return this._name;\n    }\n    /** Setter for `name` property, which also sets `source` as custom */\n    ,\n    set: function set(newName) {\n      this.setName(newName);\n    }\n    /**\n     * JSDoc\n     */\n\n  }, {\n    key: \"setName\",\n    value: function setName(name) {\n      var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'custom';\n\n      // `source` could change without the name changing if we discover that an unparameterized route is actually\n      // parameterized by virtue of having no parameters in its path\n      if (name !== this.name || source !== this.metadata.source) {\n        this.metadata.changes.push({\n          // log previous source\n          source: this.metadata.source,\n          timestamp: timestampInSeconds(),\n          propagations: this.metadata.propagations\n        });\n      }\n\n      this._name = name;\n      this.metadata.source = source;\n    }\n    /**\n     * Attaches SpanRecorder to the span itself\n     * @param maxlen maximum number of spans that can be recorded\n     */\n\n  }, {\n    key: \"initSpanRecorder\",\n    value: function initSpanRecorder() {\n      var maxlen = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;\n\n      if (!this.spanRecorder) {\n        this.spanRecorder = new SpanRecorder(maxlen);\n      }\n\n      this.spanRecorder.add(this);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setContext\",\n    value: function setContext(key, context) {\n      if (context === null) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n        delete this._contexts[key];\n      } else {\n        this._contexts[key] = context;\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setMeasurement\",\n    value: function setMeasurement(name, value) {\n      var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n      this._measurements[name] = {\n        value: value,\n        unit: unit\n      };\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setMetadata\",\n    value: function setMetadata(newMetadata) {\n      this.metadata = _objectSpread(_objectSpread({}, this.metadata), newMetadata);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"finish\",\n    value: function finish(endTimestamp) {\n      var _this2 = this;\n\n      // This transaction is already finished, so we should not flush it again.\n      if (this.endTimestamp !== undefined) {\n        return undefined;\n      }\n\n      if (!this.name) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n        this.name = '<unlabeled transaction>';\n      } // just sets the end timestamp\n\n\n      _get(_getPrototypeOf(Transaction.prototype), \"finish\", this).call(this, endTimestamp);\n\n      if (this.sampled !== true) {\n        // At this point if `sampled !== true` we want to discard the transaction.\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n        var client = this._hub.getClient();\n\n        if (client) {\n          client.recordDroppedEvent('sample_rate', 'transaction');\n        }\n\n        return undefined;\n      }\n\n      var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(function (s) {\n        return s !== _this2 && s.endTimestamp;\n      }) : [];\n\n      if (this._trimEnd && finishedSpans.length > 0) {\n        this.endTimestamp = finishedSpans.reduce(function (prev, current) {\n          if (prev.endTimestamp && current.endTimestamp) {\n            return prev.endTimestamp > current.endTimestamp ? prev : current;\n          }\n\n          return prev;\n        }).endTimestamp;\n      }\n\n      var metadata = this.metadata;\n\n      var transaction = _objectSpread({\n        contexts: _objectSpread(_objectSpread({}, this._contexts), {}, {\n          // We don't want to override trace context\n          trace: this.getTraceContext()\n        }),\n        spans: finishedSpans,\n        start_timestamp: this.startTimestamp,\n        tags: this.tags,\n        timestamp: this.endTimestamp,\n        transaction: this.name,\n        type: 'transaction',\n        sdkProcessingMetadata: _objectSpread(_objectSpread({}, metadata), {}, {\n          dynamicSamplingContext: this.getDynamicSamplingContext()\n        })\n      }, metadata.source && {\n        transaction_info: {\n          source: metadata.source,\n          changes: metadata.changes,\n          propagations: metadata.propagations\n        }\n      });\n\n      var hasMeasurements = Object.keys(this._measurements).length > 0;\n\n      if (hasMeasurements) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding measurements to transaction', JSON.stringify(this._measurements, undefined, 2));\n        transaction.measurements = this._measurements;\n      }\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Finishing \".concat(this.op, \" transaction: \").concat(this.name, \".\"));\n      return this._hub.captureEvent(transaction);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"toContext\",\n    value: function toContext() {\n      var spanContext = _get(_getPrototypeOf(Transaction.prototype), \"toContext\", this).call(this);\n\n      return dropUndefinedKeys(_objectSpread(_objectSpread({}, spanContext), {}, {\n        name: this.name,\n        trimEnd: this._trimEnd\n      }));\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"updateWithContext\",\n    value: function updateWithContext(transactionContext) {\n      _get(_getPrototypeOf(Transaction.prototype), \"updateWithContext\", this).call(this, transactionContext);\n\n      this.name = _nullishCoalesce(transactionContext.name, function () {\n        return '';\n      });\n      this._trimEnd = transactionContext.trimEnd;\n      return this;\n    }\n    /**\n     * @inheritdoc\n     *\n     * @experimental\n     */\n\n  }, {\n    key: \"getDynamicSamplingContext\",\n    value: function getDynamicSamplingContext() {\n      if (this._frozenDynamicSamplingContext) {\n        return this._frozenDynamicSamplingContext;\n      }\n\n      var hub = this._hub || getCurrentHub();\n      var client = hub && hub.getClient();\n      if (!client) return {};\n\n      var _ref = client.getOptions() || {},\n          environment = _ref.environment,\n          release = _ref.release;\n\n      var _ref2 = client.getDsn() || {},\n          public_key = _ref2.publicKey;\n\n      var maybeSampleRate = this.metadata.sampleRate;\n      var sample_rate = maybeSampleRate !== undefined ? maybeSampleRate.toString() : undefined;\n      var scope = hub.getScope();\n\n      var _ref3 = scope && scope.getUser() || {},\n          user_segment = _ref3.segment;\n\n      var source = this.metadata.source; // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n\n      var transaction = source && source !== 'url' ? this.name : undefined;\n      var dsc = dropUndefinedKeys({\n        environment: environment,\n        release: release,\n        transaction: transaction,\n        user_segment: user_segment,\n        public_key: public_key,\n        trace_id: this.traceId,\n        sample_rate: sample_rate\n      }); // Uncomment if we want to make DSC immutable\n      // this._frozenDynamicSamplingContext = dsc;\n\n      return dsc;\n    }\n  }]);\n\n  return Transaction;\n}(Span);\n\nexport { Transaction };","/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nfunction _nullishCoalesce(lhs, rhsFn) {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n} // Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n\n\nexport { _nullishCoalesce };","module.exports = function (originalModule) {\n  if (!originalModule.webpackPolyfill) {\n    var module = Object.create(originalModule); // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    Object.defineProperty(module, \"exports\", {\n      enumerable: true\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { urlEncode, makeDsn, dsnToString } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\n\nfunction getBaseApiEndpoint(dsn) {\n  var protocol = dsn.protocol ? \"\".concat(dsn.protocol, \":\") : '';\n  var port = dsn.port ? \":\".concat(dsn.port) : '';\n  return \"\".concat(protocol, \"//\").concat(dsn.host).concat(port).concat(dsn.path ? \"/\".concat(dsn.path) : '', \"/api/\");\n}\n/** Returns the ingest API endpoint for target. */\n\n\nfunction _getIngestEndpoint(dsn) {\n  return \"\".concat(getBaseApiEndpoint(dsn)).concat(dsn.projectId, \"/envelope/\");\n}\n/** Returns a URL-encoded string with auth config suitable for a query string. */\n\n\nfunction _encodedAuth(dsn, sdkInfo) {\n  return urlEncode(_objectSpread({\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 && {\n    sentry_client: \"\".concat(sdkInfo.name, \"/\").concat(sdkInfo.version)\n  }));\n}\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\n\n\nfunction getEnvelopeEndpointWithUrlEncodedAuth(dsn) {\n  var tunnelOrOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n  var tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  var sdkInfo = typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n  return tunnel ? tunnel : \"\".concat(_getIngestEndpoint(dsn), \"?\").concat(_encodedAuth(dsn, sdkInfo));\n}\n/** Returns the url to the report dialog endpoint. */\n\n\nfunction getReportDialogEndpoint(dsnLike, dialogOptions) {\n  var dsn = makeDsn(dsnLike);\n  var endpoint = \"\".concat(getBaseApiEndpoint(dsn), \"embed/error-page/\");\n  var encodedOptions = \"dsn=\".concat(dsnToString(dsn));\n\n  for (var key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      var user = dialogOptions.user;\n\n      if (!user) {\n        continue;\n      }\n\n      if (user.name) {\n        encodedOptions += \"&name=\".concat(encodeURIComponent(user.name));\n      }\n\n      if (user.email) {\n        encodedOptions += \"&email=\".concat(encodeURIComponent(user.email));\n      }\n    } else {\n      encodedOptions += \"&\".concat(encodeURIComponent(key), \"=\").concat(encodeURIComponent(dialogOptions[key]));\n    }\n  }\n\n  return \"\".concat(endpoint, \"?\").concat(encodedOptions);\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { isThenable } from './is.js';\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\n\nvar States;\n\n(function (States) {\n  /** Pending */\n  var PENDING = 0;\n  States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n\n  var RESOLVED = 1;\n  States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n\n  var REJECTED = 2;\n  States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {})); // Overloads so we can call resolvedSyncPromise without arguments and generic argument\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 */\n\n\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(function (resolve) {\n    resolve(value);\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 */\n\n\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise(function (_, reject) {\n    reject(reason);\n  });\n}\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\n\n\nvar SyncPromise = /*#__PURE__*/function () {\n  function SyncPromise(executor) {\n    _classCallCheck(this, SyncPromise);\n\n    ;\n\n    SyncPromise.prototype.__init.call(this);\n\n    SyncPromise.prototype.__init2.call(this);\n\n    SyncPromise.prototype.__init3.call(this);\n\n    SyncPromise.prototype.__init4.call(this);\n\n    SyncPromise.prototype.__init5.call(this);\n\n    SyncPromise.prototype.__init6.call(this);\n\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n  /** JSDoc */\n\n\n  _createClass(SyncPromise, [{\n    key: \"__init\",\n    value: function __init() {\n      this._state = States.PENDING;\n    }\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._handlers = [];\n    }\n  }, {\n    key: \"then\",\n    value: function then(onfulfilled, onrejected) {\n      var _this = this;\n\n      return new SyncPromise(function (resolve, reject) {\n        _this._handlers.push([false, function (result) {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        }, function (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    /** JSDoc */\n\n  }, {\n    key: \"catch\",\n    value: function _catch(onrejected) {\n      return this.then(function (val) {\n        return val;\n      }, onrejected);\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"finally\",\n    value: function _finally(onfinally) {\n      var _this2 = this;\n\n      return new SyncPromise(function (resolve, reject) {\n        var val;\n        var isRejected;\n        return _this2.then(function (value) {\n          isRejected = false;\n          val = value;\n\n          if (onfinally) {\n            onfinally();\n          }\n        }, function (reason) {\n          isRejected = true;\n          val = reason;\n\n          if (onfinally) {\n            onfinally();\n          }\n        }).then(function () {\n          if (isRejected) {\n            reject(val);\n            return;\n          }\n\n          resolve(val);\n        });\n      });\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      var _this3 = this;\n\n      this._resolve = function (value) {\n        _this3._setResult(States.RESOLVED, value);\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init4\",\n    value: function __init4() {\n      var _this4 = this;\n\n      this._reject = function (reason) {\n        _this4._setResult(States.REJECTED, reason);\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init5\",\n    value: function __init5() {\n      var _this5 = this;\n\n      this._setResult = function (state, value) {\n        if (_this5._state !== States.PENDING) {\n          return;\n        }\n\n        if (isThenable(value)) {\n          void value.then(_this5._resolve, _this5._reject);\n          return;\n        }\n\n        _this5._state = state;\n        _this5._value = value;\n\n        _this5._executeHandlers();\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init6\",\n    value: function __init6() {\n      var _this6 = this;\n\n      this._executeHandlers = function () {\n        if (_this6._state === States.PENDING) {\n          return;\n        }\n\n        var cachedHandlers = _this6._handlers.slice();\n\n        _this6._handlers = [];\n        cachedHandlers.forEach(function (handler) {\n          if (handler[0]) {\n            return;\n          }\n\n          if (_this6._state === States.RESOLVED) {\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\n            handler[1](_this6._value);\n          }\n\n          if (_this6._state === States.REJECTED) {\n            handler[2](_this6._value);\n          }\n\n          handler[0] = true;\n        });\n      };\n    }\n  }]);\n\n  return SyncPromise;\n}();\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { arrayify, logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\nimport { addGlobalEventProcessor } from './scope.js';\nvar installedIntegrations = [];\n/** Map of integrations assigned to a client */\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 */\n\nfunction filterDuplicates(integrations) {\n  var integrationsByName = {};\n  integrations.forEach(function (currentInstance) {\n    var name = currentInstance.name;\n    var existingInstance = integrationsByName[name]; // 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\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n  return Object.values(integrationsByName);\n}\n/** Gets integrations to install */\n\n\nfunction getIntegrationsToSetup(options) {\n  var defaultIntegrations = options.defaultIntegrations || [];\n  var userIntegrations = options.integrations; // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n\n  defaultIntegrations.forEach(function (integration) {\n    integration.isDefaultInstance = true;\n  });\n  var integrations;\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [].concat(_toConsumableArray(defaultIntegrations), _toConsumableArray(userIntegrations));\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  var finalIntegrations = filterDuplicates(integrations); // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend` or\n  // `beforeSendTransaction`. It therefore has to run after all other integrations, so that the changes of all event\n  // processors will be reflected in the printed values. For lack of a more elegant way to guarantee that, we therefore\n  // locate it and, assuming it exists, pop it out of its current spot and shove it onto the end of the array.\n\n  var debugIndex = finalIntegrations.findIndex(function (integration) {\n    return integration.name === 'Debug';\n  });\n\n  if (debugIndex !== -1) {\n    var _finalIntegrations$sp = finalIntegrations.splice(debugIndex, 1),\n        _finalIntegrations$sp2 = _slicedToArray(_finalIntegrations$sp, 1),\n        debugInstance = _finalIntegrations$sp2[0];\n\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\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 */\n\n\nfunction setupIntegrations(integrations) {\n  var integrationIndex = {};\n  integrations.forEach(function (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      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"Integration installed: \".concat(integration.name));\n    }\n  });\n  return integrationIndex;\n}\n\nexport { getIntegrationsToSetup, installedIntegrations, setupIntegrations };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { _optionalChain } from './buildPolyfills';\nvar STACKTRACE_LIMIT = 50;\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 */\n\nfunction createStackParser() {\n  for (var _len = arguments.length, parsers = new Array(_len), _key = 0; _key < _len; _key++) {\n    parsers[_key] = arguments[_key];\n  }\n\n  var sortedParsers = parsers.sort(function (a, b) {\n    return a[0] - b[0];\n  }).map(function (p) {\n    return p[1];\n  });\n  return function (stack) {\n    var skipFirst = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    var frames = [];\n\n    var _iterator = _createForOfIteratorHelper(stack.split('\\n').slice(skipFirst)),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var line = _step.value;\n        // https://github.com/getsentry/sentry-javascript/issues/5459\n        // Remove webpack (error: *) wrappers\n        var cleanedLine = line.replace(/\\(error: (.*)\\)/, '$1');\n\n        var _iterator2 = _createForOfIteratorHelper(sortedParsers),\n            _step2;\n\n        try {\n          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n            var parser = _step2.value;\n            var frame = parser(cleanedLine);\n\n            if (frame) {\n              frames.push(frame);\n              break;\n            }\n          }\n        } catch (err) {\n          _iterator2.e(err);\n        } finally {\n          _iterator2.f();\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    return stripSentryFramesAndReverse(frames);\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 */\n\n\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser.apply(void 0, _toConsumableArray(stackParser));\n  }\n\n  return stackParser;\n}\n/**\n * @hidden\n */\n\n\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  var localStack = stack;\n  var firstFrameFunction = localStack[0].function || '';\n  var lastFrameFunction = localStack[localStack.length - 1].function || ''; // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\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\n\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  } // The frame where the crash happened, should be the last entry in the array\n\n\n  return localStack.slice(0, STACKTRACE_LIMIT).map(function (frame) {\n    return _objectSpread(_objectSpread({}, frame), {}, {\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?'\n    });\n  }).reverse();\n}\n\nvar defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\n\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\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} // eslint-disable-next-line complexity\n\n\nfunction node(getModule) {\n  var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/; // eslint-disable-next-line complexity\n\n  return function (line) {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line\n      };\n    }\n\n    var lineMatch = line.match(FULL_MATCH);\n\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    var object;\n    var method;\n    var functionName;\n    var typeName;\n    var methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n      var methodStart = functionName.lastIndexOf('.');\n\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        var objectEnd = object.indexOf('.Module');\n\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\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 ? \"\".concat(typeName, \".\").concat(methodName) : methodName;\n    }\n\n    var filename = _optionalChain([lineMatch, 'access', function (_) {\n      return _[2];\n    }, 'optionalAccess', function (_2) {\n      return _2.startsWith;\n    }, 'call', function (_3) {\n      return _3('file://');\n    }]) ? lineMatch[2].substr(7) : lineMatch[2];\n    var isNative = lineMatch[5] === 'native';\n    var isInternal = isNative || filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1; // 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\n    var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n    return {\n      filename: filename,\n      module: _optionalChain([getModule, 'optionalCall', function (_4) {\n        return _4(filename);\n      }]),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app: in_app\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 */\n\n\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };","import { GLOBAL_OBJ, getGlobalSingleton } from './worldwide.js';\n/** Prefix for logging strings */\n\nvar PREFIX = 'Sentry Logger ';\nvar CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'];\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 */\n\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  var originalConsole = GLOBAL_OBJ.console;\n  var wrappedLevels = {}; // Restore all wrapped console methods\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    var originalWrappedFunc = originalConsole[level] && originalConsole[level].__sentry_original__;\n\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level];\n      originalConsole[level] = originalWrappedFunc;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n      originalConsole[level] = wrappedLevels[level];\n    });\n  }\n}\n\nfunction makeLogger() {\n  var enabled = false;\n  var logger = {\n    enable: function enable() {\n      enabled = true;\n    },\n    disable: function disable() {\n      enabled = false;\n    }\n  };\n\n  if (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) {\n    CONSOLE_LEVELS.forEach(function (name) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = function () {\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        if (enabled) {\n          consoleSandbox(function () {\n            var _GLOBAL_OBJ$console;\n\n            (_GLOBAL_OBJ$console = GLOBAL_OBJ.console)[name].apply(_GLOBAL_OBJ$console, [\"\".concat(PREFIX, \"[\").concat(name, \"]:\")].concat(args));\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(function (name) {\n      logger[name] = function () {\n        return undefined;\n      };\n    });\n  }\n\n  return logger;\n} // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\n\n\nvar logger;\n\nif (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };","import { getCurrentHub } from '@sentry/core';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\n\nfunction hasTracingEnabled(maybeOptions) {\n  var client = getCurrentHub().getClient();\n  var options = maybeOptions || client && client.getOptions();\n  return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n/** Grabs active transaction off scope, if any */\n\n\nfunction getActiveTransaction(maybeHub) {\n  var hub = maybeHub || getCurrentHub();\n  var scope = hub.getScope();\n  return scope && scope.getTransaction();\n}\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\n\n\nfunction msToSec(time) {\n  return time / 1000;\n}\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\n\n\nfunction secToMs(time) {\n  return time * 1000;\n}\n\nexport { getActiveTransaction, hasTracingEnabled, msToSec, secToMs };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, isNodeEnv, getGlobalSingleton } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\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 */\n\nvar API_VERSION = 4;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\n\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\n\nvar Hub = /*#__PURE__*/function () {\n  /** Contains the last event id of a captured event.  */\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  function Hub(client) {\n    var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Scope();\n\n    var _version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : API_VERSION;\n\n    _classCallCheck(this, Hub);\n\n    ;\n    this._version = _version;\n\n    Hub.prototype.__init.call(this);\n\n    this.getStackTop().scope = scope;\n\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  _createClass(Hub, [{\n    key: \"__init\",\n    value:\n    /** Is a {@link Layer}[] containing the client and scope */\n    function __init() {\n      this._stack = [{}];\n    }\n  }, {\n    key: \"isOlderThan\",\n    value: function isOlderThan(version) {\n      return this._version < version;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"bindClient\",\n    value: function bindClient(client) {\n      var top = this.getStackTop();\n      top.client = client;\n\n      if (client && client.setupIntegrations) {\n        client.setupIntegrations();\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"pushScope\",\n    value: function pushScope() {\n      // We want to clone the content of prev scope\n      var scope = Scope.clone(this.getScope());\n      this.getStack().push({\n        client: this.getClient(),\n        scope: scope\n      });\n      return scope;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"popScope\",\n    value: function popScope() {\n      if (this.getStack().length <= 1) return false;\n      return !!this.getStack().pop();\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"withScope\",\n    value: function withScope(callback) {\n      var scope = this.pushScope();\n\n      try {\n        callback(scope);\n      } finally {\n        this.popScope();\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getClient\",\n    value: function getClient() {\n      return this.getStackTop().client;\n    }\n    /** Returns the scope of the top stack. */\n\n  }, {\n    key: \"getScope\",\n    value: function getScope() {\n      return this.getStackTop().scope;\n    }\n    /** Returns the scope stack for domains or the process. */\n\n  }, {\n    key: \"getStack\",\n    value: function getStack() {\n      return this._stack;\n    }\n    /** Returns the topmost scope layer in the order domain > local > process. */\n\n  }, {\n    key: \"getStackTop\",\n    value: function getStackTop() {\n      return this._stack[this._stack.length - 1];\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n  }, {\n    key: \"captureException\",\n    value: function captureException(exception, hint) {\n      var eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();\n      var syntheticException = new Error('Sentry syntheticException');\n\n      this._withClient(function (client, scope) {\n        client.captureException(exception, _objectSpread(_objectSpread({\n          originalException: exception,\n          syntheticException: syntheticException\n        }, hint), {}, {\n          event_id: eventId\n        }), scope);\n      });\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureMessage\",\n    value: function captureMessage(message, // eslint-disable-next-line deprecation/deprecation\n    level, hint) {\n      var eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();\n      var syntheticException = new Error(message);\n\n      this._withClient(function (client, scope) {\n        client.captureMessage(message, level, _objectSpread(_objectSpread({\n          originalException: message,\n          syntheticException: syntheticException\n        }, hint), {}, {\n          event_id: eventId\n        }), scope);\n      });\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureEvent\",\n    value: function captureEvent(event, hint) {\n      var eventId = hint && hint.event_id ? hint.event_id : uuid4();\n\n      if (event.type !== 'transaction') {\n        this._lastEventId = eventId;\n      }\n\n      this._withClient(function (client, scope) {\n        client.captureEvent(event, _objectSpread(_objectSpread({}, hint), {}, {\n          event_id: eventId\n        }), scope);\n      });\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"lastEventId\",\n    value: function lastEventId() {\n      return this._lastEventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"addBreadcrumb\",\n    value: function addBreadcrumb(breadcrumb, hint) {\n      var _this$getStackTop = this.getStackTop(),\n          scope = _this$getStackTop.scope,\n          client = _this$getStackTop.client;\n\n      if (!scope || !client) return; // eslint-disable-next-line @typescript-eslint/unbound-method\n\n      var _ref = client.getOptions && client.getOptions() || {},\n          _ref$beforeBreadcrumb = _ref.beforeBreadcrumb,\n          beforeBreadcrumb = _ref$beforeBreadcrumb === void 0 ? null : _ref$beforeBreadcrumb,\n          _ref$maxBreadcrumbs = _ref.maxBreadcrumbs,\n          maxBreadcrumbs = _ref$maxBreadcrumbs === void 0 ? DEFAULT_BREADCRUMBS : _ref$maxBreadcrumbs;\n\n      if (maxBreadcrumbs <= 0) return;\n      var timestamp = dateTimestampInSeconds();\n\n      var mergedBreadcrumb = _objectSpread({\n        timestamp: timestamp\n      }, breadcrumb);\n\n      var finalBreadcrumb = beforeBreadcrumb ? consoleSandbox(function () {\n        return beforeBreadcrumb(mergedBreadcrumb, hint);\n      }) : mergedBreadcrumb;\n      if (finalBreadcrumb === null) return;\n      scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setUser\",\n    value: function setUser(user) {\n      var scope = this.getScope();\n      if (scope) scope.setUser(user);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTags\",\n    value: function setTags(tags) {\n      var scope = this.getScope();\n      if (scope) scope.setTags(tags);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setExtras\",\n    value: function setExtras(extras) {\n      var scope = this.getScope();\n      if (scope) scope.setExtras(extras);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setTag\",\n    value: function setTag(key, value) {\n      var scope = this.getScope();\n      if (scope) scope.setTag(key, value);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"setExtra\",\n    value: function setExtra(key, extra) {\n      var scope = this.getScope();\n      if (scope) scope.setExtra(key, extra);\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  }, {\n    key: \"setContext\",\n    value: function setContext(name, context) {\n      var scope = this.getScope();\n      if (scope) scope.setContext(name, context);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"configureScope\",\n    value: function configureScope(callback) {\n      var _this$getStackTop2 = this.getStackTop(),\n          scope = _this$getStackTop2.scope,\n          client = _this$getStackTop2.client;\n\n      if (scope && client) {\n        callback(scope);\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"run\",\n    value: function run(callback) {\n      var oldHub = makeMain(this);\n\n      try {\n        callback(this);\n      } finally {\n        makeMain(oldHub);\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getIntegration\",\n    value: function getIntegration(integration) {\n      var client = this.getClient();\n      if (!client) return null;\n\n      try {\n        return client.getIntegration(integration);\n      } catch (_oO) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Cannot retrieve integration \".concat(integration.id, \" from the current Hub\"));\n        return null;\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"startTransaction\",\n    value: function startTransaction(context, customSamplingContext) {\n      return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"traceHeaders\",\n    value: function traceHeaders() {\n      return this._callExtensionMethod('traceHeaders');\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureSession\",\n    value: function captureSession() {\n      var endSession = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      // both send the update and pull the session from the scope\n      if (endSession) {\n        return this.endSession();\n      } // only send the update\n\n\n      this._sendSessionUpdate();\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"endSession\",\n    value: function endSession() {\n      var layer = this.getStackTop();\n      var scope = layer && layer.scope;\n      var session = scope && scope.getSession();\n\n      if (session) {\n        closeSession(session);\n      }\n\n      this._sendSessionUpdate(); // the session is over; take it off of the scope\n\n\n      if (scope) {\n        scope.setSession();\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"startSession\",\n    value: function startSession(context) {\n      var _this$getStackTop3 = this.getStackTop(),\n          scope = _this$getStackTop3.scope,\n          client = _this$getStackTop3.client;\n\n      var _ref2 = client && client.getOptions() || {},\n          release = _ref2.release,\n          environment = _ref2.environment; // Will fetch userAgent if called from browser sdk\n\n\n      var _ref3 = GLOBAL_OBJ.navigator || {},\n          userAgent = _ref3.userAgent;\n\n      var session = makeSession(_objectSpread(_objectSpread(_objectSpread({\n        release: release,\n        environment: environment\n      }, scope && {\n        user: scope.getUser()\n      }), userAgent && {\n        userAgent: userAgent\n      }), context));\n\n      if (scope) {\n        // End existing session if there's one\n        var currentSession = scope.getSession && scope.getSession();\n\n        if (currentSession && currentSession.status === 'ok') {\n          updateSession(currentSession, {\n            status: 'exited'\n          });\n        }\n\n        this.endSession(); // Afterwards we set the new session on the scope\n\n        scope.setSession(session);\n      }\n\n      return session;\n    }\n    /**\n     * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n     * when Tracing is used.\n     */\n\n  }, {\n    key: \"shouldSendDefaultPii\",\n    value: function shouldSendDefaultPii() {\n      var client = this.getClient();\n      var options = client && client.getOptions();\n      return Boolean(options && options.sendDefaultPii);\n    }\n    /**\n     * Sends the current Session on the scope\n     */\n\n  }, {\n    key: \"_sendSessionUpdate\",\n    value: function _sendSessionUpdate() {\n      var _this$getStackTop4 = this.getStackTop(),\n          scope = _this$getStackTop4.scope,\n          client = _this$getStackTop4.client;\n\n      if (!scope) return;\n      var session = scope.getSession();\n\n      if (session) {\n        if (client && client.captureSession) {\n          client.captureSession(session);\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\n  }, {\n    key: \"_withClient\",\n    value: function _withClient(callback) {\n      var _this$getStackTop5 = this.getStackTop(),\n          scope = _this$getStackTop5.scope,\n          client = _this$getStackTop5.client;\n\n      if (client) {\n        callback(client, scope);\n      }\n    }\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  }, {\n    key: \"_callExtensionMethod\",\n    value: function _callExtensionMethod(method) {\n      var carrier = getMainCarrier();\n      var sentry = carrier.__SENTRY__;\n\n      if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        return sentry.extensions[method].apply(this, args);\n      }\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Extension method \".concat(method, \" couldn't be found, doing nothing.\"));\n    }\n  }]);\n\n  return Hub;\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 **/\n\n\nfunction getMainCarrier() {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined\n  };\n  return GLOBAL_OBJ;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\n\n\nfunction makeMain(hub) {\n  var registry = getMainCarrier();\n  var oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\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 */\n\n\nfunction getCurrentHub() {\n  // Get main carrier (global for every environment)\n  var registry = getMainCarrier(); // If there's no hub, or its an old API, assign a new one\n\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  } // Prefer domains over global if they are there (applicable only to Node environment)\n\n\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  } // Return hub that lives on a global object\n\n\n  return getHubFromCarrier(registry);\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 */\n\n\nfunction getHubFromActiveDomain(registry) {\n  try {\n    var sentry = getMainCarrier().__SENTRY__;\n\n    var activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active; // If there's no active domain, just return global hub\n\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    } // If there's no hub on current domain, or it's an old API, assign a new one\n\n\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    } // Return hub that lives on a domain\n\n\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\n\n\nfunction hasHubOnCarrier(carrier) {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\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 */\n\n\nfunction getHubFromCarrier(carrier) {\n  return getGlobalSingleton('hub', function () {\n    return new Hub();\n  }, carrier);\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 */\n\n\nfunction setHubOnCarrier(carrier, hub) {\n  if (!carrier) return false;\n\n  var __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n\n  __SENTRY__.hub = hub;\n  return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };","import { logger } from './logger.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\n\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsDOMError() {\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 * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsFetch() {\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\n\n\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\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 */\n\n\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  } // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n\n\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\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\n\n  var result = false;\n  var doc = WINDOW.document; // eslint-disable-next-line deprecation/deprecation\n\n  if (doc && typeof doc.createElement === 'function') {\n    try {\n      var sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && 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 * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in WINDOW;\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsReferrerPolicy() {\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  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin'\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsHistory() {\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\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  var chrome = WINDOW.chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n  var hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nvar objectToString = Object.prototype.toString;\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 */\n\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n\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 */\n\n\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === \"[object \".concat(className, \"]\");\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 */\n\n\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\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 */\n\n\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\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 */\n\n\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\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 */\n\n\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\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 */\n\n\nfunction isPrimitive(wat) {\n  return wat === null || _typeof(wat) !== 'object' && typeof wat !== 'function';\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 */\n\n\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\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 */\n\n\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\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 */\n\n\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\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 */\n\n\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\n\n\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\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 */\n\n\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\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 */\n\n\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\n\n\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };","var TRACEPARENT_REGEXP = new RegExp('^[ \\\\t]*' + // whitespace\n'([0-9a-f]{32})?' + // trace_id\n'-?([0-9a-f]{16})?' + // span_id\n'-?([01])?' + // sampled\n'[ \\\\t]*$');\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\n\nfunction extractTraceparentData(traceparent) {\n  var matches = traceparent.match(TRACEPARENT_REGEXP);\n\n  if (!traceparent || !matches) {\n    // empty string or no matches is invalid traceparent data\n    return undefined;\n  }\n\n  var parentSampled;\n\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled: parentSampled,\n    parentSpanId: matches[2]\n  };\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData };","import { logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\n/** A class object that can instantiate Client objects. */\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 */\n\nfunction initAndBind(clientClass, options) {\n  if (options.debug === true) {\n    if (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) {\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\n  var hub = getCurrentHub();\n  var scope = hub.getScope();\n\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  var client = new clientClass(options);\n  hub.bindClient(client);\n}\n\nexport { initAndBind };","var SDK_VERSION = '7.20.1';\nexport { SDK_VERSION };","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\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 */\n\nfunction makePromiseBuffer(limit) {\n  var buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n\n\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\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\n\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    } // start the task and add its promise to the queue\n\n\n    var task = taskProducer();\n\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n\n    void task.then(function () {\n      return 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, function () {\n      return remove(task).then(null, function () {// We have to add another catch here because `remove()` starts a new promise chain.\n      });\n    });\n    return task;\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\n\n  function drain(timeout) {\n    return new SyncPromise(function (resolve, reject) {\n      var counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      } // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n\n\n      var capturedSetTimeout = setTimeout(function () {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout); // if all promises resolve in time, cancel the timer and resolve to `true`\n\n      buffer.forEach(function (item) {\n        void resolvedSyncPromise(item).then(function () {\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: add,\n    drain: drain\n  };\n}\n\nexport { makePromiseBuffer };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nvar 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 */\n\nfunction parseRetryAfterHeader(header) {\n  var now = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Date.now();\n  var headerDelay = parseInt(\"\".concat(header), 10);\n\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  var headerDate = Date.parse(\"\".concat(header));\n\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\n\n\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n/**\n * Checks if a category is rate limited\n */\n\n\nfunction isRateLimited(limits, category) {\n  var now = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Date.now();\n  return disabledUntil(limits, category) > now;\n}\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\n\n\nfunction updateRateLimits(limits, _ref) {\n  var statusCode = _ref.statusCode,\n      headers = _ref.headers;\n  var now = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Date.now();\n\n  var updatedRateLimits = _objectSpread({}, limits); // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n\n\n  var rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  var 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    var _iterator = _createForOfIteratorHelper(rateLimitHeader.trim().split(',')),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var limit = _step.value;\n\n        var _limit$split = limit.split(':', 2),\n            _limit$split2 = _slicedToArray(_limit$split, 2),\n            retryAfter = _limit$split2[0],\n            categories = _limit$split2[1];\n\n        var headerDelay = parseInt(retryAfter, 10);\n        var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n\n        if (!categories) {\n          updatedRateLimits.all = now + delay;\n        } else {\n          var _iterator2 = _createForOfIteratorHelper(categories.split(';')),\n              _step2;\n\n          try {\n            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n              var category = _step2.value;\n              updatedRateLimits[category] = now + delay;\n            }\n          } catch (err) {\n            _iterator2.e(err);\n          } finally {\n            _iterator2.f();\n          }\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\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\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };","import { forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError, makePromiseBuffer } from '@sentry/utils';\nvar DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\n\nfunction createTransport(options, makeRequest) {\n  var buffer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE);\n  var rateLimits = {};\n\n  var flush = function flush(timeout) {\n    return buffer.drain(timeout);\n  };\n\n  function send(envelope) {\n    var filteredEnvelopeItems = []; // Drop rate limited items from envelope\n\n    forEachEnvelopeItem(envelope, function (item, type) {\n      var envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    }); // Skip sending if envelope is empty after filtering out rate limited events\n\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n    var filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems); // Creates client report for each item in an envelope\n\n    var recordEnvelopeLoss = function recordEnvelopeLoss(reason) {\n      forEachEnvelopeItem(filteredEnvelope, function (_, type) {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    var requestTask = function requestTask() {\n      return makeRequest({\n        body: serializeEnvelope(filteredEnvelope, options.textEncoder)\n      }).then(function (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          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Sentry responded with status code \".concat(response.statusCode, \" to sent event.\"));\n        }\n\n        rateLimits = updateRateLimits(rateLimits, response);\n      }, function (error) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n        recordEnvelopeLoss('network_error');\n      });\n    };\n\n    return buffer.add(requestTask).then(function (result) {\n      return result;\n    }, function (error) {\n      if (error instanceof SentryError) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && 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  return {\n    send: send,\n    flush: flush\n  };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { dsnToString, createEnvelope, dropUndefinedKeys } from '@sentry/utils';\n/** Extract sdk info from from the API metadata */\n\nfunction getSdkMetadataForEnvelopeHeader(metadata) {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n\n  var _metadata$sdk = metadata.sdk,\n      name = _metadata$sdk.name,\n      version = _metadata$sdk.version;\n  return {\n    name: name,\n    version: version\n  };\n}\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\n\n\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\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 = [].concat(_toConsumableArray(event.sdk.integrations || []), _toConsumableArray(sdkInfo.integrations || []));\n  event.sdk.packages = [].concat(_toConsumableArray(event.sdk.packages || []), _toConsumableArray(sdkInfo.packages || []));\n  return event;\n}\n/** Creates an envelope from a Session */\n\n\nfunction createSessionEnvelope(session, dsn, metadata, tunnel) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n\n  var envelopeHeaders = _objectSpread(_objectSpread({\n    sent_at: new Date().toISOString()\n  }, sdkInfo && {\n    sdk: sdkInfo\n  }), !!tunnel && {\n    dsn: dsnToString(dsn)\n  });\n\n  var envelopeItem = 'aggregates' in session ? [{\n    type: 'sessions'\n  }, session] : [{\n    type: 'session'\n  }, session];\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n/**\n * Create an Envelope from an event.\n */\n\n\nfunction createEventEnvelope(event, dsn, metadata, tunnel) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var eventType = event.type || 'event';\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n  var envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn); // 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\n  delete event.sdkProcessingMetadata;\n  var eventItem = [{\n    type: eventType\n  }, event];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {\n  var dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return _objectSpread(_objectSpread(_objectSpread({\n    event_id: event.event_id,\n    sent_at: new Date().toISOString()\n  }, sdkInfo && {\n    sdk: sdkInfo\n  }), !!tunnel && {\n    dsn: dsnToString(dsn)\n  }), event.type === 'transaction' && dynamicSamplingContext && {\n    trace: dropUndefinedKeys(_objectSpread({}, dynamicSamplingContext))\n  });\n}\n\nexport { createEventEnvelope, createSessionEnvelope };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, uuid4, dateTimestampInSeconds, normalize, truncate, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegrations as _setupIntegrations } from './integration.js';\nimport { Scope } from './scope.js';\nimport { updateSession } from './session.js';\nvar ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\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 */\n\nvar BaseClient = /*#__PURE__*/function () {\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n  function BaseClient(options) {\n    _classCallCheck(this, BaseClient);\n\n    ;\n\n    BaseClient.prototype.__init.call(this);\n\n    BaseClient.prototype.__init2.call(this);\n\n    BaseClient.prototype.__init3.call(this);\n\n    BaseClient.prototype.__init4.call(this);\n\n    this._options = options;\n\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport(_objectSpread(_objectSpread({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this)\n      }, options.transportOptions), {}, {\n        url: url\n      }));\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n\n  _createClass(BaseClient, [{\n    key: \"__init\",\n    value:\n    /** Options passed to the SDK. */\n\n    /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n\n    /** Array of set up integrations. */\n    function __init() {\n      this._integrations = {};\n    }\n    /** Indicates whether this client's integrations have been set up. */\n\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      this._integrationsInitialized = false;\n    }\n    /** Number of calls being processed */\n\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      this._numProcessing = 0;\n    }\n    /** Holds flushable  */\n\n  }, {\n    key: \"__init4\",\n    value: function __init4() {\n      this._outcomes = {};\n    }\n  }, {\n    key: \"captureException\",\n    value: function captureException(exception, hint, scope) {\n      var _this = this;\n\n      // ensure we haven't captured this very object before\n      if (checkOrSetAlreadyCaught(exception)) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n        return;\n      }\n\n      var eventId = hint && hint.event_id;\n\n      this._process(this.eventFromException(exception, hint).then(function (event) {\n        return _this._captureEvent(event, hint, scope);\n      }).then(function (result) {\n        eventId = result;\n      }));\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureMessage\",\n    value: function captureMessage(message, // eslint-disable-next-line deprecation/deprecation\n    level, hint, scope) {\n      var _this2 = this;\n\n      var eventId = hint && hint.event_id;\n      var promisedEvent = isPrimitive(message) ? this.eventFromMessage(String(message), level, hint) : this.eventFromException(message, hint);\n\n      this._process(promisedEvent.then(function (event) {\n        return _this2._captureEvent(event, hint, scope);\n      }).then(function (result) {\n        eventId = result;\n      }));\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureEvent\",\n    value: function captureEvent(event, hint, scope) {\n      // ensure we haven't captured this very object before\n      if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n        return;\n      }\n\n      var eventId = hint && hint.event_id;\n\n      this._process(this._captureEvent(event, hint, scope).then(function (result) {\n        eventId = result;\n      }));\n\n      return eventId;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"captureSession\",\n    value: function captureSession(session) {\n      if (!this._isEnabled()) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');\n        return;\n      }\n\n      if (!(typeof session.release === 'string')) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');\n      } else {\n        this.sendSession(session); // After sending, we set init false to indicate it's not the first occurrence\n\n        updateSession(session, {\n          init: false\n        });\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getDsn\",\n    value: function getDsn() {\n      return this._dsn;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getOptions\",\n    value: function getOptions() {\n      return this._options;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getTransport\",\n    value: function getTransport() {\n      return this._transport;\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"flush\",\n    value: function flush(timeout) {\n      var transport = this._transport;\n\n      if (transport) {\n        return this._isClientDoneProcessing(timeout).then(function (clientFinished) {\n          return transport.flush(timeout).then(function (transportFlushed) {\n            return clientFinished && transportFlushed;\n          });\n        });\n      } else {\n        return resolvedSyncPromise(true);\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"close\",\n    value: function close(timeout) {\n      var _this3 = this;\n\n      return this.flush(timeout).then(function (result) {\n        _this3.getOptions().enabled = false;\n        return result;\n      });\n    }\n    /**\n     * Sets up the integrations\n     */\n\n  }, {\n    key: \"setupIntegrations\",\n    value: function setupIntegrations() {\n      if (this._isEnabled() && !this._integrationsInitialized) {\n        this._integrations = _setupIntegrations(this._options.integrations);\n        this._integrationsInitialized = true;\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\n  }, {\n    key: \"getIntegrationById\",\n    value: function getIntegrationById(integrationId) {\n      return this._integrations[integrationId];\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"getIntegration\",\n    value: function getIntegration(integration) {\n      try {\n        return this._integrations[integration.id] || null;\n      } catch (_oO) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Cannot retrieve integration \".concat(integration.id, \" from the current Client\"));\n        return null;\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"sendEvent\",\n    value: function sendEvent(event) {\n      var hint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (this._dsn) {\n        var env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n        var _iterator = _createForOfIteratorHelper(hint.attachments || []),\n            _step;\n\n        try {\n          for (_iterator.s(); !(_step = _iterator.n()).done;) {\n            var attachment = _step.value;\n            env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment, this._options.transportOptions && this._options.transportOptions.textEncoder));\n          }\n        } catch (err) {\n          _iterator.e(err);\n        } finally {\n          _iterator.f();\n        }\n\n        this._sendEnvelope(env);\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"sendSession\",\n    value: function sendSession(session) {\n      if (this._dsn) {\n        var env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n\n        this._sendEnvelope(env);\n      }\n    }\n    /**\n     * @inheritDoc\n     */\n\n  }, {\n    key: \"recordDroppedEvent\",\n    value: function recordDroppedEvent(reason, category) {\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        var key = \"\".concat(reason, \":\").concat(category);\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"Adding outcome: \\\"\".concat(key, \"\\\"\")); // The following works because undefined + 1 === NaN and NaN is falsy\n\n        this._outcomes[key] = this._outcomes[key] + 1 || 1;\n      }\n    }\n    /** Updates existing session based on the provided event */\n\n  }, {\n    key: \"_updateSessionFromEvent\",\n    value: function _updateSessionFromEvent(session, event) {\n      var crashed = false;\n      var errored = false;\n      var exceptions = event.exception && event.exception.values;\n\n      if (exceptions) {\n        errored = true;\n\n        var _iterator2 = _createForOfIteratorHelper(exceptions),\n            _step2;\n\n        try {\n          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n            var ex = _step2.value;\n            var mechanism = ex.mechanism;\n\n            if (mechanism && mechanism.handled === false) {\n              crashed = true;\n              break;\n            }\n          }\n        } catch (err) {\n          _iterator2.e(err);\n        } finally {\n          _iterator2.f();\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\n\n      var sessionNonTerminal = session.status === 'ok';\n      var shouldUpdateAndSend = sessionNonTerminal && session.errors === 0 || sessionNonTerminal && crashed;\n\n      if (shouldUpdateAndSend) {\n        updateSession(session, _objectSpread(_objectSpread({}, crashed && {\n          status: 'crashed'\n        }), {}, {\n          errors: session.errors || Number(errored || crashed)\n        }));\n        this.captureSession(session);\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\n  }, {\n    key: \"_isClientDoneProcessing\",\n    value: function _isClientDoneProcessing(timeout) {\n      var _this4 = this;\n\n      return new SyncPromise(function (resolve) {\n        var ticked = 0;\n        var tick = 1;\n        var interval = setInterval(function () {\n          if (_this4._numProcessing == 0) {\n            clearInterval(interval);\n            resolve(true);\n          } else {\n            ticked += tick;\n\n            if (timeout && ticked >= timeout) {\n              clearInterval(interval);\n              resolve(false);\n            }\n          }\n        }, tick);\n      });\n    }\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n\n  }, {\n    key: \"_isEnabled\",\n    value: function _isEnabled() {\n      return this.getOptions().enabled !== false && this._dsn !== undefined;\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\n  }, {\n    key: \"_prepareEvent\",\n    value: function _prepareEvent(event, hint, scope) {\n      var _this5 = this;\n\n      var _this$getOptions = this.getOptions(),\n          _this$getOptions$norm = _this$getOptions.normalizeDepth,\n          normalizeDepth = _this$getOptions$norm === void 0 ? 3 : _this$getOptions$norm,\n          _this$getOptions$norm2 = _this$getOptions.normalizeMaxBreadth,\n          normalizeMaxBreadth = _this$getOptions$norm2 === void 0 ? 1000 : _this$getOptions$norm2;\n\n      var prepared = _objectSpread(_objectSpread({}, event), {}, {\n        event_id: event.event_id || hint.event_id || uuid4(),\n        timestamp: event.timestamp || dateTimestampInSeconds()\n      });\n\n      this._applyClientOptions(prepared);\n\n      this._applyIntegrationsMetadata(prepared); // 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\n\n      var finalScope = scope;\n\n      if (hint.captureContext) {\n        finalScope = Scope.clone(finalScope).update(hint.captureContext);\n      } // We prepare the result here with a resolved Event.\n\n\n      var result = resolvedSyncPromise(prepared); // This should be the last thing called, since we want that\n      // {@link Hub.addEventProcessor} gets the finished prepared event.\n\n      if (finalScope) {\n        // Collect attachments from the hint and scope\n        var attachments = [].concat(_toConsumableArray(hint.attachments || []), _toConsumableArray(finalScope.getAttachments()));\n\n        if (attachments.length) {\n          hint.attachments = attachments;\n        } // In case we have a hub we reassign it.\n\n\n        result = finalScope.applyToEvent(prepared, hint);\n      }\n\n      return result.then(function (evt) {\n        if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n          return _this5._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n        }\n\n        return evt;\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\n  }, {\n    key: \"_normalizeEvent\",\n    value: function _normalizeEvent(event, depth, maxBreadth) {\n      if (!event) {\n        return null;\n      }\n\n      var normalized = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, event), event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(function (b) {\n          return _objectSpread(_objectSpread({}, b), b.data && {\n            data: normalize(b.data, depth, maxBreadth)\n          });\n        })\n      }), event.user && {\n        user: normalize(event.user, depth, maxBreadth)\n      }), event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth)\n      }), event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth)\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\n\n      if (event.contexts && event.contexts.trace && normalized.contexts) {\n        normalized.contexts.trace = event.contexts.trace; // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n\n        if (event.contexts.trace.data) {\n          normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n        }\n      } // event.spans[].data may contain circular/dangerous data so we need to normalize it\n\n\n      if (event.spans) {\n        normalized.spans = event.spans.map(function (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\n          return span;\n        });\n      }\n\n      return normalized;\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\n  }, {\n    key: \"_applyClientOptions\",\n    value: function _applyClientOptions(event) {\n      var options = this.getOptions();\n      var environment = options.environment,\n          release = options.release,\n          dist = options.dist,\n          _options$maxValueLeng = options.maxValueLength,\n          maxValueLength = _options$maxValueLeng === void 0 ? 250 : _options$maxValueLeng;\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      var exception = event.exception && event.exception.values && event.exception.values[0];\n\n      if (exception && exception.value) {\n        exception.value = truncate(exception.value, maxValueLength);\n      }\n\n      var request = event.request;\n\n      if (request && request.url) {\n        request.url = truncate(request.url, maxValueLength);\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\n  }, {\n    key: \"_applyIntegrationsMetadata\",\n    value: function _applyIntegrationsMetadata(event) {\n      var integrationsArray = Object.keys(this._integrations);\n\n      if (integrationsArray.length > 0) {\n        event.sdk = event.sdk || {};\n        event.sdk.integrations = [].concat(_toConsumableArray(event.sdk.integrations || []), _toConsumableArray(integrationsArray));\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\n  }, {\n    key: \"_captureEvent\",\n    value: function _captureEvent(event) {\n      var hint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var scope = arguments.length > 2 ? arguments[2] : undefined;\n      return this._processEvent(event, hint, scope).then(function (finalEvent) {\n        return finalEvent.event_id;\n      }, function (reason) {\n        if (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) {\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          var sentryError = reason;\n\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n\n        return undefined;\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\n  }, {\n    key: \"_processEvent\",\n    value: function _processEvent(event, hint, scope) {\n      var _this6 = this;\n\n      var options = this.getOptions();\n      var sampleRate = options.sampleRate;\n\n      if (!this._isEnabled()) {\n        return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));\n      }\n\n      var isTransaction = event.type === 'transaction';\n      var beforeSendProcessorName = isTransaction ? 'beforeSendTransaction' : 'beforeSend';\n      var beforeSendProcessor = options[beforeSendProcessorName]; // 1.0 === 100% events are sent\n      // 0.0 === 0% events are sent\n      // Sampling for transaction happens somewhere else\n\n      if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n        this.recordDroppedEvent('sample_rate', 'error');\n        return rejectedSyncPromise(new SentryError(\"Discarding event because it's not included in the random sample (sampling rate = \".concat(sampleRate, \")\"), 'log'));\n      }\n\n      return this._prepareEvent(event, hint, scope).then(function (prepared) {\n        if (prepared === null) {\n          _this6.recordDroppedEvent('event_processor', event.type || 'error');\n\n          throw new SentryError('An event processor returned `null`, will not send event.', 'log');\n        }\n\n        var isInternalException = hint.data && hint.data.__sentry__ === true;\n\n        if (isInternalException || !beforeSendProcessor) {\n          return prepared;\n        }\n\n        var beforeSendResult = beforeSendProcessor(prepared, hint);\n        return _validateBeforeSendResult(beforeSendResult, beforeSendProcessorName);\n      }).then(function (processedEvent) {\n        if (processedEvent === null) {\n          _this6.recordDroppedEvent('before_send', event.type || 'error');\n\n          throw new SentryError(\"`\".concat(beforeSendProcessorName, \"` returned `null`, will not send event.\"), 'log');\n        }\n\n        var session = scope && scope.getSession();\n\n        if (!isTransaction && session) {\n          _this6._updateSessionFromEvent(session, processedEvent);\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\n\n        var transactionInfo = processedEvent.transaction_info;\n\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          var source = 'custom';\n          processedEvent.transaction_info = _objectSpread(_objectSpread({}, transactionInfo), {}, {\n            source: source,\n            changes: [].concat(_toConsumableArray(transactionInfo.changes), [{\n              source: source,\n              // use the same timestamp as the processed event.\n              timestamp: processedEvent.timestamp,\n              propagations: transactionInfo.propagations\n            }])\n          });\n        }\n\n        _this6.sendEvent(processedEvent, hint);\n\n        return processedEvent;\n      }).then(null, function (reason) {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        _this6.captureException(reason, {\n          data: {\n            __sentry__: true\n          },\n          originalException: reason\n        });\n\n        throw new SentryError(\"Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: \".concat(reason));\n      });\n    }\n    /**\n     * Occupies the client with processing and event\n     */\n\n  }, {\n    key: \"_process\",\n    value: function _process(promise) {\n      var _this7 = this;\n\n      this._numProcessing += 1;\n      void promise.then(function (value) {\n        _this7._numProcessing -= 1;\n        return value;\n      }, function (reason) {\n        _this7._numProcessing -= 1;\n        return reason;\n      });\n    }\n    /**\n     * @inheritdoc\n     */\n\n  }, {\n    key: \"_sendEnvelope\",\n    value: function _sendEnvelope(envelope) {\n      if (this._transport && this._dsn) {\n        this._transport.send(envelope).then(null, function (reason) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);\n        });\n      } else {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');\n      }\n    }\n    /**\n     * Clears outcomes on this client and returns them.\n     */\n\n  }, {\n    key: \"_clearOutcomes\",\n    value: function _clearOutcomes() {\n      var outcomes = this._outcomes;\n      this._outcomes = {};\n      return Object.keys(outcomes).map(function (key) {\n        var _key$split = key.split(':'),\n            _key$split2 = _slicedToArray(_key$split, 2),\n            reason = _key$split2[0],\n            category = _key$split2[1];\n\n        return {\n          reason: reason,\n          category: category,\n          quantity: outcomes[key]\n        };\n      });\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n  }]);\n\n  return BaseClient;\n}();\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\n\n\nfunction _validateBeforeSendResult(beforeSendResult, beforeSendProcessorName) {\n  var invalidValueError = \"`\".concat(beforeSendProcessorName, \"` must return `null` or a valid event.\");\n\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(function (event) {\n      if (!isPlainObject(event) && event !== null) {\n        throw new SentryError(invalidValueError);\n      }\n\n      return event;\n    }, function (e) {\n      throw new SentryError(\"`\".concat(beforeSendProcessorName, \"` rejected with \").concat(e));\n    });\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n\n  return beforeSendResult;\n}\n\nexport { BaseClient };","/*\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\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\nexport { isBrowserBundle };","import { isString } from './is.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\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 */\n\nfunction htmlTreeAsString(elem, keyAttrs) {\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    var currentElem = elem;\n    var MAX_TRAVERSE_HEIGHT = 5;\n    var MAX_OUTPUT_LEN = 80;\n    var out = [];\n    var height = 0;\n    var len = 0;\n    var separator = ' > ';\n    var sepLength = separator.length;\n    var nextStr; // eslint-disable-next-line no-plusplus\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs); // 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\n      if (nextStr === 'html' || height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN) {\n        break;\n      }\n\n      out.push(nextStr);\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 * 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 */\n\n\nfunction _htmlElementAsString(el, keyAttrs) {\n  var elem = el;\n  var out = [];\n  var className;\n  var classes;\n  var key;\n  var attr;\n  var i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase()); // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n\n  var keyAttrPairs = keyAttrs && keyAttrs.length ? keyAttrs.filter(function (keyAttr) {\n    return elem.getAttribute(keyAttr);\n  }).map(function (keyAttr) {\n    return [keyAttr, elem.getAttribute(keyAttr)];\n  }) : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(function (keyAttrPair) {\n      out.push(\"[\".concat(keyAttrPair[0], \"=\\\"\").concat(keyAttrPair[1], \"\\\"]\"));\n    });\n  } else {\n    if (elem.id) {\n      out.push(\"#\".concat(elem.id));\n    } // eslint-disable-next-line prefer-const\n\n\n    className = elem.className;\n\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n\n      for (i = 0; i < classes.length; i++) {\n        out.push(\".\".concat(classes[i]));\n      }\n    }\n  }\n\n  var allowedAttrs = ['type', 'name', 'title', 'alt'];\n\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n\n    if (attr) {\n      out.push(\"[\".concat(key, \"=\\\"\").concat(attr, \"\\\"]\"));\n    }\n  }\n\n  return out.join('');\n}\n/**\n * A safe form of location.href\n */\n\n\nfunction getLocationHref() {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\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\n\n\nfunction getDomElement(selector) {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector);\n  }\n\n  return null;\n}\n\nexport { getDomElement, getLocationHref, htmlTreeAsString };","import { addInstrumentationHandler, logger } from '@sentry/utils';\nimport { getActiveTransaction } from './utils.js';\n/**\n * Configures global error listeners\n */\n\nfunction registerErrorInstrumentation() {\n  addInstrumentationHandler('error', errorCallback);\n  addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\n\n\nfunction errorCallback() {\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    var status = 'internal_error';\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"[Tracing] Transaction: \".concat(status, \" -> Global error occured\"));\n    activeTransaction.setStatus(status);\n  }\n}\n\nexport { registerErrorInstrumentation };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nimport { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\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\n\nfunction normalize(input) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : +Infinity;\n  var maxProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : +Infinity;\n\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 {\n      ERROR: \"**non-serializable** (\".concat(err, \")\")\n    };\n  }\n}\n/** JSDoc */\n\n\nfunction normalizeToSize( // eslint-disable-next-line @typescript-eslint/no-explicit-any\nobject) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;\n  var maxSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100 * 1024;\n  var normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized;\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 */\n\n\nfunction visit(key, value) {\n  var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : +Infinity;\n  var maxProperties = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : +Infinity;\n  var memo = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : memoBuilder();\n\n  var _memo = _slicedToArray(memo, 2),\n      memoize = _memo[0],\n      unmemoize = _memo[1]; // Get the simple cases out of the way first\n\n\n  if (value === null || ['number', 'boolean', 'string'].includes(_typeof(value)) && !isNaN(value)) {\n    return value;\n  }\n\n  var stringified = stringifyValue(key, value); // 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\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  } // From here on, we can assert that `value` is either an object or an array.\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\n\n  if (value['__sentry_skip_normalization__']) {\n    return value;\n  } // We're also done if we've reached the max depth\n\n\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  } // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n\n\n  if (memoize(value)) {\n    return '[Circular ~]';\n  } // If the value has a `toJSON` method, we call it to extract more information\n\n\n  var valueWithToJSON = value;\n\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      var jsonValue = valueWithToJSON.toJSON(); // We need to normalize the return value of `.toJSON()` in case it has circular references\n\n      return visit('', jsonValue, depth - 1, maxProperties, memo);\n    } catch (err) {// pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\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\n\n  var normalized = Array.isArray(value) ? [] : {};\n  var numAdded = 0; // 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\n  var visitable = convertToPlainObject(value);\n\n  for (var 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    } // Recursively visit all the child nodes\n\n\n    var visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n    numAdded += 1;\n  } // Once we've visited all the branches, remove the parent from memo storage\n\n\n  unmemoize(value); // Return accumulated values\n\n  return normalized;\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 */\n\n\nfunction stringifyValue(key, // 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\nvalue) {\n  try {\n    if (key === 'domain' && value && _typeof(value) === 'object' && value._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\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\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    } // eslint-disable-next-line no-restricted-globals\n\n\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    } // eslint-disable-next-line no-restricted-globals\n\n\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    } // React's SyntheticEvent thingy\n\n\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    } // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n\n\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return \"[Function: \".concat(getFunctionName(value), \"]\");\n    }\n\n    if (_typeof(value) === 'symbol') {\n      return \"[\".concat(String(value), \"]\");\n    } // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n\n\n    if (typeof value === 'bigint') {\n      return \"[BigInt: \".concat(String(value), \"]\");\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\n\n    return \"[object \".concat(Object.getPrototypeOf(value).constructor.name, \"]\");\n  } catch (err) {\n    return \"**non-serializable** (\".concat(err, \")\");\n  }\n}\n/** Calculates bytes size of input string */\n\n\nfunction utf8Length(value) {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  var hasWeakSet = typeof WeakSet === 'function';\n  var inner = hasWeakSet ? new WeakSet() : [];\n\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n\n      inner.add(obj);\n      return false;\n    } // eslint-disable-next-line @typescript-eslint/prefer-for-of\n\n\n    for (var i = 0; i < inner.length; i++) {\n      var value = inner[i];\n\n      if (value === obj) {\n        return true;\n      }\n    }\n\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (var i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };","function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\n\nfunction createEnvelope(headers) {\n  var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  return [headers, items];\n}\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\n\n\nfunction addItemToEnvelope(envelope, newItem) {\n  var _envelope = _slicedToArray(envelope, 2),\n      headers = _envelope[0],\n      items = _envelope[1];\n\n  return [headers, [].concat(_toConsumableArray(items), [newItem])];\n}\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\n\n\nfunction forEachEnvelopeItem(envelope, callback) {\n  var envelopeItems = envelope[1];\n  envelopeItems.forEach(function (envelopeItem) {\n    var envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\n\nfunction encodeUTF8(input, textEncoder) {\n  var utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n/**\n * Serializes an envelope.\n */\n\n\nfunction serializeEnvelope(envelope, textEncoder) {\n  var _envelope2 = _slicedToArray(envelope, 2),\n      envHeaders = _envelope2[0],\n      items = _envelope2[1]; // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n\n\n  var parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  var _iterator = _createForOfIteratorHelper(items),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var item = _step.value;\n\n      var _item = _slicedToArray(item, 2),\n          itemHeaders = _item[0],\n          payload = _item[1];\n\n      append(\"\\n\".concat(JSON.stringify(itemHeaders), \"\\n\"));\n\n      if (typeof payload === 'string' || payload instanceof Uint8Array) {\n        append(payload);\n      } else {\n        var stringifiedPayload = void 0;\n\n        try {\n          stringifiedPayload = JSON.stringify(payload);\n        } catch (e) {\n          // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n          // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n          // performance impact but in this case a performance hit is better than throwing.\n          stringifiedPayload = JSON.stringify(normalize(payload));\n        }\n\n        append(stringifiedPayload);\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  var totalLength = buffers.reduce(function (acc, buf) {\n    return acc + buf.length;\n  }, 0);\n  var merged = new Uint8Array(totalLength);\n  var offset = 0;\n\n  var _iterator2 = _createForOfIteratorHelper(buffers),\n      _step2;\n\n  try {\n    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n      var buffer = _step2.value;\n      merged.set(buffer, offset);\n      offset += buffer.length;\n    }\n  } catch (err) {\n    _iterator2.e(err);\n  } finally {\n    _iterator2.f();\n  }\n\n  return merged;\n}\n/**\n * Creates attachment envelope items\n */\n\n\nfunction createAttachmentEnvelopeItem(attachment, textEncoder) {\n  var buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n  return [dropUndefinedKeys({\n    type: 'attachment',\n    length: buffer.length,\n    filename: attachment.filename,\n    content_type: attachment.contentType,\n    attachment_type: attachment.attachmentType\n  }), buffer];\n}\n\nvar ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default'\n};\n/**\n * Maps the type of an envelope item to a data category.\n */\n\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, envelopeItemTypeToDataCategory, forEachEnvelopeItem, serializeEnvelope };","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\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\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\n\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n\n    case 'dom':\n      instrumentDOM();\n      break;\n\n    case 'xhr':\n      instrumentXHR();\n      break;\n\n    case 'fetch':\n      instrumentFetch();\n      break;\n\n    case 'history':\n      instrumentHistory();\n      break;\n\n    case 'error':\n      instrumentError();\n      break;\n\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\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 */\n\n\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  handlers[type].push(callback);\n  instrument(type);\n}\n/** JSDoc */\n\n\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  var _iterator = _createForOfIteratorHelper(handlers[type] || []),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var handler = _step.value;\n\n      try {\n        handler(data);\n      } catch (e) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(\"Error while triggering instrumentation handler.\\nType: \".concat(type, \"\\nName: \").concat(getFunctionName(handler), \"\\nError:\"), e);\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n/** JSDoc */\n\n\nfunction instrumentConsole() {\n  if (!('console' in WINDOW)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in WINDOW.console)) {\n      return;\n    }\n\n    fill(WINDOW.console, level, function (originalConsoleMethod) {\n      return function () {\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        triggerHandlers('console', {\n          args: args,\n          level: level\n        }); // this fails for some browsers. :(\n\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(WINDOW.console, args);\n        }\n      };\n    });\n  });\n}\n/** JSDoc */\n\n\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(WINDOW, 'fetch', function (originalFetch) {\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      var handlerData = {\n        args: args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args)\n        },\n        startTimestamp: Date.now()\n      };\n      triggerHandlers('fetch', _objectSpread({}, handlerData)); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n      return originalFetch.apply(WINDOW, args).then(function (response) {\n        triggerHandlers('fetch', _objectSpread(_objectSpread({}, handlerData), {}, {\n          endTimestamp: Date.now(),\n          response: response\n        }));\n        return response;\n      }, function (error) {\n        triggerHandlers('fetch', _objectSpread(_objectSpread({}, handlerData), {}, {\n          endTimestamp: Date.now(),\n          error: error\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\n        throw error;\n      });\n    };\n  });\n}\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** Extract `method` from fetch call arguments */\n\n\nfunction getFetchMethod() {\n  var fetchArgs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n\n  return 'GET';\n}\n/** Extract `url` from fetch call arguments */\n\n\nfunction getFetchUrl() {\n  var fetchArgs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n\n  return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\n\n\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in WINDOW)) {\n    return;\n  }\n\n  var xhrproto = XMLHttpRequest.prototype;\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function () {\n      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n        args[_key3] = arguments[_key3];\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      var xhr = this;\n      var url = args[1];\n      var xhrInfo = 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      }; // 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\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      var onreadystatechangeHandler = function onreadystatechangeHandler() {\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: args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr: xhr\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function () {\n            onreadystatechangeHandler();\n\n            for (var _len4 = arguments.length, readyStateArgs = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n              readyStateArgs[_key4] = arguments[_key4];\n            }\n\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  fill(xhrproto, 'send', function (originalSend) {\n    return function () {\n      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n        args[_key5] = arguments[_key5];\n      }\n\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args: args,\n        startTimestamp: Date.now(),\n        xhr: this\n      });\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nvar lastHref;\n/** JSDoc */\n\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  var oldOnPopState = WINDOW.onpopstate;\n\n  WINDOW.onpopstate = function () {\n    var to = WINDOW.location.href; // keep track of the current URL state, as we always receive only the updated state\n\n    var from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from: from,\n      to: to\n    });\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        for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n          args[_key6] = arguments[_key6];\n        }\n\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {// no-empty\n      }\n    }\n  };\n  /** @hidden */\n\n\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function () {\n      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {\n        args[_key7] = arguments[_key7];\n      }\n\n      var url = args.length > 2 ? args[2] : undefined;\n\n      if (url) {\n        // coerce to string (this is what pushState does)\n        var from = lastHref;\n        var to = String(url); // keep track of the current URL state, as we always receive only the updated state\n\n        lastHref = to;\n        triggerHandlers('history', {\n          from: from,\n          to: to\n        });\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\nvar debounceDuration = 1000;\nvar debounceTimerID;\nvar lastCapturedEvent;\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 */\n\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  } // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n\n\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) {// just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\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\n\n  return false;\n}\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\n\n\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    var target = event.target;\n\n    if (!target || !target.tagName) {\n      return true;\n    } // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n\n\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {// 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 * 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 */\n\n\nfunction makeDOMEventHandler(handler) {\n  var globalListener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  return function (event) {\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    } // We always want to skip _some_ events.\n\n\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    var name = event.type === 'keypress' ? 'input' : event.type; // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name: name,\n        global: globalListener\n      });\n      lastCapturedEvent = event;\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: name,\n        global: globalListener\n      });\n      lastCapturedEvent = event;\n    } // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n\n\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(function () {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n/** JSDoc */\n\n\nfunction instrumentDOM() {\n  if (!('document' in WINDOW)) {\n    return;\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\n\n  var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false); // 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\n  ['EventTarget', 'Node'].forEach(function (target) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var proto = WINDOW[target] && WINDOW[target].prototype; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (type, listener, options) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this;\n\n            var _handlers = el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {};\n\n            var handlerForType = _handlers[type] = _handlers[type] || {\n              refCount: 0\n            };\n\n            if (!handlerForType.handler) {\n              var handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {// 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    fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n      return function (type, listener, options) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this;\n\n            var _handlers2 = el.__sentry_instrumentation_handlers__ || {};\n\n            var handlerForType = _handlers2[type];\n\n            if (handlerForType) {\n              handlerForType.refCount -= 1; // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n\n              if (handlerForType.refCount <= 0) {\n                originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                handlerForType.handler = undefined;\n                delete _handlers2[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n              } // If there are no longer any custom handlers of any type on this element, cleanup everything.\n\n\n              if (Object.keys(_handlers2).length === 0) {\n                delete el.__sentry_instrumentation_handlers__;\n              }\n            }\n          } catch (e) {// 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\nvar _oldOnErrorHandler = null;\n/** JSDoc */\n\nfunction instrumentError() {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column: column,\n      error: error,\n      line: line,\n      msg: msg,\n      url: 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\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\n\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e) {\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\nexport { addInstrumentationHandler };","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n  var lastAccessLHS = undefined;\n  var value = ops[0];\n  var i = 1;\n\n  while (i < ops.length) {\n    var op = ops[i];\n    var fn = ops[i + 1];\n    i += 2; // by checking for loose equality to `null`, we catch both `null` and `undefined`\n\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn(function () {\n        var _value;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return (_value = value).call.apply(_value, [lastAccessLHS].concat(args));\n      });\n      lastAccessLHS = undefined;\n    }\n  }\n\n  return value;\n} // Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     const op = ops[i];\n//     const fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n\n\nexport { _optionalChain };","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nimport { SentryError } from './error.js';\n/** Regular expression used to parse a Dsn. */\n\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\n\n\nfunction dsnToString(dsn) {\n  var withPassword = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  var host = dsn.host,\n      path = dsn.path,\n      pass = dsn.pass,\n      port = dsn.port,\n      projectId = dsn.projectId,\n      protocol = dsn.protocol,\n      publicKey = dsn.publicKey;\n  return \"\".concat(protocol, \"://\").concat(publicKey).concat(withPassword && pass ? \":\".concat(pass) : '') + \"@\".concat(host).concat(port ? \":\".concat(port) : '', \"/\").concat(path ? \"\".concat(path, \"/\") : path).concat(projectId);\n}\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\n\n\nfunction dsnFromString(str) {\n  var match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(\"Invalid Sentry Dsn: \".concat(str));\n  }\n\n  var _match$slice = match.slice(1),\n      _match$slice2 = _slicedToArray(_match$slice, 6),\n      protocol = _match$slice2[0],\n      publicKey = _match$slice2[1],\n      _match$slice2$ = _match$slice2[2],\n      pass = _match$slice2$ === void 0 ? '' : _match$slice2$,\n      host = _match$slice2[3],\n      _match$slice2$2 = _match$slice2[4],\n      port = _match$slice2$2 === void 0 ? '' : _match$slice2$2,\n      lastPath = _match$slice2[5];\n\n  var path = '';\n  var projectId = lastPath;\n  var split = projectId.split('/');\n\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop();\n  }\n\n  if (projectId) {\n    var projectMatch = projectId.match(/^\\d+/);\n\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({\n    host: host,\n    pass: pass,\n    path: path,\n    projectId: projectId,\n    port: port,\n    protocol: protocol,\n    publicKey: publicKey\n  });\n}\n\nfunction dsnFromComponents(components) {\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) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  var port = dsn.port,\n      projectId = dsn.projectId,\n      protocol = dsn.protocol;\n  var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(function (component) {\n    if (!dsn[component]) {\n      throw new SentryError(\"Invalid Sentry Dsn: \".concat(component, \" missing\"));\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(\"Invalid Sentry Dsn: Invalid projectId \".concat(projectId));\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(\"Invalid Sentry Dsn: Invalid protocol \".concat(protocol));\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(\"Invalid Sentry Dsn: Invalid port \".concat(port));\n  }\n\n  return true;\n}\n/** The Sentry Dsn, identifying a Sentry instance and project. */\n\n\nfunction makeDsn(from) {\n  var components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\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 */\n\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  var original = source[name];\n  var wrapped = replacementFactory(original); // 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\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {// 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 * 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 */\n\n\nfunction addNonEnumerableProperty(obj, name, value) {\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 * 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 */\n\n\nfunction markFunctionWrapped(wrapped, original) {\n  var proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\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 */\n\n\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\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 */\n\n\nfunction urlEncode(object) {\n  return Object.keys(object).map(function (key) {\n    return \"\".concat(encodeURIComponent(key), \"=\").concat(encodeURIComponent(object[key]));\n  }).join('&');\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 */\n\n\nfunction convertToPlainObject(value) {\n  if (isError(value)) {\n    return _objectSpread({\n      message: value.message,\n      name: value.name,\n      stack: value.stack\n    }, getOwnProperties(value));\n  } else if (isEvent(value)) {\n    var newObj = _objectSpread({\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget)\n    }, getOwnProperties(value));\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/** Creates a string representation of the target of an `Event` object */\n\n\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n/** Filters out all but an object's own properties */\n\n\nfunction getOwnProperties(obj) {\n  if (_typeof(obj) === 'object' && obj !== null) {\n    var extractedProps = {};\n\n    for (var property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = obj[property];\n      }\n    }\n\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n\n\nfunction extractExceptionKeysForMessage(exception) {\n  var maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 40;\n  var 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 (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    var serialized = keys.slice(0, includedKeys).join(', ');\n\n    if (serialized.length > maxLength) {\n      continue;\n    }\n\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\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 */\n\n\nfunction dropUndefinedKeys(inputValue) {\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  var memoizationMap = new Map(); // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\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    var memoVal = memoizationMap.get(inputValue);\n\n    if (memoVal !== undefined) {\n      return memoVal;\n    }\n\n    var returnValue = {}; // Store the mapping of this value in case we visit it again, in case of circular data\n\n    memoizationMap.set(inputValue, returnValue);\n\n    for (var _i = 0, _Object$keys = Object.keys(inputValue); _i < _Object$keys.length; _i++) {\n      var key = _Object$keys[_i];\n\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue;\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    var _memoVal = memoizationMap.get(inputValue);\n\n    if (_memoVal !== undefined) {\n      return _memoVal;\n    }\n\n    var _returnValue = []; // Store the mapping of this value in case we visit it again, in case of circular data\n\n    memoizationMap.set(inputValue, _returnValue);\n    inputValue.forEach(function (item) {\n      _returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n    return _returnValue;\n  }\n\n  return inputValue;\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 */\n\n\nfunction objectify(wat) {\n  var objectified;\n\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\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\n    case _typeof(wat) === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new wat.constructor(wat);\n      break;\n    // by process of elimination, at this point we know that `wat` must already be an object\n\n    default:\n      objectified = wat;\n      break;\n  }\n\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\n/** Internal global with common properties and Sentry extensions  */\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) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n/** Get's the global object for the current JavaScript runtime */\n\n\nvar GLOBAL_OBJ = (typeof globalThis === \"undefined\" ? \"undefined\" : _typeof(globalThis)) == 'object' && isGlobalObj(globalThis) || // eslint-disable-next-line no-restricted-globals\n(typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) == 'object' && isGlobalObj(window) || (typeof self === \"undefined\" ? \"undefined\" : _typeof(self)) == 'object' && isGlobalObj(self) || (typeof global === \"undefined\" ? \"undefined\" : _typeof(global)) == 'object' && isGlobalObj(global) || function () {\n  return this;\n}() || {};\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\n\n\nfunction getGlobalObject() {\n  return GLOBAL_OBJ;\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 */\n\n\nfunction getGlobalSingleton(name, creator, obj) {\n  var gbl = obj || GLOBAL_OBJ;\n\n  var __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {};\n\n  var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };"],"sourceRoot":""}