{"version":3,"mappings":"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","names":["handlers","instrumented","addHandler","type","handler","maybeInstrument","instrumentFn","e","DEBUG_BUILD","logger","triggerHandlers","data","typeHandlers","getFunctionName","_oldOnErrorHandler","addGlobalErrorInstrumentationHandler","instrumentError","GLOBAL_OBJ","msg","url","line","column","error","_oldOnUnhandledRejectionHandler","addGlobalUnhandledRejectionInstrumentationHandler","instrumentUnhandledRejection","errorsInstrumented","registerSpanErrorInstrumentation","errorCallback","activeSpan","getActiveSpan","rootSpan","getRootSpan","message","SPAN_STATUS_ERROR","TRACING_DEFAULTS","FINISH_REASON_HEARTBEAT_FAILED","FINISH_REASON_IDLE_TIMEOUT","FINISH_REASON_FINAL_TIMEOUT","FINISH_REASON_EXTERNAL_FINISH","startIdleSpan","startSpanOptions","options","activities","_finished","_idleTimeoutID","_finishReason","_autoFinishAllowed","_cleanupHooks","idleTimeout","finalTimeout","childSpanTimeout","beforeSpanEnd","client","getClient","hasTracingEnabled","SentryNonRecordingSpan","scope","getCurrentScope","previousActiveSpan","span","_startIdleSpan","target","thisArg","args","definedEndTimestamp","rest","timestamp","timestampInSeconds","spanEndTimestamp","spanTimeInputToSeconds","spans","getSpanDescendants","child","onIdleSpanEnded","childEndTimestamps","spanToJSON","latestSpanEndTimestamp","spanStartTimestamp","endTimestamp","_cancelIdleTimeout","_restartIdleTimeout","_restartChildSpanTimeout","_pushActivity","spanId","_popActivity","cleanup","_setSpanForScope","spanJSON","startTimestamp","SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON","childSpans","discardedSpans","childSpan","childSpanJSON","childEndTimestamp","childStartTimestamp","spanStartedBeforeIdleSpanEnd","timeoutWithMarginOfError","spanEndedBeforeFinalTimeout","stringifiedSpan","removeChildSpanFromSpan","startedSpan","endedSpan","spanToAllowAutoFinish","startInactiveSpan","SENTRY_API_VERSION","getBaseApiEndpoint","dsn","protocol","port","_getIngestEndpoint","_encodedAuth","sdkInfo","params","getEnvelopeEndpointWithUrlEncodedAuth","tunnel","installedIntegrations","filterDuplicates","integrations","integrationsByName","currentInstance","name","existingInstance","getIntegrationsToSetup","defaultIntegrations","userIntegrations","integration","resolvedUserIntegrations","finalIntegrations","debugIndex","debugInstance","setupIntegrations","integrationIndex","setupIntegration","afterSetupIntegrations","callback","event","hint","processor","createClientReportEnvelope","discarded_events","clientReportItem","dateTimestampInSeconds","createEnvelope","SentryError","logLevel","ALREADY_SEEN_ERROR","BaseClient","makeDsn","undefinedOption","option","consoleSandbox","exception","eventId","uuid4","checkOrSetAlreadyCaught","hintWithEventId","level","currentScope","eventMessage","isParameterizedString","promisedEvent","isPrimitive","capturedSpanScope","session","updateSession","timeout","transport","clientFinished","transportFlushed","resolvedSyncPromise","result","eventProcessor","integrationName","isAlreadyInstalled","env","createEventEnvelope","attachment","addItemToEnvelope","createAttachmentEnvelopeItem","promise","sendResponse","createSessionEnvelope","reason","category","eventOrCount","count","key","hook","hooks","cbIndex","callbacks","envelope","crashed","errored","exceptions","ex","mechanism","sessionNonTerminal","SyncPromise","resolve","ticked","tick","interval","isolationScope","getIsolationScope","prepareEvent","evt","getTraceContextFromScope","dynamicSamplingContext","getDynamicSamplingContextFromScope","finalEvent","sentryError","sampleRate","isTransaction","isTransactionEvent","isError","isErrorEvent","eventType","beforeSendLabel","parsedSampleRate","parseSampleRate","rejectedSyncPromise","dataCategory","capturedSpanIsolationScope","prepared","processBeforeSend","_validateBeforeSendResult","processedEvent","spanCount","spanCountBefore","spanCountAfter","droppedSpanCount","transactionInfo","source","value","outcomes","quantity","dsnToString","beforeSendResult","invalidValueError","isThenable","isPlainObject","beforeSend","beforeSendTransaction","beforeSendSpan","processedSpans","processedSpan","showSpanDropWarning","initAndBind","clientClass","setCurrentClient","makePromiseBuffer","limit","buffer","isReady","remove","task","add","taskProducer","drain","reject","counter","capturedSetTimeout","item","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","header","now","headerDelay","headerDate","disabledUntil","limits","isRateLimited","updateRateLimits","statusCode","headers","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","namespaces","delay","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","rateLimits","flush","send","filteredEnvelopeItems","forEachEnvelopeItem","envelopeItemTypeToDataCategory","getEventForEnvelopeItem","filteredEnvelope","recordEnvelopeLoss","requestTask","serializeEnvelope","response","applySdkMetadata","names","metadata","SDK_VERSION","getTraceData","isEnabled","carrier","getMainCarrier","acs","getAsyncContextStrategy","sentryTrace","spanToTraceHeader","scopeToTraceHeader","dsc","getDynamicSamplingContextFromSpan","baggage","dynamicSamplingContextToSentryBaggageHeader","TRACEPARENT_REGEXP","traceId","sampled","generateSentryTraceHeader","DEFAULT_BREADCRUMBS","addBreadcrumb","breadcrumb","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","originalFunctionToString","INTEGRATION_NAME","SETUP_CLIENTS","_functionToStringIntegration","originalFunction","getOriginalFunction","context","functionToStringIntegration","DEFAULT_IGNORE_ERRORS","_inboundFiltersIntegration","_hint","clientOptions","mergedOptions","_mergeOptions","_shouldDropEvent","inboundFiltersIntegration","internalOptions","_isSentryError","getEventDescription","_isIgnoredError","_isUselessError","_isIgnoredTransaction","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreErrors","_getPossibleEventMessages","stringMatchesSomePattern","ignoreTransactions","denyUrls","allowUrls","possibleMessages","lastException","_getLastValidUrl","frames","i","frame","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","isInstanceOf","originalException","truncateAggregateExceptions","aggregateExceptionsFromError","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","childError","parentId","maxValueLength","truncate","parseUrl","match","query","fragment","addConsoleInstrumentationHandler","instrumentConsole","CONSOLE_LEVELS","fill","originalConsoleMethod","originalConsoleMethods","log","severityLevelFromString","_dedupeIntegration","previousEvent","currentEvent","dedupeIntegration","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","previousException","_getExceptionFromEvent","currentException","currentFrames","getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","previousFingerprint","instrumentFetchRequest","handlerData","shouldCreateSpan","shouldAttachHeaders","spanOrigin","shouldCreateSpanResult","endSpan","method","fullUrl","getFullURL","host","hasParent","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","request","_addTracingHeadersToFetchRequest","fetchOptionsObj","traceHeaders","isRequest","isHeaders","newHeaders","prevBaggageHeader","prevHeaderStrippedFromSentryBaggage","stripBaggageHeaderOfSentryBaggageValues","headerName","headerValue","existingBaggageHeader","newBaggageHeaders","headerItem","setHttpStatus","contentLength","contentLengthNum","baggageHeader","baggageEntry","SENTRY_BAGGAGE_KEY_PREFIX","getBreadcrumbLogLevelFromHttpStatusCode","WINDOW","supportsFetch","isNativeFunction","func","supportsNativeFetch","doc","sandbox","err","addFetchInstrumentationHandler","skipNativeFetchCheck","instrumentFetch","addFetchEndInstrumentationHandler","streamHandler","onFetchResolved","originalFetch","virtualError","parseFetchArgs","addNonEnumerableProperty","resolveResponse","res","onFinishedResolving","body","responseReader","maxFetchDurationTimeout","readingActive","chunkTimeout","done","clonedResponseForResolving","hasProp","obj","prop","getUrlFromResource","resource","fetchArgs","arg","getSDKSource","supportsHistory","chromeVar","isChromePackagedApp","hasHistoryApi","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","fn","isFunction","wrapper","sentryWrapped","wrappedArguments","withScope","addExceptionTypeValue","addExceptionMechanism","captureException","property","markFunctionWrapped","exceptionFromError","stackParser","parseStackFrames","extractType","extractMessage","eventFromPlainObject","syntheticException","isUnhandledRejection","normalizeDepth","errorFromProp","getErrorPropertyFromObject","extra","normalizeToSize","isEvent","getNonErrorObjectExceptionValue","eventFromError","stacktrace","skipLines","getSkipFirstStackStringLines","framesToPop","getPopFirstTopFrames","reactMinifiedRegexp","isWebAssemblyException","eventFromException","attachStacktrace","eventFromUnknownInput","eventFromMessage","eventFromString","isDOMError","isDOMException","domException","__sentry_template_string__","__sentry_template_values__","keys","extractExceptionKeysForMessage","captureType","getObjectClassName","prototype","createUserFeedbackEnvelope","feedback","createUserFeedbackEnvelopeItem","BrowserClient","opts","sdkSource","getRating","thresholds","bindReporter","metric","reportAllChanges","prevValue","delta","forceReport","generateUniqueID","getNavigationEntry","checkResponseStart","navigationEntry","getActivationStart","navEntry","initMetric","navigationType","observe","po","list","onHidden","cb","onHiddenOrPageHide","runOnce","called","firstHiddenTime","initHiddenTime","onVisibilityUpdate","removeChangeListeners","addChangeListeners","getVisibilityWatcher","whenActivated","FCPThresholds","onFCP","onReport","visibilityWatcher","report","entries","entry","CLSThresholds","onCLS","sessionValue","sessionEntries","handleEntries","firstSessionEntry","lastSessionEntry","FIDThresholds","onFID","handleEntry","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","updateEstimate","getInteractionCount","initInteractionCountPolyfill","longestInteractionList","longestInteractionMap","DEFAULT_DURATION_THRESHOLD","prevInteractionCount","getInteractionCountForNavigation","estimateP98LongestInteraction","candidateInteractionIndex","MAX_INTERACTIONS_TO_CONSIDER","entryPreProcessingCallbacks","processInteractionEntry","minLongestInteraction","existingInteraction","interaction","a","b","whenIdle","rIC","handle","INPThresholds","onINP","inp","LCPThresholds","reportedMetricIDs","onLCP","stopListening","TTFBThresholds","whenReady","onTTFB","_previousCls","_previousFid","_previousLcp","_previousTtfb","_previousInp","addClsInstrumentationHandler","stopOnCallback","addMetricObserver","instrumentCls","addLcpInstrumentationHandler","instrumentLcp","addFidInstrumentationHandler","instrumentFid","addTtfbInstrumentationHandler","instrumentTtfb","addInpInstrumentationHandler","instrumentInp","addPerformanceInstrumentationHandler","instrumentPerformanceObserver","getCleanupCallback","previousValue","index","isPerformanceEventTiming","isMeasurementValue","startAndEndSpan","parentSpan","startTimeInSeconds","endTime","ctx","parentStartTime","withActiveSpan","startStandaloneWebVitalSpan","transaction","passedAttributes","startTime","release","environment","replay","replayId","user","userDisplay","profileId","attributes","getBrowserPerformanceAPI","msToSec","time","trackClsAsStandaloneSpan","standaloneCLsValue","standaloneClsEntry","pageloadSpanId","supportsLayoutShift","sentSpan","_collectClsOnce","sendStandaloneClsSpan","cleanupClsHandler","unsubscribeStartNavigation","clsValue","browserPerformanceTimeOrigin","routeName","htmlTreeAsString","dropUndefinedKeys","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE","MAX_INT_AS_BYTES","_performanceCursor","_measurements","_lcpEntry","_clsEntry","startTrackingWebVitals","recordClsStandaloneSpans","performance","fidCleanupCallback","_trackFID","lcpCleanupCallback","_trackLCP","ttfbCleanupCallback","_trackTtfb","clsCleanupCallback","_trackCLS","startTrackingLongTasks","parent","parentOp","parentStartTimestamp","duration","startTrackingLongAnimationFrames","initialScript","invoker","invokerType","sourceURL","sourceFunctionName","sourceCharPosition","startTrackingInteractions","spanOptions","componentName","getComponentName","timeOrigin","addPerformanceEntries","performanceEntries","op","transactionStartTime","_addNavigationSpans","_addMeasureSpans","firstHidden","shouldRecord","_addResourceSpans","_trackNavigator","_addTtfbRequestTimeToMeasurements","fidMark","measurementName","measurement","setMeasurement","_setWebVitalAttributes","requestTime","measureStartTimestamp","startTimeStamp","measureEndTimestamp","_addPerformanceNavigationTiming","_addRequest","eventEnd","_getEndPropertyNameForNavigationTiming","end","start","requestStartTimestamp","responseEndTimestamp","responseStartTimestamp","resourceUrl","parsedUrl","setResourceEntrySizeData","deliveryType","renderBlockingStatus","navigator","connection","dataKey","entryVal","responseStart","requestStart","DEBOUNCE_DURATION","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","addClickKeypressInstrumentationHandler","instrumentDOM","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","targetObj","proto","originalAddEventListener","listener","handlerForType","originalRemoveEventListener","isSimilarToLastCapturedEvent","shouldSkipDOMEvent","globalListener","getEventTarget","lastHref","addHistoryInstrumentationHandler","instrumentHistory","oldOnPopState","to","from","historyReplacementFunction","originalHistoryFunction","cachedImplementations","getNativeImplementation","cached","impl","document","contentWindow","clearCachedImplementation","SENTRY_XHR_DATA_KEY","addXhrInstrumentationHandler","instrumentXHR","xhrproto","originalOpen","xhrOpenThisArg","xhrOpenArgArray","isString","onreadystatechangeHandler","xhrInfo","originalOnreadystatechange","onreadystatechangeThisArg","onreadystatechangeArgArray","originalSetRequestHeader","setRequestHeaderThisArg","setRequestHeaderArgArray","originalSend","sendThisArg","sendArgArray","sentryXhrData","LAST_INTERACTIONS","INTERACTIONS_SPAN_MAP","startTrackingINP","inpCallback","_trackINP","INP_ENTRY_MAP","interactionId","interactionType","spanToUse","registerInpInteractionListener","_latestRoute","activeRootSpan","last","makeFetchTransport","nativeFetch","pendingBodySize","pendingCount","requestSize","requestOptions","CHROME_PRIORITY","GECKO_PRIORITY","createFrame","filename","lineno","colno","UNKNOWN_FUNCTION","chromeRegexNoFnName","chromeRegex","chromeEvalRegex","chromeStackParserFn","noFnParts","col","parts","subMatch","extractSafariExtensionDetails","chromeStackLineParser","geckoREgex","geckoEvalRegex","gecko","geckoStackLineParser","defaultStackLineParsers","defaultStackParser","createStackParser","isSafariExtension","isSafariWebExtension","MAX_ALLOWED_STRING_LENGTH","_breadcrumbsIntegration","_options","_getConsoleBreadcrumbHandler","_getDomBreadcrumbHandler","_getXhrBreadcrumbHandler","_getFetchBreadcrumbHandler","_getHistoryBreadcrumbHandler","_getSentryBreadcrumbHandler","breadcrumbsIntegration","dom","keyAttrs","maxStringLength","element","_isEvent","safeJoin","status_code","parsedLoc","parsedFrom","parsedTo","DEFAULT_EVENT_TARGET","_browserApiErrorsIntegration","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","browserApiErrorsIntegration","original","originalCallback","xhr","wrapOptions","eventName","isEventListenerObject","originalEventHandler","browserSessionIntegration","startSession","captureSession","_globalHandlersIntegration","_installGlobalOnErrorHandler","globalHandlerLog","_installGlobalOnUnhandledRejectionHandler","globalHandlersIntegration","getOptions","_enhanceEventWithInitialFrame","captureEvent","_getUnhandledRejectionError","_eventFromRejectionWithPrimitive","ev","ev0","ev0s","ev0sf","getLocationHref","httpContextIntegration","referrer","userAgent","DEFAULT_KEY","DEFAULT_LIMIT","_linkedErrorsIntegration","linkedErrorsIntegration","getDefaultIntegrations","applyDefaultOptions","optionsArg","defaultOptions","shouldShowBrowserExtensionError","windowWithMaybeExtension","extensionKey","extensionObject","runtimeId","href","extensionProtocols","isDedicatedExtensionPage","isNWjs","init","browserOptions","stackParserFromStackParserOptions","responseToSpanId","spanIdToEndTimestamp","defaultRequestInstrumentationOptions","instrumentOutgoingRequests","traceFetch","traceXHR","trackFetchStreamPerformance","shouldCreateSpanForRequest","enableHTTPTimings","tracePropagationTargets","_","shouldAttachHeadersWithTargets","updatedTimestamp","createdSpan","addHTTPTimings","xhrCallback","isPerformanceResourceTiming","resourceTimingEntryToSpanData","extractNetworkProtocol","nextHopProtocol","version","_name","char","getAbsoluteTime","resourceTiming","timingSpanData","targetUrl","resolvedUrl","currentOrigin","isSameOriginRequest","isRelativeSameOriginRequest","addTracingHeadersToXhrRequest","setHeaderOnXhr","sentryTraceHeader","sentryBaggageHeader","registerBackgroundTabDetection","cancelledStatus","status","BROWSER_TRACING_INTEGRATION_ID","DEFAULT_BROWSER_TRACING_OPTIONS","browserTracingIntegration","enableInp","enableLongTask","enableLongAnimationFrame","enableInteractions","enableStandaloneClsSpans","beforeStartSpan","markBackgroundSpan","instrumentPageLoad","instrumentNavigation","_collectWebVitals","latestRoute","_createRouteSpan","isPageloadTransaction","finalStartSpanOptions","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","idleSpan","emitFinish","startingUrl","maybeEndActiveSpan","traceOptions","getMetaContent","propagationContext","propagationContextFromHeaders","oldPropagationContext","spanIsSampled","startBrowserTracingPageLoadSpan","startBrowserTracingNavigationSpan","registerInteractionListener","generateTraceId","metaName","metaTag","getDomElement","inflightInteractionSpan","registerInteractionTransaction","currentRootSpanOp","init$1","detectAndReportSvelteKit","detectedSvelteKit","svelteKitProcessor","isSvelteKitApp","addEventProcessor","browserTracingIntegration$1","_instrumentPageload","_instrumentNavigations","initialPath","pageloadSpan","page","routeId","routingSpan","navigating","navigation","rawRouteOrigin","rawRouteDestination","parameterizedRouteOrigin","parameterizedRouteDestination","navigationInfo","actualFetch","switchToFetchProxy","restoreFetch","getDefaultIntegrations$1","globalWithSentryFetchProxy","defaultErrorHandler","handleErrorWithSentry","handleError","input","Sentry.init","myErrorHandler","Sentry.handleErrorWithSentry","matchers","switch_value","dirty","create_if_block_1","insert_hydration","div","anchor","create_if_block","stores","$$props","constructors","components","form","data_0","data_1","data_2","data_3","afterUpdate","mounted","navigated","title","onMount","unsubscribe","$$invalidate","$$value","nodes","__vitePreload","server_loads","dictionary","client_hooks.handleError"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],"sources":["../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/instrument/handlers.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/instrument/globalError.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/instrument/globalUnhandledRejection.js","../../../../../../node_modules/@sentry/core/build/esm/tracing/errors.js","../../../../../../node_modules/@sentry/core/build/esm/tracing/idleSpan.js","../../../../../../node_modules/@sentry/core/build/esm/api.js","../../../../../../node_modules/@sentry/core/build/esm/integration.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/clientreport.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/error.js","../../../../../../node_modules/@sentry/core/build/esm/baseclient.js","../../../../../../node_modules/@sentry/core/build/esm/sdk.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/promisebuffer.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/ratelimit.js","../../../../../../node_modules/@sentry/core/build/esm/transports/base.js","../../../../../../node_modules/@sentry/core/build/esm/utils/sdkMetadata.js","../../../../../../node_modules/@sentry/core/build/esm/utils/traceData.js","../../../../../../node_modules/@sentry/core/build/esm/breadcrumbs.js","../../../../../../node_modules/@sentry/core/build/esm/integrations/functiontostring.js","../../../../../../node_modules/@sentry/core/build/esm/integrations/inboundfilters.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/aggregate-errors.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/url.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/instrument/console.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/severity.js","../../../../../../node_modules/@sentry/core/build/esm/integrations/dedupe.js","../../../../../../node_modules/@sentry/core/build/esm/fetch.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/breadcrumb-log-level.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/supports.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/instrument/fetch.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/env.js","../../../../../../node_modules/@sentry/core/build/esm/utils-hoist/vendor/supportsHistory.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/helpers.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/debug-build.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/eventbuilder.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/userfeedback.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/client.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/debug-build.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/bindReporter.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/types.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/generateUniqueID.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getNavigationEntry.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getActivationStart.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/initMetric.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/observe.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/onHidden.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/runOnce.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getVisibilityWatcher.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenActivated.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onFCP.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getCLS.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getFID.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/interactions.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenIdle.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getINP.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getLCP.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onTTFB.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/instrument.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/utils.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/cls.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/browserMetrics.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/instrument/dom.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/instrument/history.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/getNativeImplementation.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/instrument/xhr.js","../../../../../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/inp.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/transports/fetch.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/stack-parsers.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/breadcrumbs.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/browserapierrors.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/browsersession.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/globalhandlers.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/httpcontext.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/integrations/linkederrors.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/sdk.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/tracing/request.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/tracing/backgroundtab.js","../../../../../../node_modules/@sentry/browser/build/npm/esm/tracing/browserTracingIntegration.js","../../../../../../node_modules/@sentry/svelte/build/esm/sdk.js","../../../../../../node_modules/@sentry/sveltekit/build/esm/client/browserTracingIntegration.js","../../../../../../node_modules/@sentry/sveltekit/build/esm/client/sdk.js","../../../../../../node_modules/@sentry/sveltekit/build/esm/client/handleError.js","../../../../../../src/hooks.client.ts","../../../../../generated/client-optimized/matchers.js","../../../../../generated/root.svelte","../../../../../generated/client-optimized/app.js"],"sourcesContent":["import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../logger.js';\nimport { getFunctionName } from '../stacktrace.js';\n\n// We keep the handlers globally\nconst handlers = {};\nconst instrumented = {};\n\n/** Add a handler function. */\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nfunction resetInstrumentationHandlers() {\n  Object.keys(handlers).forEach(key => {\n    handlers[key ] = undefined;\n  });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nfunction maybeInstrument(type, instrumentFn) {\n  if (!instrumented[type]) {\n    instrumented[type] = true;\n    try {\n      instrumentFn();\n    } catch (e) {\n      DEBUG_BUILD && logger.error(`Error while instrumenting ${type}`, e);\n    }\n  }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = type && handlers[type];\n  if (!typeHandlers) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\nexport { addHandler, maybeInstrument, resetInstrumentationHandlers, triggerHandlers };\n//# sourceMappingURL=handlers.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\nlet _oldOnErrorHandler = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalErrorInstrumentationHandler(handler) {\n  const type = 'error';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError() {\n  _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n  // Note: The reason we are doing window.onerror instead of window.addEventListener('error')\n  // is that we are using this handler in the Loader Script, to handle buffered errors consistently\n  GLOBAL_OBJ.onerror = function (\n    msg,\n    url,\n    line,\n    column,\n    error,\n  ) {\n    const handlerData = {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    };\n    triggerHandlers('error', handlerData);\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  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalErrorInstrumentationHandler };\n//# sourceMappingURL=globalError.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\nlet _oldOnUnhandledRejectionHandler = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalUnhandledRejectionInstrumentationHandler(\n  handler,\n) {\n  const type = 'unhandledrejection';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n  // Note: The reason we are doing window.onunhandledrejection instead of window.addEventListener('unhandledrejection')\n  // is that we are using this handler in the Loader Script, to handle buffered rejections consistently\n  GLOBAL_OBJ.onunhandledrejection = function (e) {\n    const handlerData = e;\n    triggerHandlers('unhandledrejection', handlerData);\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  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalUnhandledRejectionInstrumentationHandler };\n//# sourceMappingURL=globalUnhandledRejection.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { addGlobalErrorInstrumentationHandler } from '../utils-hoist/instrument/globalError.js';\nimport { addGlobalUnhandledRejectionInstrumentationHandler } from '../utils-hoist/instrument/globalUnhandledRejection.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { getActiveSpan, getRootSpan } from '../utils/spanUtils.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\n\nlet errorsInstrumented = false;\n\n/**\n * Ensure that global errors automatically set the active span status.\n */\nfunction registerSpanErrorInstrumentation() {\n  if (errorsInstrumented) {\n    return;\n  }\n\n  errorsInstrumented = true;\n  addGlobalErrorInstrumentationHandler(errorCallback);\n  addGlobalUnhandledRejectionInstrumentationHandler(errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active root span as failed\n */\nfunction errorCallback() {\n  const activeSpan = getActiveSpan();\n  const rootSpan = activeSpan && getRootSpan(activeSpan);\n  if (rootSpan) {\n    const message = 'internal_error';\n    DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occurred`);\n    rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });\n  }\n}\n\n// The function name will be lost when bundling but we need to be able to identify this listener later to maintain the\n// node.js default exit behaviour\nerrorCallback.tag = 'sentry_tracingErrorCallback';\n\nexport { registerSpanErrorInstrumentation };\n//# sourceMappingURL=errors.js.map\n","import { getClient, getCurrentScope } from '../currentScopes.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '../semanticAttributes.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { timestampInSeconds } from '../utils-hoist/time.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { _setSpanForScope } from '../utils/spanOnScope.js';\nimport { getActiveSpan, spanTimeInputToSeconds, getSpanDescendants, spanToJSON, removeChildSpanFromSpan } from '../utils/spanUtils.js';\nimport { SentryNonRecordingSpan } from './sentryNonRecordingSpan.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\nimport { startInactiveSpan } from './trace.js';\n\nconst TRACING_DEFAULTS = {\n  idleTimeout: 1000,\n  finalTimeout: 30000,\n  childSpanTimeout: 15000,\n};\n\nconst FINISH_REASON_HEARTBEAT_FAILED = 'heartbeatFailed';\nconst FINISH_REASON_IDLE_TIMEOUT = 'idleTimeout';\nconst FINISH_REASON_FINAL_TIMEOUT = 'finalTimeout';\nconst FINISH_REASON_EXTERNAL_FINISH = 'externalFinish';\n\n/**\n * An idle span is a span that automatically finishes. It does this by tracking child spans as activities.\n * An idle span is always the active span.\n */\nfunction startIdleSpan(startSpanOptions, options = {}) {\n  // Activities store a list of active spans\n  const activities = new Map();\n\n  // We should not use heartbeat if we finished a span\n  let _finished = false;\n\n  // Timer that tracks idleTimeout\n  let _idleTimeoutID;\n\n  // The reason why the span was finished\n  let _finishReason = FINISH_REASON_EXTERNAL_FINISH;\n\n  let _autoFinishAllowed = !options.disableAutoFinish;\n\n  const _cleanupHooks = [];\n\n  const {\n    idleTimeout = TRACING_DEFAULTS.idleTimeout,\n    finalTimeout = TRACING_DEFAULTS.finalTimeout,\n    childSpanTimeout = TRACING_DEFAULTS.childSpanTimeout,\n    beforeSpanEnd,\n  } = options;\n\n  const client = getClient();\n\n  if (!client || !hasTracingEnabled()) {\n    return new SentryNonRecordingSpan();\n  }\n\n  const scope = getCurrentScope();\n  const previousActiveSpan = getActiveSpan();\n  const span = _startIdleSpan(startSpanOptions);\n\n  // We patch span.end to ensure we can run some things before the span is ended\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  span.end = new Proxy(span.end, {\n    apply(target, thisArg, args) {\n      if (beforeSpanEnd) {\n        beforeSpanEnd(span);\n      }\n\n      // Just ensuring that this keeps working, even if we ever have more arguments here\n      const [definedEndTimestamp, ...rest] = args;\n      const timestamp = definedEndTimestamp || timestampInSeconds();\n      const spanEndTimestamp = spanTimeInputToSeconds(timestamp);\n\n      // Ensure we end with the last span timestamp, if possible\n      const spans = getSpanDescendants(span).filter(child => child !== span);\n\n      // If we have no spans, we just end, nothing else to do here\n      if (!spans.length) {\n        onIdleSpanEnded(spanEndTimestamp);\n        return Reflect.apply(target, thisArg, [spanEndTimestamp, ...rest]);\n      }\n\n      const childEndTimestamps = spans\n        .map(span => spanToJSON(span).timestamp)\n        .filter(timestamp => !!timestamp) ;\n      const latestSpanEndTimestamp = childEndTimestamps.length ? Math.max(...childEndTimestamps) : undefined;\n\n      // In reality this should always exist here, but type-wise it may be undefined...\n      const spanStartTimestamp = spanToJSON(span).start_timestamp;\n\n      // The final endTimestamp should:\n      // * Never be before the span start timestamp\n      // * Be the latestSpanEndTimestamp, if there is one, and it is smaller than the passed span end timestamp\n      // * Otherwise be the passed end timestamp\n      // Final timestamp can never be after finalTimeout\n      const endTimestamp = Math.min(\n        spanStartTimestamp ? spanStartTimestamp + finalTimeout / 1000 : Infinity,\n        Math.max(spanStartTimestamp || -Infinity, Math.min(spanEndTimestamp, latestSpanEndTimestamp || Infinity)),\n      );\n\n      onIdleSpanEnded(endTimestamp);\n      return Reflect.apply(target, thisArg, [endTimestamp, ...rest]);\n    },\n  });\n\n  /**\n   * Cancels the existing idle timeout, if there is one.\n   */\n  function _cancelIdleTimeout() {\n    if (_idleTimeoutID) {\n      clearTimeout(_idleTimeoutID);\n      _idleTimeoutID = undefined;\n    }\n  }\n\n  /**\n   * Restarts idle timeout, if there is no running idle timeout it will start one.\n   */\n  function _restartIdleTimeout(endTimestamp) {\n    _cancelIdleTimeout();\n    _idleTimeoutID = setTimeout(() => {\n      if (!_finished && activities.size === 0 && _autoFinishAllowed) {\n        _finishReason = FINISH_REASON_IDLE_TIMEOUT;\n        span.end(endTimestamp);\n      }\n    }, idleTimeout);\n  }\n\n  /**\n   * Restarts child span timeout, if there is none running it will start one.\n   */\n  function _restartChildSpanTimeout(endTimestamp) {\n    _idleTimeoutID = setTimeout(() => {\n      if (!_finished && _autoFinishAllowed) {\n        _finishReason = FINISH_REASON_HEARTBEAT_FAILED;\n        span.end(endTimestamp);\n      }\n    }, childSpanTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n  function _pushActivity(spanId) {\n    _cancelIdleTimeout();\n    activities.set(spanId, true);\n\n    const endTimestamp = timestampInSeconds();\n    // We need to add the timeout here to have the real endtimestamp of the idle span\n    // Remember timestampInSeconds is in seconds, timeout is in ms\n    _restartChildSpanTimeout(endTimestamp + childSpanTimeout / 1000);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n  function _popActivity(spanId) {\n    if (activities.has(spanId)) {\n      activities.delete(spanId);\n    }\n\n    if (activities.size === 0) {\n      const endTimestamp = timestampInSeconds();\n      // We need to add the timeout here to have the real endtimestamp of the idle span\n      // Remember timestampInSeconds is in seconds, timeout is in ms\n      _restartIdleTimeout(endTimestamp + idleTimeout / 1000);\n    }\n  }\n\n  function onIdleSpanEnded(endTimestamp) {\n    _finished = true;\n    activities.clear();\n\n    _cleanupHooks.forEach(cleanup => cleanup());\n\n    _setSpanForScope(scope, previousActiveSpan);\n\n    const spanJSON = spanToJSON(span);\n\n    const { start_timestamp: startTimestamp } = spanJSON;\n    // This should never happen, but to make TS happy...\n    if (!startTimestamp) {\n      return;\n    }\n\n    const attributes = spanJSON.data || {};\n    if (!attributes[SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON]) {\n      span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, _finishReason);\n    }\n\n    logger.log(`[Tracing] Idle span \"${spanJSON.op}\" finished`);\n\n    const childSpans = getSpanDescendants(span).filter(child => child !== span);\n\n    let discardedSpans = 0;\n    childSpans.forEach(childSpan => {\n      // We cancel all pending spans with status \"cancelled\" to indicate the idle span was finished early\n      if (childSpan.isRecording()) {\n        childSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'cancelled' });\n        childSpan.end(endTimestamp);\n        DEBUG_BUILD &&\n          logger.log('[Tracing] Cancelling span since span ended early', JSON.stringify(childSpan, undefined, 2));\n      }\n\n      const childSpanJSON = spanToJSON(childSpan);\n      const { timestamp: childEndTimestamp = 0, start_timestamp: childStartTimestamp = 0 } = childSpanJSON;\n\n      const spanStartedBeforeIdleSpanEnd = childStartTimestamp <= endTimestamp;\n\n      // Add a delta with idle timeout so that we prevent false positives\n      const timeoutWithMarginOfError = (finalTimeout + idleTimeout) / 1000;\n      const spanEndedBeforeFinalTimeout = childEndTimestamp - childStartTimestamp <= timeoutWithMarginOfError;\n\n      if (DEBUG_BUILD) {\n        const stringifiedSpan = JSON.stringify(childSpan, undefined, 2);\n        if (!spanStartedBeforeIdleSpanEnd) {\n          logger.log('[Tracing] Discarding span since it happened after idle span was finished', stringifiedSpan);\n        } else if (!spanEndedBeforeFinalTimeout) {\n          logger.log('[Tracing] Discarding span since it finished after idle span final timeout', stringifiedSpan);\n        }\n      }\n\n      if (!spanEndedBeforeFinalTimeout || !spanStartedBeforeIdleSpanEnd) {\n        removeChildSpanFromSpan(span, childSpan);\n        discardedSpans++;\n      }\n    });\n\n    if (discardedSpans > 0) {\n      span.setAttribute('sentry.idle_span_discarded_spans', discardedSpans);\n    }\n  }\n\n  _cleanupHooks.push(\n    client.on('spanStart', startedSpan => {\n      // If we already finished the idle span,\n      // or if this is the idle span itself being started,\n      // or if the started span has already been closed,\n      // we don't care about it for activity\n      if (_finished || startedSpan === span || !!spanToJSON(startedSpan).timestamp) {\n        return;\n      }\n\n      const allSpans = getSpanDescendants(span);\n\n      // If the span that was just started is a child of the idle span, we should track it\n      if (allSpans.includes(startedSpan)) {\n        _pushActivity(startedSpan.spanContext().spanId);\n      }\n    }),\n  );\n\n  _cleanupHooks.push(\n    client.on('spanEnd', endedSpan => {\n      if (_finished) {\n        return;\n      }\n\n      _popActivity(endedSpan.spanContext().spanId);\n    }),\n  );\n\n  _cleanupHooks.push(\n    client.on('idleSpanEnableAutoFinish', spanToAllowAutoFinish => {\n      if (spanToAllowAutoFinish === span) {\n        _autoFinishAllowed = true;\n        _restartIdleTimeout();\n\n        if (activities.size) {\n          _restartChildSpanTimeout();\n        }\n      }\n    }),\n  );\n\n  // We only start the initial idle timeout if we are not delaying the auto finish\n  if (!options.disableAutoFinish) {\n    _restartIdleTimeout();\n  }\n\n  setTimeout(() => {\n    if (!_finished) {\n      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'deadline_exceeded' });\n      _finishReason = FINISH_REASON_FINAL_TIMEOUT;\n      span.end();\n    }\n  }, finalTimeout);\n\n  return span;\n}\n\nfunction _startIdleSpan(options) {\n  const span = startInactiveSpan(options);\n\n  _setSpanForScope(getCurrentScope(), span);\n\n  DEBUG_BUILD && logger.log('[Tracing] Started span is an idle span');\n\n  return span;\n}\n\nexport { TRACING_DEFAULTS, startIdleSpan };\n//# sourceMappingURL=idleSpan.js.map\n","import { makeDsn, dsnToString } from './utils-hoist/dsn.js';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn) {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn) {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn, sdkInfo) {\n  const params = {\n    sentry_version: SENTRY_API_VERSION,\n  };\n\n  if (dsn.publicKey) {\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    params.sentry_key = dsn.publicKey;\n  }\n\n  if (sdkInfo) {\n    params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;\n  }\n\n  return new URLSearchParams(params).toString();\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 */\nfunction getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel, sdkInfo) {\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nfunction getReportDialogEndpoint(\n  dsnLike,\n  dialogOptions\n\n,\n) {\n  const dsn = makeDsn(dsnLike);\n  if (!dsn) {\n    return '';\n  }\n\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'onClose') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };\n//# sourceMappingURL=api.js.map\n","import { getClient } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { logger } from './utils-hoist/logger.js';\n\nconst installedIntegrations = [];\n\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 * preserve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations) {\n  const integrationsByName = {};\n\n  integrations.forEach((currentInstance) => {\n    const { name } = currentInstance;\n\n    const existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nfunction getIntegrationsToSetup(options) {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach((integration) => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations;\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    const resolvedUserIntegrations = userIntegrations(defaultIntegrations);\n    integrations = Array.isArray(resolvedUserIntegrations) ? resolvedUserIntegrations : [resolvedUserIntegrations];\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  const finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend` or\n  // `beforeSendTransaction`. It therefore has to run after all other integrations, so that the changes of all event\n  // processors will be reflected in the printed values. For lack of a more elegant way to guarantee that, we therefore\n  // locate it and, assuming it exists, pop it out of its current spot and shove it onto the end of the array.\n  const debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n  if (debugIndex > -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1) ;\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nfunction setupIntegrations(client, integrations) {\n  const integrationIndex = {};\n\n  integrations.forEach(integration => {\n    // guard against empty provided integrations\n    if (integration) {\n      setupIntegration(client, integration, integrationIndex);\n    }\n  });\n\n  return integrationIndex;\n}\n\n/**\n * Execute the `afterAllSetup` hooks of the given integrations.\n */\nfunction afterSetupIntegrations(client, integrations) {\n  for (const integration of integrations) {\n    // guard against empty provided integrations\n    if (integration && integration.afterAllSetup) {\n      integration.afterAllSetup(client);\n    }\n  }\n}\n\n/** Setup a single integration.  */\nfunction setupIntegration(client, integration, integrationIndex) {\n  if (integrationIndex[integration.name]) {\n    DEBUG_BUILD && logger.log(`Integration skipped because it was already installed: ${integration.name}`);\n    return;\n  }\n  integrationIndex[integration.name] = integration;\n\n  // `setupOnce` is only called the first time\n  if (installedIntegrations.indexOf(integration.name) === -1 && typeof integration.setupOnce === 'function') {\n    integration.setupOnce();\n    installedIntegrations.push(integration.name);\n  }\n\n  // `setup` is run for each client\n  if (integration.setup && typeof integration.setup === 'function') {\n    integration.setup(client);\n  }\n\n  if (typeof integration.preprocessEvent === 'function') {\n    const callback = integration.preprocessEvent.bind(integration) ;\n    client.on('preprocessEvent', (event, hint) => callback(event, hint, client));\n  }\n\n  if (typeof integration.processEvent === 'function') {\n    const callback = integration.processEvent.bind(integration) ;\n\n    const processor = Object.assign((event, hint) => callback(event, hint, client), {\n      id: integration.name,\n    });\n\n    client.addEventProcessor(processor);\n  }\n\n  DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);\n}\n\n/** Add an integration to the current scope's client. */\nfunction addIntegration(integration) {\n  const client = getClient();\n\n  if (!client) {\n    DEBUG_BUILD && logger.warn(`Cannot add integration \"${integration.name}\" because no SDK Client is available.`);\n    return;\n  }\n\n  client.addIntegration(integration);\n}\n\n/**\n * Define an integration function that can be used to create an integration instance.\n * Note that this by design hides the implementation details of the integration, as they are considered internal.\n */\nfunction defineIntegration(fn) {\n  return fn;\n}\n\nexport { addIntegration, afterSetupIntegrations, defineIntegration, getIntegrationsToSetup, installedIntegrations, setupIntegration, setupIntegrations };\n//# sourceMappingURL=integration.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  const clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n\n   constructor(\n     message,\n    logLevel = 'warn',\n  ) {\n    super(message);this.message = message;\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { getTraceContextFromScope, getCurrentScope, getIsolationScope } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegration, afterSetupIntegrations, setupIntegrations } from './integration.js';\nimport { updateSession } from './session.js';\nimport { getDynamicSamplingContextFromScope } from './tracing/dynamicSamplingContext.js';\nimport { createClientReportEnvelope } from './utils-hoist/clientreport.js';\nimport { makeDsn, dsnToString } from './utils-hoist/dsn.js';\nimport { addItemToEnvelope, createAttachmentEnvelopeItem } from './utils-hoist/envelope.js';\nimport { SentryError } from './utils-hoist/error.js';\nimport { isPrimitive, isThenable, isPlainObject, isParameterizedString } from './utils-hoist/is.js';\nimport { logger, consoleSandbox } from './utils-hoist/logger.js';\nimport { uuid4, checkOrSetAlreadyCaught } from './utils-hoist/misc.js';\nimport { resolvedSyncPromise, SyncPromise, rejectedSyncPromise } from './utils-hoist/syncpromise.js';\nimport { parseSampleRate } from './utils/parseSampleRate.js';\nimport { prepareEvent } from './utils/prepareEvent.js';\nimport { showSpanDropWarning } from './utils/spanUtils.js';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nclass BaseClient {\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\n  /** Number of calls being processed */\n\n  /** Holds flushable  */\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {\n    this._options = options;\n    this._integrations = {};\n    this._numProcessing = 0;\n    this._outcomes = {};\n    this._hooks = {};\n    this._eventProcessors = [];\n\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n    } else {\n      DEBUG_BUILD && logger.warn('No DSN provided, client will not send events.');\n    }\n\n    if (this._dsn) {\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(\n        this._dsn,\n        options.tunnel,\n        options._metadata ? options._metadata.sdk : undefined,\n      );\n      this._transport = options.transport({\n        tunnel: this._options.tunnel,\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    }\n\n    // TODO(v9): Remove this deprecation warning\n    const tracingOptions = ['enableTracing', 'tracesSampleRate', 'tracesSampler'] ;\n    const undefinedOption = tracingOptions.find(option => option in options && options[option] == undefined);\n    if (undefinedOption) {\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[Sentry] Deprecation warning: \\`${undefinedOption}\\` is set to undefined, which leads to tracing being enabled. In v9, a value of \\`undefined\\` will result in tracing being disabled.`,\n        );\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureException(exception, hint, scope) {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    this._process(\n      this.eventFromException(exception, hintWithEventId).then(event =>\n        this._captureEvent(event, hintWithEventId, scope),\n      ),\n    );\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n    level,\n    hint,\n    currentScope,\n  ) {\n    const hintWithEventId = {\n      event_id: uuid4(),\n      ...hint,\n    };\n\n    const eventMessage = isParameterizedString(message) ? message : String(message);\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(eventMessage, level, hintWithEventId)\n      : this.eventFromException(message, hintWithEventId);\n\n    this._process(promisedEvent.then(event => this._captureEvent(event, hintWithEventId, currentScope)));\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, currentScope) {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanScope = sdkProcessingMetadata.capturedSpanScope;\n\n    this._process(this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope));\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!(typeof session.release === 'string')) {\n      DEBUG_BUILD && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getDsn() {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * @see SdkMetadata\n   *\n   * @return The metadata of the SDK\n   */\n   getSdkMetadata() {\n    return this._options._metadata;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransport() {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   flush(timeout) {\n    const transport = this._transport;\n    if (transport) {\n      this.emit('flush');\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   close(timeout) {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      this.emit('close');\n      return result;\n    });\n  }\n\n  /** Get all installed event processors. */\n   getEventProcessors() {\n    return this._eventProcessors;\n  }\n\n  /** @inheritDoc */\n   addEventProcessor(eventProcessor) {\n    this._eventProcessors.push(eventProcessor);\n  }\n\n  /** @inheritdoc */\n   init() {\n    if (\n      this._isEnabled() ||\n      // Force integrations to be setup even if no DSN was set when we have\n      // Spotlight enabled. This is particularly important for browser as we\n      // don't support the `spotlight` option there and rely on the users\n      // adding the `spotlightBrowserIntegration()` to their integrations which\n      // wouldn't get initialized with the check below when there's no DSN set.\n      this._options.integrations.some(({ name }) => name.startsWith('Spotlight'))\n    ) {\n      this._setupIntegrations();\n    }\n  }\n\n  /**\n   * Gets an installed integration by its name.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `name` was installed.\n   */\n   getIntegrationByName(integrationName) {\n    return this._integrations[integrationName] ;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addIntegration(integration) {\n    const isAlreadyInstalled = this._integrations[integration.name];\n\n    // This hook takes care of only installing if not already installed\n    setupIntegration(this, integration, this._integrations);\n    // Here we need to check manually to make sure to not run this multiple times\n    if (!isAlreadyInstalled) {\n      afterSetupIntegrations(this, [integration]);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    this.emit('beforeSendEvent', event, hint);\n\n    let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n    for (const attachment of hint.attachments || []) {\n      env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));\n    }\n\n    const promise = this.sendEnvelope(env);\n    if (promise) {\n      promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(env);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category, eventOrCount) {\n    if (this._options.sendClientReports) {\n      // TODO v9: We do not need the `event` passed as third argument anymore, and can possibly remove this overload\n      // If event is passed as third argument, we assume this is a count of 1\n      const count = typeof eventOrCount === 'number' ? eventOrCount : 1;\n\n      // We want to track each category (error, transaction, session, replay_event) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      DEBUG_BUILD && logger.log(`Recording outcome: \"${key}\"${count > 1 ? ` (${count} times)` : ''}`);\n      this._outcomes[key] = (this._outcomes[key] || 0) + count;\n    }\n  }\n\n  // Keep on() & emit() signatures in sync with types' client.ts interface\n  /* eslint-disable @typescript-eslint/unified-signatures */\n\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n   on(hook, callback) {\n    const hooks = (this._hooks[hook] = this._hooks[hook] || []);\n\n    // @ts-expect-error We assume the types are correct\n    hooks.push(callback);\n\n    // This function returns a callback execution handler that, when invoked,\n    // deregisters a callback. This is crucial for managing instances where callbacks\n    // need to be unregistered to prevent self-referencing in callback closures,\n    // ensuring proper garbage collection.\n    return () => {\n      // @ts-expect-error We assume the types are correct\n      const cbIndex = hooks.indexOf(callback);\n      if (cbIndex > -1) {\n        hooks.splice(cbIndex, 1);\n      }\n    };\n  }\n\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n   emit(hook, ...rest) {\n    const callbacks = this._hooks[hook];\n    if (callbacks) {\n      callbacks.forEach(callback => callback(...rest));\n    }\n  }\n\n  /**\n   * @inheritdoc\n   */\n   sendEnvelope(envelope) {\n    this.emit('beforeEnvelope', envelope);\n\n    if (this._isEnabled() && this._transport) {\n      return this._transport.send(envelope).then(null, reason => {\n        DEBUG_BUILD && logger.error('Error while sending envelope:', reason);\n        return reason;\n      });\n    }\n\n    DEBUG_BUILD && logger.error('Transport disabled');\n\n    return resolvedSyncPromise({});\n  }\n\n  /* eslint-enable @typescript-eslint/unified-signatures */\n\n  /** Setup integrations for this client. */\n   _setupIntegrations() {\n    const { integrations } = this._options;\n    this._integrations = setupIntegrations(this, integrations);\n    afterSetupIntegrations(this, integrations);\n  }\n\n  /** Updates existing session based on the provided event */\n   _updateSessionFromEvent(session, event) {\n    let crashed = false;\n    let errored = false;\n    const exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n   _isClientDoneProcessing(timeout) {\n    return new SyncPromise(resolve => {\n      let ticked = 0;\n      const tick = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a transport is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._transport !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param currentScope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n   _prepareEvent(\n    event,\n    hint,\n    currentScope = getCurrentScope(),\n    isolationScope = getIsolationScope(),\n  ) {\n    const options = this.getOptions();\n    const integrations = Object.keys(this._integrations);\n    if (!hint.integrations && integrations.length > 0) {\n      hint.integrations = integrations;\n    }\n\n    this.emit('preprocessEvent', event, hint);\n\n    if (!event.type) {\n      isolationScope.setLastEventId(event.event_id || hint.event_id);\n    }\n\n    return prepareEvent(options, event, hint, currentScope, this, isolationScope).then(evt => {\n      if (evt === null) {\n        return evt;\n      }\n\n      evt.contexts = {\n        trace: getTraceContextFromScope(currentScope),\n        ...evt.contexts,\n      };\n\n      const dynamicSamplingContext = getDynamicSamplingContextFromScope(this, currentScope);\n\n      evt.sdkProcessingMetadata = {\n        dynamicSamplingContext,\n        ...evt.sdkProcessingMetadata,\n      };\n\n      return evt;\n    });\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n   _captureEvent(event, hint = {}, scope) {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if (DEBUG_BUILD) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          const sentryError = reason ;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param currentScope 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   _processEvent(event, hint, currentScope) {\n    const options = this.getOptions();\n    const { sampleRate } = options;\n\n    const isTransaction = isTransactionEvent(event);\n    const isError = isErrorEvent(event);\n    const eventType = event.type || 'error';\n    const beforeSendLabel = `before send for type \\`${eventType}\\``;\n\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    const parsedSampleRate = typeof sampleRate === 'undefined' ? undefined : parseSampleRate(sampleRate);\n    if (isError && typeof parsedSampleRate === 'number' && Math.random() > parsedSampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error', event);\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    const dataCategory = eventType === 'replay_event' ? 'replay' : eventType;\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanIsolationScope = sdkProcessingMetadata.capturedSpanIsolationScope;\n\n    return this._prepareEvent(event, hint, currentScope, capturedSpanIsolationScope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', dataCategory, event);\n          throw new SentryError('An event processor returned `null`, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data ).__sentry__ === true;\n        if (isInternalException) {\n          return prepared;\n        }\n\n        const result = processBeforeSend(this, options, prepared, hint);\n        return _validateBeforeSendResult(result, beforeSendLabel);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', dataCategory, event);\n          if (isTransaction) {\n            const spans = event.spans || [];\n            // the transaction itself counts as one span, plus all the child spans that are added\n            const spanCount = 1 + spans.length;\n            this.recordDroppedEvent('before_send', 'span', spanCount);\n          }\n          throw new SentryError(`${beforeSendLabel} returned \\`null\\`, will not send event.`, 'log');\n        }\n\n        const session = currentScope && currentScope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        if (isTransaction) {\n          const spanCountBefore =\n            (processedEvent.sdkProcessingMetadata && processedEvent.sdkProcessingMetadata.spanCountBeforeProcessing) ||\n            0;\n          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;\n\n          const droppedSpanCount = spanCountBefore - spanCountAfter;\n          if (droppedSpanCount > 0) {\n            this.recordDroppedEvent('before_send', 'span', droppedSpanCount);\n          }\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n   _process(promise) {\n    this._numProcessing++;\n    void promise.then(\n      value => {\n        this._numProcessing--;\n        return value;\n      },\n      reason => {\n        this._numProcessing--;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n   _clearOutcomes() {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.entries(outcomes).map(([key, quantity]) => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity,\n      };\n    });\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    DEBUG_BUILD && logger.log('Flushing outcomes...');\n\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      DEBUG_BUILD && logger.log('No outcomes to send');\n      return;\n    }\n\n    // This is really the only place where we want to check for a DSN and only send outcomes then\n    if (!this._dsn) {\n      DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);\n\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\nfunction _validateBeforeSendResult(\n  beforeSendResult,\n  beforeSendLabel,\n) {\n  const invalidValueError = `${beforeSendLabel} must return \\`null\\` or a valid event.`;\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(\n      event => {\n        if (!isPlainObject(event) && event !== null) {\n          throw new SentryError(invalidValueError);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`${beforeSendLabel} rejected with ${e}`);\n      },\n    );\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n  return beforeSendResult;\n}\n\n/**\n * Process the matching `beforeSendXXX` callback.\n */\nfunction processBeforeSend(\n  client,\n  options,\n  event,\n  hint,\n) {\n  const { beforeSend, beforeSendTransaction, beforeSendSpan } = options;\n\n  if (isErrorEvent(event) && beforeSend) {\n    return beforeSend(event, hint);\n  }\n\n  if (isTransactionEvent(event)) {\n    if (event.spans && beforeSendSpan) {\n      const processedSpans = [];\n      for (const span of event.spans) {\n        const processedSpan = beforeSendSpan(span);\n        if (processedSpan) {\n          processedSpans.push(processedSpan);\n        } else {\n          showSpanDropWarning();\n          client.recordDroppedEvent('before_send', 'span');\n        }\n      }\n      event.spans = processedSpans;\n    }\n\n    if (beforeSendTransaction) {\n      if (event.spans) {\n        // We store the # of spans before processing in SDK metadata,\n        // so we can compare it afterwards to determine how many spans were dropped\n        const spanCountBefore = event.spans.length;\n        event.sdkProcessingMetadata = {\n          ...event.sdkProcessingMetadata,\n          spanCountBeforeProcessing: spanCountBefore,\n        };\n      }\n      return beforeSendTransaction(event, hint);\n    }\n  }\n\n  return event;\n}\n\nfunction isErrorEvent(event) {\n  return event.type === undefined;\n}\n\nfunction isTransactionEvent(event) {\n  return event.type === 'transaction';\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { getCurrentScope } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { logger, consoleSandbox } from './utils-hoist/logger.js';\n\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 */\nfunction initAndBind(\n  clientClass,\n  options,\n) {\n  if (options.debug === true) {\n    if (DEBUG_BUILD) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      consoleSandbox(() => {\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  const scope = getCurrentScope();\n  scope.update(options.initialScope);\n\n  const client = new clientClass(options);\n  setCurrentClient(client);\n  client.init();\n  return client;\n}\n\n/**\n * Make the given client the current client.\n */\nfunction setCurrentClient(client) {\n  getCurrentScope().setClient(client);\n}\n\nexport { initAndBind, setCurrentClient };\n//# sourceMappingURL=sdk.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  const buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0] || Promise.resolve(undefined);\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nconst 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 */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nfunction disabledUntil(limits, dataCategory) {\n  return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, dataCategory, now = Date.now()) {\n  return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  const updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>\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     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n     *         Only present if rate limit applies to the metric_bucket data category.\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories, , , namespaces] = limit.split(':', 5) ;\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          if (category === 'metric_bucket') {\n            // namespaces will be present when category === 'metric_bucket'\n            if (!namespaces || namespaces.split(';').includes('custom')) {\n              updatedRateLimits[category] = now + delay;\n            }\n          } else {\n            updatedRateLimits[category] = now + delay;\n          }\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { forEachEnvelopeItem, envelopeItemTypeToDataCategory, createEnvelope, serializeEnvelope } from '../utils-hoist/envelope.js';\nimport { SentryError } from '../utils-hoist/error.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { makePromiseBuffer } from '../utils-hoist/promisebuffer.js';\nimport { isRateLimited, updateRateLimits } from '../utils-hoist/ratelimit.js';\nimport { resolvedSyncPromise } from '../utils-hoist/syncpromise.js';\n\nconst DEFAULT_TRANSPORT_BUFFER_SIZE = 64;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n  options,\n  makeRequest,\n  buffer = makePromiseBuffer(\n    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,\n  ),\n) {\n  let rateLimits = {};\n  const flush = (timeout) => buffer.drain(timeout);\n\n  function send(envelope) {\n    const filteredEnvelopeItems = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const dataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, dataCategory)) {\n        const event = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent('ratelimit_backoff', dataCategory, event);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise({});\n    }\n\n    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (item, type) => {\n        const event = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);\n      });\n    };\n\n    const requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            DEBUG_BUILD && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n          return response;\n        },\n        error => {\n          recordEnvelopeLoss('network_error');\n          throw error;\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          DEBUG_BUILD && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise({});\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n\nfunction getEventForEnvelopeItem(item, type) {\n  if (type !== 'event' && type !== 'transaction') {\n    return undefined;\n  }\n\n  return Array.isArray(item) ? (item )[1] : undefined;\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { SDK_VERSION } from '../utils-hoist/version.js';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n *\n * Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.\n * We don't extract it for bundle size reasons.\n * @see https://github.com/getsentry/sentry-javascript/pull/7404\n * @see https://github.com/getsentry/sentry-javascript/pull/4196\n *\n * If you make changes to this function consider updating the others as well.\n *\n * @param options SDK options object that gets mutated\n * @param names list of package names\n */\nfunction applySdkMetadata(options, name, names = [name], source = 'npm') {\n  const metadata = options._metadata || {};\n\n  if (!metadata.sdk) {\n    metadata.sdk = {\n      name: `sentry.javascript.${name}`,\n      packages: names.map(name => ({\n        name: `${source}:@sentry/${name}`,\n        version: SDK_VERSION,\n      })),\n      version: SDK_VERSION,\n    };\n  }\n\n  options._metadata = metadata;\n}\n\nexport { applySdkMetadata };\n//# sourceMappingURL=sdkMetadata.js.map\n","import { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { getMainCarrier } from '../carrier.js';\nimport { getClient, getCurrentScope } from '../currentScopes.js';\nimport { isEnabled } from '../exports.js';\nimport '../tracing/errors.js';\nimport '../utils-hoist/version.js';\nimport '../utils-hoist/debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport '../debug-build.js';\nimport '../utils-hoist/time.js';\nimport { getActiveSpan, spanToTraceHeader } from './spanUtils.js';\nimport { TRACEPARENT_REGEXP, generateSentryTraceHeader } from '../utils-hoist/tracing.js';\nimport { getDynamicSamplingContextFromSpan, getDynamicSamplingContextFromScope } from '../tracing/dynamicSamplingContext.js';\nimport { dynamicSamplingContextToSentryBaggageHeader } from '../utils-hoist/baggage.js';\n\n/**\n * Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation\n * context) and serializes it to `sentry-trace` and `baggage` values to strings. These values can be used to propagate\n * a trace via our tracing Http headers or Html `<meta>` tags.\n *\n * This function also applies some validation to the generated sentry-trace and baggage values to ensure that\n * only valid strings are returned.\n *\n * @returns an object with the tracing data values. The object keys are the name of the tracing key to be used as header\n * or meta tag name.\n */\nfunction getTraceData(options = {}) {\n  const client = getClient();\n  if (!isEnabled() || !client) {\n    return {};\n  }\n\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  if (acs.getTraceData) {\n    return acs.getTraceData(options);\n  }\n\n  const scope = getCurrentScope();\n  const span = options.span || getActiveSpan();\n  const sentryTrace = span ? spanToTraceHeader(span) : scopeToTraceHeader(scope);\n  const dsc = span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromScope(client, scope);\n  const baggage = dynamicSamplingContextToSentryBaggageHeader(dsc);\n\n  const isValidSentryTraceHeader = TRACEPARENT_REGEXP.test(sentryTrace);\n  if (!isValidSentryTraceHeader) {\n    logger.warn('Invalid sentry-trace data. Cannot generate trace data');\n    return {};\n  }\n\n  return {\n    'sentry-trace': sentryTrace,\n    baggage,\n  };\n}\n\n/**\n * Get a sentry-trace header value for the given scope.\n */\nfunction scopeToTraceHeader(scope) {\n  // TODO(v9): Use generateSpanId() instead of spanId\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceId, sampled, spanId } = scope.getPropagationContext();\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\nexport { getTraceData };\n//# sourceMappingURL=traceData.js.map\n","import { getClient, getIsolationScope } from './currentScopes.js';\nimport { consoleSandbox } from './utils-hoist/logger.js';\nimport { dateTimestampInSeconds } from './utils-hoist/time.js';\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * 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 */\nfunction addBreadcrumb(breadcrumb, hint) {\n  const client = getClient();\n  const isolationScope = getIsolationScope();\n\n  if (!client) return;\n\n  const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions();\n\n  if (maxBreadcrumbs <= 0) return;\n\n  const timestamp = dateTimestampInSeconds();\n  const mergedBreadcrumb = { timestamp, ...breadcrumb };\n  const finalBreadcrumb = beforeBreadcrumb\n    ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n    : mergedBreadcrumb;\n\n  if (finalBreadcrumb === null) return;\n\n  if (client.emit) {\n    client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);\n  }\n\n  isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n}\n\nexport { addBreadcrumb };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { getClient } from '../currentScopes.js';\nimport { defineIntegration } from '../integration.js';\nimport { getOriginalFunction } from '../utils-hoist/object.js';\n\nlet originalFunctionToString;\n\nconst INTEGRATION_NAME = 'FunctionToString';\n\nconst SETUP_CLIENTS = new WeakMap();\n\nconst _functionToStringIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      originalFunctionToString = Function.prototype.toString;\n\n      // intrinsics (like Function.prototype) might be immutable in some environments\n      // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)\n      try {\n        Function.prototype.toString = function ( ...args) {\n          const originalFunction = getOriginalFunction(this);\n          const context =\n            SETUP_CLIENTS.has(getClient() ) && originalFunction !== undefined ? originalFunction : this;\n          return originalFunctionToString.apply(context, args);\n        };\n      } catch (e) {\n        // ignore errors here, just don't patch this\n      }\n    },\n    setup(client) {\n      SETUP_CLIENTS.set(client, true);\n    },\n  };\n}) ;\n\n/**\n * Patch toString calls to return proper name for wrapped functions.\n *\n * ```js\n * Sentry.init({\n *   integrations: [\n *     functionToStringIntegration(),\n *   ],\n * });\n * ```\n */\nconst functionToStringIntegration = defineIntegration(_functionToStringIntegration);\n\nexport { functionToStringIntegration };\n//# sourceMappingURL=functiontostring.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { defineIntegration } from '../integration.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { getEventDescription } from '../utils-hoist/misc.js';\nimport { stringMatchesSomePattern } from '../utils-hoist/string.js';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [\n  /^Script error\\.?$/,\n  /^Javascript error: Script error\\.? on line 0$/,\n  /^ResizeObserver loop completed with undelivered notifications.$/, // The browser logs this when a ResizeObserver handler takes a bit longer. Usually this is not an actual issue though. It indicates slowness.\n  /^Cannot redefine property: googletag$/, // This is thrown when google tag manager is used in combination with an ad blocker\n  \"undefined is not an object (evaluating 'a.L')\", // Random error that happens but not actionable or noticeable to end-users.\n  'can\\'t redefine non-configurable property \"solana\"', // Probably a browser extension or custom browser (Brave) throwing this error\n  \"vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)\", // Error thrown by GTM, seemingly not affecting end-users\n  \"Can't find variable: _AutofillCallbackHandler\", // Unactionable error in instagram webview https://developers.facebook.com/community/threads/320013549791141/\n  /^Non-Error promise rejection captured with value: Object Not Found Matching Id:\\d+, MethodName:simulateEvent, ParamCount:\\d+$/, // unactionable error from CEFSharp, a .NET library that embeds chromium in .NET apps\n];\n\n/** Options for the InboundFilters integration */\n\nconst INTEGRATION_NAME = 'InboundFilters';\nconst _inboundFiltersIntegration = ((options = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(event, _hint, client) {\n      const clientOptions = client.getOptions();\n      const mergedOptions = _mergeOptions(options, clientOptions);\n      return _shouldDropEvent(event, mergedOptions) ? null : event;\n    },\n  };\n}) ;\n\nconst inboundFiltersIntegration = defineIntegration(_inboundFiltersIntegration);\n\nfunction _mergeOptions(\n  internalOptions = {},\n  clientOptions = {},\n) {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS),\n    ],\n    ignoreTransactions: [...(internalOptions.ignoreTransactions || []), ...(clientOptions.ignoreTransactions || [])],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    DEBUG_BUILD &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isUselessError(event)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to not having an error message, error type or stacktrace.\\nEvent: ${getEventDescription(\n          event,\n        )}`,\n      );\n    return true;\n  }\n  if (_isIgnoredTransaction(event, options.ignoreTransactions)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreTransactions\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  // If event.type, this is not an error\n  if (event.type || !ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));\n}\n\nfunction _isIgnoredTransaction(event, ignoreTransactions) {\n  if (event.type !== 'transaction' || !ignoreTransactions || !ignoreTransactions.length) {\n    return false;\n  }\n\n  const name = event.transaction;\n  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : stringMatchesSomePattern(url, denyUrls);\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : stringMatchesSomePattern(url, allowUrls);\n}\n\nfunction _getPossibleEventMessages(event) {\n  const possibleMessages = [];\n\n  if (event.message) {\n    possibleMessages.push(event.message);\n  }\n\n  let lastException;\n  try {\n    // @ts-expect-error Try catching to save bundle size\n    lastException = event.exception.values[event.exception.values.length - 1];\n  } catch (e) {\n    // try catching to save bundle size checking existence of variables\n  }\n\n  if (lastException) {\n    if (lastException.value) {\n      possibleMessages.push(lastException.value);\n      if (lastException.type) {\n        possibleMessages.push(`${lastException.type}: ${lastException.value}`);\n      }\n    }\n  }\n\n  return possibleMessages;\n}\n\nfunction _isSentryError(event) {\n  try {\n    // @ts-expect-error can't be a sentry error if undefined\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames = []) {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event) {\n  try {\n    let frames;\n    try {\n      // @ts-expect-error we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    DEBUG_BUILD && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nfunction _isUselessError(event) {\n  if (event.type) {\n    // event is not an error\n    return false;\n  }\n\n  // We only want to consider events for dropping that actually have recorded exception values.\n  if (!event.exception || !event.exception.values || event.exception.values.length === 0) {\n    return false;\n  }\n\n  return (\n    // No top-level message\n    !event.message &&\n    // There are no exception values that have a stacktrace, a non-generic-Error type or value\n    !event.exception.values.some(value => value.stacktrace || (value.type && value.type !== 'Error') || value.value)\n  );\n}\n\nexport { inboundFiltersIntegration };\n//# sourceMappingURL=inboundfilters.js.map\n","import { isInstanceOf } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nfunction applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation,\n  parser,\n  maxValueLimit = 250,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException ,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation,\n  parser,\n  limit,\n  error,\n  key,\n  prevExceptions,\n  exception,\n  exceptionId,\n) {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  // Recursively call this function in order to walk down a chain of errors\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception, exceptionId) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception,\n  source,\n  exceptionId,\n  parentId,\n) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions, maxValueLength) {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n\nexport { applyAggregateErrorsToEvent };\n//# sourceMappingURL=aggregate-errors.js.map\n","/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url) {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    search: query,\n    hash: fragment,\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n  return (urlPath.split(/[?#]/, 1) )[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n *\n * @deprecated This function will be removed in the next major version.\n */\n// TODO(v9): Hoist this function into the places where we use it. (as it stands only react router v6 instrumentation)\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span name\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nfunction getSanitizedUrlString(url) {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    (host &&\n      host\n        // Always filter out authority\n        .replace(/^.*@/, '[filtered]:[filtered]@')\n        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n        // TODO: Use new URL global if it exists\n        .replace(/(:80)$/, '')\n        .replace(/(:443)$/, '')) ||\n    '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n\nexport { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","import { CONSOLE_LEVELS, originalConsoleMethods } from '../logger.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addConsoleInstrumentationHandler(handler) {\n  const type = 'console';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole() {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args) {\n        const handlerData = { args, level };\n        triggerHandlers('console', handlerData);\n\n        const log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n\nexport { addConsoleInstrumentationHandler };\n//# sourceMappingURL=console.js.map\n","/**\n * @deprecated This variable has been deprecated and will be removed in the next major version.\n */\nconst validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\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 */\nfunction severityLevelFromString(level) {\n  return (\n    level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log'\n  ) ;\n}\n\nexport { severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","import { defineIntegration } from '../integration.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { getFramesFromEvent } from '../utils-hoist/stacktrace.js';\n\nconst INTEGRATION_NAME = 'Dedupe';\n\nconst _dedupeIntegration = (() => {\n  let previousEvent;\n\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(currentEvent) {\n      // We want to ignore any non-error type events, e.g. transactions or replays\n      // These should never be deduped, and also not be compared against as _previousEvent.\n      if (currentEvent.type) {\n        return currentEvent;\n      }\n\n      // Juuust in case something goes wrong\n      try {\n        if (_shouldDropEvent(currentEvent, previousEvent)) {\n          DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n          return null;\n        }\n      } catch (_oO) {} // eslint-disable-line no-empty\n\n      return (previousEvent = currentEvent);\n    },\n  };\n}) ;\n\n/**\n * Deduplication filter.\n */\nconst dedupeIntegration = defineIntegration(_dedupeIntegration);\n\n/** only exported for tests. */\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\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  let currentFrames = getFramesFromEvent(currentEvent);\n  let previousFrames = getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames ;\n  previousFrames = previousFrames ;\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const frameA = previousFrames[i];\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint ;\n  previousFingerprint = previousFingerprint ;\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\nexport { _shouldDropEvent, dedupeIntegration };\n//# sourceMappingURL=dedupe.js.map\n","import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP } from './semanticAttributes.js';\nimport './tracing/errors.js';\nimport { isInstanceOf } from './utils-hoist/is.js';\nimport './utils-hoist/version.js';\nimport './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport './utils-hoist/time.js';\nimport './utils-hoist/syncpromise.js';\nimport { parseUrl } from './utils-hoist/url.js';\nimport { SENTRY_BAGGAGE_KEY_PREFIX } from './utils-hoist/baggage.js';\nimport './debug-build.js';\nimport { hasTracingEnabled } from './utils/hasTracingEnabled.js';\nimport { getActiveSpan } from './utils/spanUtils.js';\nimport { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan.js';\nimport { setHttpStatus, SPAN_STATUS_ERROR } from './tracing/spanstatus.js';\nimport { startInactiveSpan } from './tracing/trace.js';\nimport { getTraceData } from './utils/traceData.js';\n\n/**\n * Create and track fetch request spans for usage in combination with `addFetchInstrumentationHandler`.\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction instrumentFetchRequest(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n  spanOrigin = 'auto.http.browser',\n) {\n  if (!handlerData.fetchData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(handlerData.fetchData.url);\n\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      endSpan(span, handlerData);\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const { method, url } = handlerData.fetchData;\n\n  const fullUrl = getFullURL(url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${method} ${url}`,\n          attributes: {\n            url,\n            type: 'fetch',\n            'http.method': method,\n            'http.url': fullUrl,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  handlerData.fetchData.__span = span.spanContext().spanId;\n  spans[span.spanContext().spanId] = span;\n\n  if (shouldAttachHeaders(handlerData.fetchData.url)) {\n    const request = handlerData.args[0];\n\n    const options = handlerData.args[1] || {};\n\n    const headers = _addTracingHeadersToFetchRequest(\n      request,\n      options,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasTracingEnabled() && hasParent ? span : undefined,\n    );\n    if (headers) {\n      // Ensure this is actually set, if no options have been passed previously\n      handlerData.args[1] = options;\n      options.headers = headers;\n    }\n  }\n\n  return span;\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers.\n */\nfunction _addTracingHeadersToFetchRequest(\n  request,\n  fetchOptionsObj\n\n,\n  span,\n) {\n  const traceHeaders = getTraceData({ span });\n  const sentryTrace = traceHeaders['sentry-trace'];\n  const baggage = traceHeaders.baggage;\n\n  // Nothing to do, when we return undefined here, the original headers will be used\n  if (!sentryTrace) {\n    return undefined;\n  }\n\n  const headers = fetchOptionsObj.headers || (isRequest(request) ? request.headers : undefined);\n\n  if (!headers) {\n    return { ...traceHeaders };\n  } else if (isHeaders(headers)) {\n    const newHeaders = new Headers(headers);\n    newHeaders.set('sentry-trace', sentryTrace);\n\n    if (baggage) {\n      const prevBaggageHeader = newHeaders.get('baggage');\n      if (prevBaggageHeader) {\n        const prevHeaderStrippedFromSentryBaggage = stripBaggageHeaderOfSentryBaggageValues(prevBaggageHeader);\n        newHeaders.set(\n          'baggage',\n          // If there are non-sentry entries (i.e. if the stripped string is non-empty/truthy) combine the stripped header and sentry baggage header\n          // otherwise just set the sentry baggage header\n          prevHeaderStrippedFromSentryBaggage ? `${prevHeaderStrippedFromSentryBaggage},${baggage}` : baggage,\n        );\n      } else {\n        newHeaders.set('baggage', baggage);\n      }\n    }\n\n    return newHeaders;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [\n      ...headers\n        // Remove any existing sentry-trace headers\n        .filter(header => {\n          return !(Array.isArray(header) && header[0] === 'sentry-trace');\n        })\n        // Get rid of previous sentry baggage values in baggage header\n        .map(header => {\n          if (Array.isArray(header) && header[0] === 'baggage' && typeof header[1] === 'string') {\n            const [headerName, headerValue, ...rest] = header;\n            return [headerName, stripBaggageHeaderOfSentryBaggageValues(headerValue), ...rest];\n          } else {\n            return header;\n          }\n        }),\n      // Attach the new sentry-trace header\n      ['sentry-trace', sentryTrace],\n    ];\n\n    if (baggage) {\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', baggage]);\n    }\n\n    return newHeaders ;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    let newBaggageHeaders = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders = existingBaggageHeader\n        .map(headerItem =>\n          typeof headerItem === 'string' ? stripBaggageHeaderOfSentryBaggageValues(headerItem) : headerItem,\n        )\n        .filter(headerItem => headerItem === '');\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(stripBaggageHeaderOfSentryBaggageValues(existingBaggageHeader));\n    }\n\n    if (baggage) {\n      newBaggageHeaders.push(baggage);\n    }\n\n    return {\n      ...(headers ),\n      'sentry-trace': sentryTrace,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers.\n *\n * @deprecated This function will not be exported anymore in v9.\n */\nfunction addTracingHeadersToFetchRequest(\n  request,\n  _client,\n  _scope,\n  fetchOptionsObj\n\n,\n  span,\n) {\n  return _addTracingHeadersToFetchRequest(request , fetchOptionsObj, span);\n}\n\nfunction getFullURL(url) {\n  try {\n    const parsed = new URL(url);\n    return parsed.href;\n  } catch (e) {\n    return undefined;\n  }\n}\n\nfunction endSpan(span, handlerData) {\n  if (handlerData.response) {\n    setHttpStatus(span, handlerData.response.status);\n\n    const contentLength =\n      handlerData.response && handlerData.response.headers && handlerData.response.headers.get('content-length');\n\n    if (contentLength) {\n      const contentLengthNum = parseInt(contentLength);\n      if (contentLengthNum > 0) {\n        span.setAttribute('http.response_content_length', contentLengthNum);\n      }\n    }\n  } else if (handlerData.error) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n  }\n  span.end();\n}\n\nfunction stripBaggageHeaderOfSentryBaggageValues(baggageHeader) {\n  return (\n    baggageHeader\n      .split(',')\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      .filter(baggageEntry => !baggageEntry.split('=')[0].startsWith(SENTRY_BAGGAGE_KEY_PREFIX))\n      .join(',')\n  );\n}\n\nfunction isRequest(request) {\n  return typeof Request !== 'undefined' && isInstanceOf(request, Request);\n}\n\nfunction isHeaders(headers) {\n  return typeof Headers !== 'undefined' && isInstanceOf(headers, Headers);\n}\n\nexport { addTracingHeadersToFetchRequest, instrumentFetchRequest };\n//# sourceMappingURL=fetch.js.map\n","/**\n * Determine a breadcrumb's log level (only `warning` or `error`) based on an HTTP status code.\n */\nfunction getBreadcrumbLogLevelFromHttpStatusCode(statusCode) {\n  // NOTE: undefined defaults to 'info' in Sentry\n  if (statusCode === undefined) {\n    return undefined;\n  } else if (statusCode >= 400 && statusCode < 500) {\n    return 'warning';\n  } else if (statusCode >= 500) {\n    return 'error';\n  } else {\n    return undefined;\n  }\n}\n\nexport { getBreadcrumbLogLevelFromHttpStatusCode };\n//# sourceMappingURL=breadcrumb-log-level.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { logger } from './logger.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-expect-error It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\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/**\n * isNative checks if the given function is a native implementation\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFunction(func) {\n  return func && /^function\\s+\\w+\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (typeof EdgeRuntime === 'string') {\n    return true;\n  }\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFunction(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFunction(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      DEBUG_BUILD &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\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\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\nexport { isNativeFunction, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { isError } from '../is.js';\nimport { fill, addNonEnumerableProperty } from '../object.js';\nimport { supportsNativeFetch } from '../supports.js';\nimport { timestampInSeconds } from '../time.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addFetchInstrumentationHandler(\n  handler,\n  skipNativeFetchCheck,\n) {\n  const type = 'fetch';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(undefined, skipNativeFetchCheck));\n}\n\n/**\n * Add an instrumentation handler for long-lived fetch requests, like consuming server-sent events (SSE) via fetch.\n * The handler will resolve the request body and emit the actual `endTimestamp`, so that the\n * span can be updated accordingly.\n *\n * Only used internally\n * @hidden\n */\nfunction addFetchEndInstrumentationHandler(handler) {\n  const type = 'fetch-body-resolved';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(streamHandler));\n}\n\nfunction instrumentFetch(onFetchResolved, skipNativeFetchCheck = false) {\n  if (skipNativeFetchCheck && !supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {\n    return function (...args) {\n      // We capture the error right here and not in the Promise error callback because Safari (and probably other\n      // browsers too) will wipe the stack trace up to this point, only leaving us with this file which is useless.\n\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your fetch call did not\n      //       have a stack trace, so the SDK backfilled the stack trace so\n      //       you can see which fetch call failed.\n      const virtualError = new Error();\n\n      const { method, url } = parseFetchArgs(args);\n      const handlerData = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: timestampInSeconds() * 1000,\n        // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation\n        virtualError,\n      };\n\n      // if there is no callback, fetch is instrumented directly\n      if (!onFetchResolved) {\n        triggerHandlers('fetch', {\n          ...handlerData,\n        });\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        async (response) => {\n          if (onFetchResolved) {\n            onFetchResolved(response);\n          } else {\n            triggerHandlers('fetch', {\n              ...handlerData,\n              endTimestamp: timestampInSeconds() * 1000,\n              response,\n            });\n          }\n\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: timestampInSeconds() * 1000,\n            error,\n          });\n\n          if (isError(error) && error.stack === undefined) {\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n            //       it means the error, that was caused by your fetch call did not\n            //       have a stack trace, so the SDK backfilled the stack trace so\n            //       you can see which fetch call failed.\n            error.stack = virtualError.stack;\n            addNonEnumerableProperty(error, 'framesToPop', 1);\n          }\n\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\nasync function resolveResponse(res, onFinishedResolving) {\n  if (res && res.body) {\n    const body = res.body;\n    const responseReader = body.getReader();\n\n    // Define a maximum duration after which we just cancel\n    const maxFetchDurationTimeout = setTimeout(\n      () => {\n        body.cancel().then(null, () => {\n          // noop\n        });\n      },\n      90 * 1000, // 90s\n    );\n\n    let readingActive = true;\n    while (readingActive) {\n      let chunkTimeout;\n      try {\n        // abort reading if read op takes more than 5s\n        chunkTimeout = setTimeout(() => {\n          body.cancel().then(null, () => {\n            // noop on error\n          });\n        }, 5000);\n\n        // This .read() call will reject/throw when we abort due to timeouts through `body.cancel()`\n        const { done } = await responseReader.read();\n\n        clearTimeout(chunkTimeout);\n\n        if (done) {\n          onFinishedResolving();\n          readingActive = false;\n        }\n      } catch (error) {\n        readingActive = false;\n      } finally {\n        clearTimeout(chunkTimeout);\n      }\n    }\n\n    clearTimeout(maxFetchDurationTimeout);\n\n    responseReader.releaseLock();\n    body.cancel().then(null, () => {\n      // noop on error\n    });\n  }\n}\n\nfunction streamHandler(response) {\n  // clone response for awaiting stream\n  let clonedResponseForResolving;\n  try {\n    clonedResponseForResolving = response.clone();\n  } catch (e) {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  resolveResponse(clonedResponseForResolving, () => {\n    triggerHandlers('fetch-body-resolved', {\n      endTimestamp: timestampInSeconds() * 1000,\n      response,\n    });\n  });\n}\n\nfunction hasProp(obj, prop) {\n  return !!obj && typeof obj === 'object' && !!(obj )[prop];\n}\n\nfunction getUrlFromResource(resource) {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nfunction parseFetchArgs(fetchArgs) {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs ;\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg ),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n\nexport { addFetchEndInstrumentationHandler, addFetchInstrumentationHandler, parseFetchArgs };\n//# sourceMappingURL=fetch.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\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\n/**\n * Get source of SDK.\n */\nfunction getSDKSource() {\n  // This comment is used to identify this line in the CDN bundle build step and replace this with \"return 'cdn';\"\n  /* __SENTRY_SDK_SOURCE__ */ return 'npm';\n}\n\nexport { getSDKSource, isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\n\n// Based on https://github.com/angular/angular.js/pull/13945/files\n// The MIT License\n\n\nconst WINDOW = GLOBAL_OBJ ;\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\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  // TODO(v9): Remove this custom check, it is pretty old and likely not needed anymore\n  const chromeVar = (WINDOW ).chrome;\n  const isChromePackagedApp = chromeVar && chromeVar.app && chromeVar.app.runtime;\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { supportsHistory };\n//# sourceMappingURL=supportsHistory.js.map\n","import { GLOBAL_OBJ, getOriginalFunction, markFunctionWrapped, addNonEnumerableProperty, withScope, addExceptionTypeValue, addExceptionMechanism, captureException } from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\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 */\nfunction wrap(\n  fn,\n  options\n\n = {},\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\n  function isFunction(fn) {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = (fn ).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function ( ...args) {\n    try {\n      // Also wrap arguments that are themselves functions\n      const wrappedArguments = args.map(arg => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope(scope => {\n        scope.addEventProcessor(event => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  } ;\n\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property ] = fn[property ];\n      }\n    }\n  } catch (e2) {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get() {\n          return fn.name;\n        },\n      });\n    }\n  } catch (e3) {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject, isEvent, isParameterizedString, getClient, normalizeToSize, extractExceptionKeysForMessage } from '@sentry/core';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception = {\n    type: extractType(ex),\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  const client = getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  // If we can, we extract an exception from the object properties\n  const errorFromProp = getErrorPropertyFromObject(exception);\n\n  const extra = {\n    __serialized__: normalizeToSize(exception, normalizeDepth),\n  };\n\n  if (errorFromProp) {\n    return {\n      exception: {\n        values: [exceptionFromError(stackParser, errorFromProp)],\n      },\n      extra,\n    };\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        } ,\n      ],\n    },\n    extra,\n  } ;\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception.values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser,\n  ex,\n) {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const skipLines = getSkipFirstStackStringLines(ex);\n  const framesToPop = getPopFirstTopFrames(ex);\n\n  try {\n    return stackParser(stacktrace, skipLines, framesToPop);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\n/**\n * Certain known React errors contain links that would be falsely\n * parsed as frames. This function check for these errors and\n * returns number of the stack string lines to skip.\n */\nfunction getSkipFirstStackStringLines(ex) {\n  if (ex && reactMinifiedRegexp.test(ex.message)) {\n    return 1;\n  }\n\n  return 0;\n}\n\n/**\n * If error has `framesToPop` property, it means that the\n * creator tells us the first x frames will be useless\n * and should be discarded. Typically error from wrapper function\n * which don't point to the actual location in the developer's code.\n *\n * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46\n */\nfunction getPopFirstTopFrames(ex) {\n  if (typeof ex.framesToPop === 'number') {\n    return ex.framesToPop;\n  }\n\n  return 0;\n}\n\n// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception\n// @ts-expect-error - WebAssembly.Exception is a valid class\nfunction isWebAssemblyException(exception) {\n  // Check for support\n  // @ts-expect-error - WebAssembly.Exception is a valid class\n  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {\n    // @ts-expect-error - WebAssembly.Exception is a valid class\n    return exception instanceof WebAssembly.Exception;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Extracts from errors what we use as the exception `type` in error events.\n *\n * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.\n */\nfunction extractType(ex) {\n  const name = ex && ex.name;\n\n  // The name for WebAssembly.Exception Errors needs to be extracted differently.\n  // Context: https://github.com/getsentry/sentry-javascript/issues/13787\n  if (!name && isWebAssemblyException(ex)) {\n    // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;\n    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';\n  }\n\n  return name;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n  const 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  // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n  if (isWebAssemblyException(ex) && Array.isArray(ex.message) && ex.message.length == 2) {\n    return ex.message[1];\n  }\n\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n  stackParser,\n  exception,\n  hint,\n  attachStacktrace,\n) {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n  level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception) || isDOMException(exception )) {\n    const domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\nfunction eventFromString(\n  stackParser,\n  message,\n  syntheticException,\n  attachStacktrace,\n) {\n  const event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n    addExceptionMechanism(event, { synthetic: true });\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception,\n  { isUnhandledRejection },\n) {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj) {\n  try {\n    const prototype = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch (e) {\n    // ignore errors here\n  }\n}\n\n/** If a plain object has a property that is an `Error`, return this error. */\nfunction getErrorPropertyFromObject(obj) {\n  for (const prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      const value = obj[prop];\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return undefined;\n}\n\nexport { eventFromException, eventFromMessage, eventFromUnknownInput, exceptionFromError, extractMessage, extractType };\n//# sourceMappingURL=eventbuilder.js.map\n","import { dsnToString, createEnvelope } from '@sentry/core';\n\n/**\n * Creates an envelope from a user feedback.\n */\nfunction createUserFeedbackEnvelope(\n  feedback,\n  {\n    metadata,\n    tunnel,\n    dsn,\n  }\n\n,\n) {\n  const headers = {\n    event_id: feedback.event_id,\n    sent_at: new Date().toISOString(),\n    ...(metadata &&\n      metadata.sdk && {\n        sdk: {\n          name: metadata.sdk.name,\n          version: metadata.sdk.version,\n        },\n      }),\n    ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),\n  };\n  const item = createUserFeedbackEnvelopeItem(feedback);\n\n  return createEnvelope(headers, [item]);\n}\n\nfunction createUserFeedbackEnvelopeItem(feedback) {\n  const feedbackHeaders = {\n    type: 'user_report',\n  };\n  return [feedbackHeaders, feedback];\n}\n\nexport { createUserFeedbackEnvelope };\n//# sourceMappingURL=userfeedback.js.map\n","import { BaseClient, getSDKSource, applySdkMetadata, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { createUserFeedbackEnvelope } from './userfeedback.js';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/core Options for more information.\n */\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n   constructor(options) {\n    const opts = {\n      // We default this to true, as it is the safer scenario\n      parentSpanIsAlwaysRootSpan: true,\n      ...options,\n    };\n    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n    applySdkMetadata(opts, 'browser', ['browser'], sdkSource);\n\n    super(opts);\n\n    if (opts.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromException(exception, hint) {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromMessage(\n    message,\n    level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * Sends user feedback to Sentry.\n   *\n   * @deprecated Use `captureFeedback` instead.\n   */\n   captureUserFeedback(feedback) {\n    if (!this._isEnabled()) {\n      DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');\n      return;\n    }\n\n    const envelope = createUserFeedbackEnvelope(feedback, {\n      metadata: this.getSdkMetadata(),\n      dsn: this.getDsn(),\n      tunnel: this.getOptions().tunnel,\n    });\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","const getRating = (value, thresholds) => {\n  if (value > thresholds[1]) {\n    return 'poor';\n  }\n  if (value > thresholds[0]) {\n    return 'needs-improvement';\n  }\n  return 'good';\n};\n\nconst bindReporter = (\n  callback,\n  metric,\n  thresholds,\n  reportAllChanges,\n) => {\n  let prevValue;\n  let delta;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          metric.rating = getRating(metric.value, thresholds);\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { GLOBAL_OBJ } from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ\n\n;\n\nexport { WINDOW };\n//# sourceMappingURL=types.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nconst generateUniqueID = () => {\n  return `v4-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// sentry-specific change:\n// add optional param to not check for responseStart (see comment below)\nconst getNavigationEntry = (checkResponseStart = true) => {\n  const navigationEntry =\n    WINDOW.performance && WINDOW.performance.getEntriesByType && WINDOW.performance.getEntriesByType('navigation')[0];\n  // Check to ensure the `responseStart` property is present and valid.\n  // In some cases no value is reported by the browser (for\n  // privacy/security reasons), and in other cases (bugs) the value is\n  // negative or is larger than the current page time. Ignore these cases:\n  // https://github.com/GoogleChrome/web-vitals/issues/137\n  // https://github.com/GoogleChrome/web-vitals/issues/162\n  // https://github.com/GoogleChrome/web-vitals/issues/275\n  if (\n    // sentry-specific change:\n    // We don't want to check for responseStart for our own use of `getNavigationEntry`\n    !checkResponseStart ||\n    (navigationEntry && navigationEntry.responseStart > 0 && navigationEntry.responseStart < performance.now())\n  ) {\n    return navigationEntry;\n  }\n};\n\nexport { getNavigationEntry };\n//# sourceMappingURL=getNavigationEntry.js.map\n","import { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst getActivationStart = () => {\n  const navEntry = getNavigationEntry();\n  return (navEntry && navEntry.activationStart) || 0;\n};\n\nexport { getActivationStart };\n//# sourceMappingURL=getActivationStart.js.map\n","import { WINDOW } from '../../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst initMetric = (name, value) => {\n  const navEntry = getNavigationEntry();\n  let navigationType = 'navigate';\n\n  if (navEntry) {\n    if ((WINDOW.document && WINDOW.document.prerendering) || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else if (WINDOW.document && WINDOW.document.wasDiscarded) {\n      navigationType = 'restore';\n    } else if (navEntry.type) {\n      navigationType = navEntry.type.replace(/_/g, '-') ;\n    }\n  }\n\n  // Use `entries` type specific for the metric.\n  const entries = [];\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good' , // If needed, will be updated when reported. `const` to keep the type from widening to `string`.\n    delta: 0,\n    entries,\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\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 * 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 */\nconst observe = (\n  type,\n  callback,\n  opts,\n) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        // Delay by a microtask to workaround a bug in Safari where the\n        // callback is invoked immediately, rather than in a separate task.\n        // See: https://github.com/GoogleChrome/web-vitals/issues/277\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        Promise.resolve().then(() => {\n          callback(list.getEntries() );\n        });\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) ,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// Sentry-specific change:\n// This function's logic was NOT updated to web-vitals 4.2.4 but we continue\n// to use the web-vitals 3.5.2 due to us having stricter browser support.\n// PR with context that made the changes: https://github.com/GoogleChrome/web-vitals/pull/442/files#r1530492402\n// The PR removed listening to the `pagehide` event, in favour of only listening to `visibilitychange` event.\n// This is \"more correct\" but some browsers we still support (Safari 12.1-14.0) don't fully support `visibilitychange`\n// or have known bugs w.r.t the `visibilitychange` event.\n// TODO (v9): If we decide to drop support for Safari 12.1-14.0, we can use the logic from web-vitals 4.2.4\n// In this case, we also need to update the integration tests that currently trigger the `pagehide` event to\n// simulate the page being hidden.\nconst onHidden = (cb) => {\n  const onHiddenOrPageHide = (event) => {\n    if (event.type === 'pagehide' || (WINDOW.document && WINDOW.document.visibilityState === 'hidden')) {\n      cb(event);\n    }\n  };\n\n  if (WINDOW.document) {\n    addEventListener('visibilitychange', onHiddenOrPageHide, true);\n    // Some browsers have buggy implementations of visibilitychange,\n    // so we use pagehide in addition, just to be safe.\n    addEventListener('pagehide', onHiddenOrPageHide, true);\n  }\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\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\nconst runOnce = (cb) => {\n  let called = false;\n  return () => {\n    if (!called) {\n      cb();\n      called = true;\n    }\n  };\n};\n\nexport { runOnce };\n//# sourceMappingURL=runOnce.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = () => {\n  // If the document is hidden when this code runs, assume it was always\n  // hidden and the page was loaded in the background, with the one exception\n  // that visibility state is always 'hidden' during prerendering, so we have\n  // to ignore that case until prerendering finishes (see: `prerenderingchange`\n  // event logic below).\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nconst onVisibilityUpdate = (event) => {\n  // If the document is 'hidden' and no previous hidden timestamp has been\n  // set, update it based on the current event data.\n  if (WINDOW.document.visibilityState === 'hidden' && firstHiddenTime > -1) {\n    // If the event is a 'visibilitychange' event, it means the page was\n    // visible prior to this change, so the event timestamp is the first\n    // hidden time.\n    // However, if the event is not a 'visibilitychange' event, then it must\n    // be a 'prerenderingchange' event, and the fact that the document is\n    // still 'hidden' from the above check means the tab was activated\n    // in a background state and so has always been hidden.\n    firstHiddenTime = event.type === 'visibilitychange' ? event.timeStamp : 0;\n\n    // Remove all listeners now that a `firstHiddenTime` value has been set.\n    removeChangeListeners();\n  }\n};\n\nconst addChangeListeners = () => {\n  addEventListener('visibilitychange', onVisibilityUpdate, true);\n  // IMPORTANT: when a page is prerendering, its `visibilityState` is\n  // 'hidden', so in order to account for cases where this module checks for\n  // visibility during prerendering, an additional check after prerendering\n  // completes is also required.\n  addEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst removeChangeListeners = () => {\n  removeEventListener('visibilitychange', onVisibilityUpdate, true);\n  removeEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst getVisibilityWatcher = () => {\n  if (WINDOW.document && 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    addChangeListeners();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst whenActivated = (callback) => {\n  if (WINDOW.document && WINDOW.document.prerendering) {\n    addEventListener('prerenderingchange', () => callback(), true);\n  } else {\n    callback();\n  }\n};\n\nexport { whenActivated };\n//# sourceMappingURL=whenActivated.js.map\n","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 { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */\nconst FCPThresholds = [1800, 3000];\n\n/**\n * Calculates the [FCP](https://web.dev/articles/fcp) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `paint` performance entry used to determine the value. The reported\n * value is a `DOMHighResTimeStamp`.\n */\nconst onFCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      entries.forEach(entry => {\n        if (entry.name === 'first-contentful-paint') {\n          po.disconnect();\n\n          // Only report if the page wasn't hidden prior to the first paint.\n          if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n            // The activationStart reference is used because FCP should be\n            // relative to page activation rather than navigation start if the\n            // page was prerendered. But in cases where `activationStart` occurs\n            // after the FCP, this time should be clamped at 0.\n            metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n            metric.entries.push(entry);\n            report(true);\n          }\n        }\n      });\n    };\n\n    const po = observe('paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);\n    }\n  });\n};\n\nexport { FCPThresholds, onFCP };\n//# sourceMappingURL=onFCP.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { onFCP } from './onFCP.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */\nconst CLSThresholds = [0.1, 0.25];\n\n/**\n * Calculates the [CLS](https://web.dev/articles/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/articles/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 */\nconst onCLS = (onReport, opts = {}) => {\n  // Start monitoring FCP so we can only report CLS if FCP is also reported.\n  // Note: this is done to match the current behavior of CrUX.\n  onFCP(\n    runOnce(() => {\n      const metric = initMetric('CLS', 0);\n      let report;\n\n      let sessionValue = 0;\n      let sessionEntries = [];\n\n      const handleEntries = (entries) => {\n        entries.forEach(entry => {\n          // Only count layout shifts without recent user input.\n          if (!entry.hadRecentInput) {\n            const firstSessionEntry = sessionEntries[0];\n            const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n            // If the entry occurred less than 1 second after the previous entry\n            // and less than 5 seconds after the first entry in the session,\n            // include the entry in the current session. Otherwise, start a new\n            // session.\n            if (\n              sessionValue &&\n              firstSessionEntry &&\n              lastSessionEntry &&\n              entry.startTime - lastSessionEntry.startTime < 1000 &&\n              entry.startTime - firstSessionEntry.startTime < 5000\n            ) {\n              sessionValue += entry.value;\n              sessionEntries.push(entry);\n            } else {\n              sessionValue = entry.value;\n              sessionEntries = [entry];\n            }\n          }\n        });\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          report();\n        }\n      };\n\n      const po = observe('layout-shift', handleEntries);\n      if (po) {\n        report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);\n\n        onHidden(() => {\n          handleEntries(po.takeRecords() );\n          report(true);\n        });\n\n        // Queue a task to report (if nothing else triggers a report first).\n        // This allows CLS to be reported as soon as FCP fires when\n        // `reportAllChanges` is true.\n        setTimeout(report, 0);\n      }\n    }),\n  );\n};\n\nexport { CLSThresholds, onCLS };\n//# sourceMappingURL=getCLS.js.map\n","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';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FID. See https://web.dev/articles/fid#what_is_a_good_fid_score */\nconst FIDThresholds = [100, 300];\n\n/**\n * Calculates the [FID](https://web.dev/articles/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 */\nconst onFID = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FID');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const 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    const handleEntries = (entries) => {\n      (entries ).forEach(handleEntry);\n    };\n\n    const po = observe('first-input', handleEntries);\n\n    report = bindReporter(onReport, metric, FIDThresholds, opts.reportAllChanges);\n\n    if (po) {\n      onHidden(\n        runOnce(() => {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n        }),\n      );\n    }\n  });\n};\n\nexport { FIDThresholds, onFID };\n//# sourceMappingURL=getFID.js.map\n","import { observe } from '../observe.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\n\nconst updateEstimate = (entries) => {\n  entries.forEach(e => {\n    if (e.interactionId) {\n      minKnownInteractionId = Math.min(minKnownInteractionId, e.interactionId);\n      maxKnownInteractionId = Math.max(maxKnownInteractionId, e.interactionId);\n\n      interactionCountEstimate = maxKnownInteractionId ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1 : 0;\n    }\n  });\n};\n\nlet po;\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nconst getInteractionCount = () => {\n  return po ? interactionCountEstimate : performance.interactionCount || 0;\n};\n\n/**\n * Feature detects native support or initializes the polyfill if needed.\n */\nconst initInteractionCountPolyfill = () => {\n  if ('interactionCount' in performance || po) return;\n\n  po = observe('event', updateEstimate, {\n    type: 'event',\n    buffered: true,\n    durationThreshold: 0,\n  } );\n};\n\nexport { getInteractionCount, initInteractionCountPolyfill };\n//# sourceMappingURL=interactionCountPolyfill.js.map\n","import { getInteractionCount } from './polyfills/interactionCountPolyfill.js';\n\n/*\n * Copyright 2024 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// A list of longest interactions on the page (by latency) sorted so the\n// longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER long.\nconst longestInteractionList = [];\n\n// A mapping of longest interactions by their interaction ID.\n// This is used for faster lookup.\nconst longestInteractionMap = new Map();\n\n// The default `durationThreshold` used across this library for observing\n// `event` entries via PerformanceObserver.\nconst DEFAULT_DURATION_THRESHOLD = 40;\n\n// Used to store the interaction count after a bfcache restore, since p98\n// interaction latencies should only consider the current navigation.\nlet prevInteractionCount = 0;\n\n/**\n * Returns the interaction count since the last bfcache restore (or for the\n * full page lifecycle if there were no bfcache restores).\n */\nconst getInteractionCountForNavigation = () => {\n  return getInteractionCount() - prevInteractionCount;\n};\n\n/**\n * Returns the estimated p98 longest interaction based on the stored\n * interaction candidates and the interaction count for the current page.\n */\nconst estimateP98LongestInteraction = () => {\n  const candidateInteractionIndex = Math.min(\n    longestInteractionList.length - 1,\n    Math.floor(getInteractionCountForNavigation() / 50),\n  );\n\n  return longestInteractionList[candidateInteractionIndex];\n};\n\n// To prevent unnecessary memory usage on pages with lots of interactions,\n// store at most 10 of the longest interactions to consider as INP candidates.\nconst MAX_INTERACTIONS_TO_CONSIDER = 10;\n\n/**\n * A list of callback functions to run before each entry is processed.\n * Exposing this list allows the attribution build to hook into the\n * entry processing pipeline.\n */\nconst entryPreProcessingCallbacks = [];\n\n/**\n * Takes a performance entry and adds it to the list of worst interactions\n * if its duration is long enough to make it among the worst. If the\n * entry is part of an existing interaction, it is merged and the latency\n * and entries list is updated as needed.\n */\nconst processInteractionEntry = (entry) => {\n  entryPreProcessingCallbacks.forEach(cb => cb(entry));\n\n  // Skip further processing for entries that cannot be INP candidates.\n  if (!(entry.interactionId || entry.entryType === 'first-input')) return;\n\n  // The least-long of the 10 longest interactions.\n  const minLongestInteraction = longestInteractionList[longestInteractionList.length - 1];\n\n  const existingInteraction = longestInteractionMap.get(entry.interactionId);\n\n  // Only process the entry if it's possibly one of the ten longest,\n  // or if it's part of an existing interaction.\n  if (\n    existingInteraction ||\n    longestInteractionList.length < MAX_INTERACTIONS_TO_CONSIDER ||\n    (minLongestInteraction && entry.duration > minLongestInteraction.latency)\n  ) {\n    // If the interaction already exists, update it. Otherwise create one.\n    if (existingInteraction) {\n      // If the new entry has a longer duration, replace the old entries,\n      // otherwise add to the array.\n      if (entry.duration > existingInteraction.latency) {\n        existingInteraction.entries = [entry];\n        existingInteraction.latency = entry.duration;\n      } else if (\n        entry.duration === existingInteraction.latency &&\n        entry.startTime === (existingInteraction.entries[0] && existingInteraction.entries[0].startTime)\n      ) {\n        existingInteraction.entries.push(entry);\n      }\n    } else {\n      const interaction = {\n        id: entry.interactionId,\n        latency: entry.duration,\n        entries: [entry],\n      };\n      longestInteractionMap.set(interaction.id, interaction);\n      longestInteractionList.push(interaction);\n    }\n\n    // Sort the entries by latency (descending) and keep only the top ten.\n    longestInteractionList.sort((a, b) => b.latency - a.latency);\n    if (longestInteractionList.length > MAX_INTERACTIONS_TO_CONSIDER) {\n      longestInteractionList.splice(MAX_INTERACTIONS_TO_CONSIDER).forEach(i => longestInteractionMap.delete(i.id));\n    }\n  }\n};\n\nexport { DEFAULT_DURATION_THRESHOLD, entryPreProcessingCallbacks, estimateP98LongestInteraction, longestInteractionList, longestInteractionMap, processInteractionEntry };\n//# sourceMappingURL=interactions.js.map\n","import { WINDOW } from '../../../types.js';\nimport { onHidden } from './onHidden.js';\nimport { runOnce } from './runOnce.js';\n\n/*\n * Copyright 2024 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/**\n * Runs the passed callback during the next idle period, or immediately\n * if the browser's visibility state is (or becomes) hidden.\n */\nconst whenIdle = (cb) => {\n  const rIC = WINDOW.requestIdleCallback || WINDOW.setTimeout;\n\n  let handle = -1;\n  // eslint-disable-next-line no-param-reassign\n  cb = runOnce(cb) ;\n  // If the document is hidden, run the callback immediately, otherwise\n  // race an idle callback with the next `visibilitychange` event.\n  if (WINDOW.document && WINDOW.document.visibilityState === 'hidden') {\n    cb();\n  } else {\n    handle = rIC(cb);\n    onHidden(cb);\n  }\n  return handle;\n};\n\nexport { whenIdle };\n//# sourceMappingURL=whenIdle.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { DEFAULT_DURATION_THRESHOLD, processInteractionEntry, estimateP98LongestInteraction } from './lib/interactions.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { initInteractionCountPolyfill } from './lib/polyfills/interactionCountPolyfill.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */\nconst INPThresholds = [200, 500];\n\n/**\n * Calculates the [INP](https://web.dev/articles/inp) value for the current\n * page and calls the `callback` function once the value is ready, along with\n * the `event` performance entries reported for that interaction. The reported\n * value is a `DOMHighResTimeStamp`.\n *\n * A custom `durationThreshold` configuration option can optionally be passed to\n * control what `event-timing` entries are considered for INP reporting. The\n * default threshold is `40`, which means INP scores of less than 40 are\n * reported as 0. Note that this will not affect your 75th percentile INP value\n * unless that value is also less than 40 (well below the recommended\n * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).\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:** INP 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 */\nconst onINP = (onReport, opts = {}) => {\n  // Return if the browser doesn't support all APIs needed to measure INP.\n  if (!('PerformanceEventTiming' in WINDOW && 'interactionId' in PerformanceEventTiming.prototype)) {\n    return;\n  }\n\n  whenActivated(() => {\n    // TODO(philipwalton): remove once the polyfill is no longer needed.\n    initInteractionCountPolyfill();\n\n    const metric = initMetric('INP');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const handleEntries = (entries) => {\n      // Queue the `handleEntries()` callback in the next idle task.\n      // This is needed to increase the chances that all event entries that\n      // occurred between the user interaction and the next paint\n      // have been dispatched. Note: there is currently an experiment\n      // running in Chrome (EventTimingKeypressAndCompositionInteractionId)\n      // 123+ that if rolled out fully may make this no longer necessary.\n      whenIdle(() => {\n        entries.forEach(processInteractionEntry);\n\n        const inp = estimateP98LongestInteraction();\n\n        if (inp && inp.latency !== metric.value) {\n          metric.value = inp.latency;\n          metric.entries = inp.entries;\n          report();\n        }\n      });\n    };\n\n    const po = observe('event', handleEntries, {\n      // Event Timing entries have their durations rounded to the nearest 8ms,\n      // so a duration of 40ms would be any event that spans 2.5 or more frames\n      // at 60Hz. This threshold is chosen to strike a balance between usefulness\n      // and performance. Running this callback for any interaction that spans\n      // just one or two frames is likely not worth the insight that could be\n      // gained.\n      durationThreshold: opts.durationThreshold != null ? opts.durationThreshold : DEFAULT_DURATION_THRESHOLD,\n    });\n\n    report = bindReporter(onReport, metric, INPThresholds, opts.reportAllChanges);\n\n    if (po) {\n      // Also observe entries of type `first-input`. This is useful in cases\n      // where the first interaction is less than the `durationThreshold`.\n      po.observe({ type: 'first-input', buffered: true });\n\n      onHidden(() => {\n        handleEntries(po.takeRecords() );\n        report(true);\n      });\n    }\n  });\n};\n\nexport { INPThresholds, onINP };\n//# sourceMappingURL=getINP.js.map\n","import { WINDOW } from '../../types.js';\nimport { 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';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */\nconst LCPThresholds = [2500, 4000];\n\nconst reportedMetricIDs = {};\n\n/**\n * Calculates the [LCP](https://web.dev/articles/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 */\nconst onLCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('LCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      // If reportAllChanges is set then call this function for each entry,\n      // otherwise only consider the last one.\n      if (!opts.reportAllChanges) {\n        // eslint-disable-next-line no-param-reassign\n        entries = entries.slice(-1);\n      }\n\n      entries.forEach(entry => {\n        // Only report if the page wasn't hidden prior to LCP.\n        if (entry.startTime < visibilityWatcher.firstHiddenTime) {\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 pre-rendered. But in cases\n          // where `activationStart` occurs after the LCP, this time should be\n          // clamped at 0.\n          metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n          metric.entries = [entry];\n          report();\n        }\n      });\n    };\n\n    const po = observe('largest-contentful-paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);\n\n      const stopListening = runOnce(() => {\n        if (!reportedMetricIDs[metric.id]) {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n          reportedMetricIDs[metric.id] = true;\n          report(true);\n        }\n      });\n\n      // Stop listening after input. Note: while scrolling is an input that\n      // stops LCP observation, it's unreliable since it can be programmatically\n      // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n      ['keydown', 'click'].forEach(type => {\n        // Wrap in a setTimeout so the callback is run in a separate task\n        // to avoid extending the keyboard/click handler to reduce INP impact\n        // https://github.com/GoogleChrome/web-vitals/issues/383\n        if (WINDOW.document) {\n          addEventListener(type, () => whenIdle(stopListening ), {\n            once: true,\n            capture: true,\n          });\n        }\n      });\n\n      onHidden(stopListening);\n    }\n  });\n};\n\nexport { LCPThresholds, onLCP };\n//# sourceMappingURL=getLCP.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getNavigationEntry } from './lib/getNavigationEntry.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */\nconst TTFBThresholds = [800, 1800];\n\n/**\n * Runs in the next task after the page is done loading and/or prerendering.\n * @param callback\n */\nconst whenReady = (callback) => {\n  if (WINDOW.document && WINDOW.document.prerendering) {\n    whenActivated(() => whenReady(callback));\n  } else if (WINDOW.document && WINDOW.document.readyState !== 'complete') {\n    addEventListener('load', () => whenReady(callback), true);\n  } else {\n    // Queue a task so the callback runs after `loadEventEnd`.\n    setTimeout(callback, 0);\n  }\n};\n\n/**\n * Calculates the [TTFB](https://web.dev/articles/ttfb) value for the\n * current page and calls the `callback` function once the page has loaded,\n * along with the relevant `navigation` performance entry used to determine the\n * value. The reported value is a `DOMHighResTimeStamp`.\n *\n * Note, this function waits until after the page is loaded to call `callback`\n * in order to ensure all properties of the `navigation` entry are populated.\n * This is useful if you want to report on other metrics exposed by the\n * [Navigation Timing API](https://w3c.github.io/navigation-timing/). For\n * example, the TTFB metric starts from the page's [time\n * origin](https://www.w3.org/TR/hr-time-2/#sec-time-origin), which means it\n * includes time spent on DNS lookup, connection negotiation, network latency,\n * and server processing time.\n */\nconst onTTFB = (onReport, opts = {}) => {\n  const metric = initMetric('TTFB');\n  const report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);\n\n  whenReady(() => {\n    const navigationEntry = getNavigationEntry();\n\n    if (navigationEntry) {\n      // The activationStart reference is used because TTFB should be\n      // relative to page activation rather than navigation start if the\n      // page was prerendered. But in cases where `activationStart` occurs\n      // after the first byte is received, this time should be clamped at 0.\n      metric.value = Math.max(navigationEntry.responseStart - getActivationStart(), 0);\n\n      metric.entries = [navigationEntry];\n      report(true);\n    }\n  });\n};\n\nexport { TTFBThresholds, onTTFB };\n//# sourceMappingURL=onTTFB.js.map\n","import { logger, getFunctionName } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { onCLS } from './web-vitals/getCLS.js';\nimport { onFID } from './web-vitals/getFID.js';\nimport { onINP } from './web-vitals/getINP.js';\nimport { onLCP } from './web-vitals/getLCP.js';\nimport { observe } from './web-vitals/lib/observe.js';\nimport { onTTFB } from './web-vitals/onTTFB.js';\n\nconst handlers = {};\nconst instrumented = {};\n\nlet _previousCls;\nlet _previousFid;\nlet _previousLcp;\nlet _previousTtfb;\nlet _previousInp;\n\n/**\n * Add a callback that will be triggered when a CLS metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for CLS when the cleanup callback is called.\n * This will lead to the CLS being finalized and frozen.\n */\nfunction addClsInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('cls', callback, instrumentCls, _previousCls, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a LCP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for LCP when the cleanup callback is called.\n * This will lead to the LCP being finalized and frozen.\n */\nfunction addLcpInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('lcp', callback, instrumentLcp, _previousLcp, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addFidInstrumentationHandler(callback) {\n  return addMetricObserver('fid', callback, instrumentFid, _previousFid);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n */\nfunction addTtfbInstrumentationHandler(callback) {\n  return addMetricObserver('ttfb', callback, instrumentTtfb, _previousTtfb);\n}\n\n/**\n * Add a callback that will be triggered when a INP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addInpInstrumentationHandler(\n  callback,\n) {\n  return addMetricObserver('inp', callback, instrumentInp, _previousInp);\n}\n\n/**\n * Add a callback that will be triggered when a performance observer is triggered,\n * and receives the entries of the observer.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addPerformanceInstrumentationHandler(\n  type,\n  callback,\n) {\n  addHandler(type, callback);\n\n  if (!instrumented[type]) {\n    instrumentPerformanceObserver(type);\n    instrumented[type] = true;\n  }\n\n  return getCleanupCallback(type, callback);\n}\n\n/** Trigger all handlers of a given type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = handlers[type];\n\n  if (!typeHandlers || !typeHandlers.length) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\nfunction instrumentCls() {\n  return onCLS(\n    metric => {\n      triggerHandlers('cls', {\n        metric,\n      });\n      _previousCls = metric;\n    },\n    // We want the callback to be called whenever the CLS value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentFid() {\n  return onFID(metric => {\n    triggerHandlers('fid', {\n      metric,\n    });\n    _previousFid = metric;\n  });\n}\n\nfunction instrumentLcp() {\n  return onLCP(\n    metric => {\n      triggerHandlers('lcp', {\n        metric,\n      });\n      _previousLcp = metric;\n    },\n    // We want the callback to be called whenever the LCP value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentTtfb() {\n  return onTTFB(metric => {\n    triggerHandlers('ttfb', {\n      metric,\n    });\n    _previousTtfb = metric;\n  });\n}\n\nfunction instrumentInp() {\n  return onINP(metric => {\n    triggerHandlers('inp', {\n      metric,\n    });\n    _previousInp = metric;\n  });\n}\n\nfunction addMetricObserver(\n  type,\n  callback,\n  instrumentFn,\n  previousValue,\n  stopOnCallback = false,\n) {\n  addHandler(type, callback);\n\n  let stopListening;\n\n  if (!instrumented[type]) {\n    stopListening = instrumentFn();\n    instrumented[type] = true;\n  }\n\n  if (previousValue) {\n    callback({ metric: previousValue });\n  }\n\n  return getCleanupCallback(type, callback, stopOnCallback ? stopListening : undefined);\n}\n\nfunction instrumentPerformanceObserver(type) {\n  const options = {};\n\n  // Special per-type options we want to use\n  if (type === 'event') {\n    options.durationThreshold = 0;\n  }\n\n  observe(\n    type,\n    entries => {\n      triggerHandlers(type, { entries });\n    },\n    options,\n  );\n}\n\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n// Get a callback which can be called to remove the instrumentation handler\nfunction getCleanupCallback(\n  type,\n  callback,\n  stopListening,\n) {\n  return () => {\n    if (stopListening) {\n      stopListening();\n    }\n\n    const typeHandlers = handlers[type];\n\n    if (!typeHandlers) {\n      return;\n    }\n\n    const index = typeHandlers.indexOf(callback);\n    if (index !== -1) {\n      typeHandlers.splice(index, 1);\n    }\n  };\n}\n\n/**\n * Check if a PerformanceEntry is a PerformanceEventTiming by checking for the `duration` property.\n */\nfunction isPerformanceEventTiming(entry) {\n  return 'duration' in entry;\n}\n\nexport { addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, addLcpInstrumentationHandler, addPerformanceInstrumentationHandler, addTtfbInstrumentationHandler, isPerformanceEventTiming };\n//# sourceMappingURL=instrument.js.map\n","import { spanToJSON, withActiveSpan, startInactiveSpan, getClient, getCurrentScope } from '@sentry/core';\nimport { WINDOW } from '../types.js';\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/**\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 */\nfunction startAndEndSpan(\n  parentSpan,\n  startTimeInSeconds,\n  endTime,\n  { ...ctx },\n) {\n  const parentStartTime = spanToJSON(parentSpan).start_timestamp;\n  if (parentStartTime && parentStartTime > startTimeInSeconds) {\n    // We can only do this for SentrySpans...\n    if (typeof (parentSpan ).updateStartTime === 'function') {\n      (parentSpan ).updateStartTime(startTimeInSeconds);\n    }\n  }\n\n  // The return value only exists for tests\n  return withActiveSpan(parentSpan, () => {\n    const span = startInactiveSpan({\n      startTime: startTimeInSeconds,\n      ...ctx,\n    });\n\n    if (span) {\n      span.end(endTime);\n    }\n\n    return span;\n  });\n}\n\n/**\n * Starts an inactive, standalone span used to send web vital values to Sentry.\n * DO NOT use this for arbitrary spans, as these spans require special handling\n * during ingestion to extract metrics.\n *\n * This function adds a bunch of attributes and data to the span that's shared\n * by all web vital standalone spans. However, you need to take care of adding\n * the actual web vital value as an event to the span. Also, you need to assign\n * a transaction name and some other values that are specific to the web vital.\n *\n * Ultimately, you also need to take care of ending the span to send it off.\n *\n * @param options\n *\n * @returns an inactive, standalone and NOT YET ended span\n */\nfunction startStandaloneWebVitalSpan(options) {\n  const client = getClient();\n  if (!client) {\n    return;\n  }\n\n  const { name, transaction, attributes: passedAttributes, startTime } = options;\n\n  const { release, environment } = client.getOptions();\n  // We need to get the replay, user, and activeTransaction from the current scope\n  // so that we can associate replay id, profile id, and a user display to the span\n  const replay = client.getIntegrationByName('Replay');\n  const replayId = replay && replay.getReplayId();\n\n  const scope = getCurrentScope();\n\n  const user = scope.getUser();\n  const userDisplay = user !== undefined ? user.email || user.id || user.ip_address : undefined;\n\n  let profileId;\n  try {\n    // @ts-expect-error skip optional chaining to save bundle size with try catch\n    profileId = scope.getScopeData().contexts.profile.profile_id;\n  } catch (e) {\n    // do nothing\n  }\n\n  const attributes = {\n    release,\n    environment,\n\n    user: userDisplay || undefined,\n    profile_id: profileId || undefined,\n    replay_id: replayId || undefined,\n\n    transaction,\n\n    // Web vital score calculation relies on the user agent to account for different\n    // browsers setting different thresholds for what is considered a good/meh/bad value.\n    // For example: Chrome vs. Chrome Mobile\n    'user_agent.original': WINDOW.navigator && WINDOW.navigator.userAgent,\n\n    ...passedAttributes,\n  };\n\n  return startInactiveSpan({\n    name,\n    attributes,\n    startTime,\n    experimental: {\n      standalone: true,\n    },\n  });\n}\n\n/** Get the browser performance API. */\nfunction getBrowserPerformanceAPI() {\n  // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n  return time / 1000;\n}\n\nexport { getBrowserPerformanceAPI, isMeasurementValue, msToSec, startAndEndSpan, startStandaloneWebVitalSpan };\n//# sourceMappingURL=utils.js.map\n","import { getClient, getActiveSpan, getRootSpan, spanToJSON, logger, browserPerformanceTimeOrigin, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { addClsInstrumentationHandler } from './instrument.js';\nimport { msToSec, startStandaloneWebVitalSpan } from './utils.js';\nimport { onHidden } from './web-vitals/lib/onHidden.js';\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value once\n *\n * - the page visibility is hidden\n * - a navigation span is started (to stop CLS measurement for SPA soft navigations)\n *\n * Once either of these events triggers, the CLS value is sent as a standalone span and we stop\n * measuring CLS.\n */\nfunction trackClsAsStandaloneSpan() {\n  let standaloneCLsValue = 0;\n  let standaloneClsEntry;\n  let pageloadSpanId;\n\n  if (!supportsLayoutShift()) {\n    return;\n  }\n\n  let sentSpan = false;\n  function _collectClsOnce() {\n    if (sentSpan) {\n      return;\n    }\n    sentSpan = true;\n    if (pageloadSpanId) {\n      sendStandaloneClsSpan(standaloneCLsValue, standaloneClsEntry, pageloadSpanId);\n    }\n    cleanupClsHandler();\n  }\n\n  const cleanupClsHandler = addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    standaloneCLsValue = metric.value;\n    standaloneClsEntry = entry;\n  }, true);\n\n  // use pagehide event from web-vitals\n  onHidden(() => {\n    _collectClsOnce();\n  });\n\n  // Since the call chain of this function is synchronous and evaluates before the SDK client is created,\n  // we need to wait with subscribing to a client hook until the client is created. Therefore, we defer\n  // to the next tick after the SDK setup.\n  setTimeout(() => {\n    const client = getClient();\n\n    if (!client) {\n      return;\n    }\n\n    const unsubscribeStartNavigation = client.on('startNavigationSpan', () => {\n      _collectClsOnce();\n      unsubscribeStartNavigation && unsubscribeStartNavigation();\n    });\n\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan && getRootSpan(activeSpan);\n    const spanJSON = rootSpan && spanToJSON(rootSpan);\n    if (spanJSON && spanJSON.op === 'pageload') {\n      pageloadSpanId = rootSpan.spanContext().spanId;\n    }\n  }, 0);\n}\n\nfunction sendStandaloneClsSpan(clsValue, entry, pageloadSpanId) {\n  DEBUG_BUILD && logger.log(`Sending CLS span (${clsValue})`);\n\n  const startTime = msToSec((browserPerformanceTimeOrigin || 0) + ((entry && entry.startTime) || 0));\n  const routeName = getCurrentScope().getScopeData().transactionName;\n\n  const name = entry ? htmlTreeAsString(entry.sources[0] && entry.sources[0].node) : 'Layout shift';\n\n  const attributes = dropUndefinedKeys({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.cls',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'ui.webvital.cls',\n    [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: (entry && entry.duration) || 0,\n    // attach the pageload span id to the CLS span so that we can link them in the UI\n    'sentry.pageload.span_id': pageloadSpanId,\n  });\n\n  const span = startStandaloneWebVitalSpan({\n    name,\n    transaction: routeName,\n    attributes,\n    startTime,\n  });\n\n  if (span) {\n    span.addEvent('cls', {\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: '',\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: clsValue,\n    });\n\n    // LayoutShift performance entries always have a duration of 0, so we don't need to add `entry.duration` here\n    // see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/duration\n    span.end(startTime);\n  }\n}\n\nfunction supportsLayoutShift() {\n  try {\n    return PerformanceObserver.supportedEntryTypes.includes('layout-shift');\n  } catch (e) {\n    return false;\n  }\n}\n\nexport { trackClsAsStandaloneSpan };\n//# sourceMappingURL=cls.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, spanToJSON, setMeasurement, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, parseUrl, htmlTreeAsString, getComponentName } from '@sentry/core';\nimport { WINDOW } from '../types.js';\nimport { trackClsAsStandaloneSpan } from './cls.js';\nimport { addPerformanceInstrumentationHandler, addClsInstrumentationHandler, addLcpInstrumentationHandler, addFidInstrumentationHandler, addTtfbInstrumentationHandler } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startAndEndSpan, isMeasurementValue } from './utils.js';\nimport { getActivationStart } from './web-vitals/lib/getActivationStart.js';\nimport { getNavigationEntry } from './web-vitals/lib/getNavigationEntry.js';\nimport { getVisibilityWatcher } from './web-vitals/lib/getVisibilityWatcher.js';\n\nconst MAX_INT_AS_BYTES = 2147483647;\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals.\n * The callback returned by this function can be used to stop tracking & ensure all measurements are final & captured.\n *\n * @returns A function that forces web vitals collection\n */\nfunction startTrackingWebVitals({ recordClsStandaloneSpans }) {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n    const fidCleanupCallback = _trackFID();\n    const lcpCleanupCallback = _trackLCP();\n    const ttfbCleanupCallback = _trackTtfb();\n    const clsCleanupCallback = recordClsStandaloneSpans ? trackClsAsStandaloneSpan() : _trackCLS();\n\n    return () => {\n      fidCleanupCallback();\n      lcpCleanupCallback();\n      ttfbCleanupCallback();\n      clsCleanupCallback && clsCleanupCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\n/**\n * Start tracking long tasks.\n */\nfunction startTrackingLongTasks() {\n  addPerformanceInstrumentationHandler('longtask', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n\n    const { op: parentOp, start_timestamp: parentStartTimestamp } = spanToJSON(parent);\n\n    for (const entry of entries) {\n      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding a span if the long task started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n    }\n  });\n}\n\n/**\n * Start tracking long animation frames.\n */\nfunction startTrackingLongAnimationFrames() {\n  // NOTE: the current web-vitals version (3.5.2) does not support long-animation-frame, so\n  // we directly observe `long-animation-frame` events instead of through the web-vitals\n  // `observe` helper function.\n  const observer = new PerformanceObserver(list => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of list.getEntries() ) {\n      if (!entry.scripts[0]) {\n        continue;\n      }\n\n      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n\n      const { start_timestamp: parentStartTimestamp, op: parentOp } = spanToJSON(parent);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding the span if the long animation frame started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n\n      const duration = msToSec(entry.duration);\n\n      const attributes = {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      };\n\n      const initialScript = entry.scripts[0];\n      const { invoker, invokerType, sourceURL, sourceFunctionName, sourceCharPosition } = initialScript;\n      attributes['browser.script.invoker'] = invoker;\n      attributes['browser.script.invoker_type'] = invokerType;\n      if (sourceURL) {\n        attributes['code.filepath'] = sourceURL;\n      }\n      if (sourceFunctionName) {\n        attributes['code.function'] = sourceFunctionName;\n      }\n      if (sourceCharPosition !== -1) {\n        attributes['browser.script.source_char_position'] = sourceCharPosition;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-animation-frame',\n        attributes,\n      });\n    }\n  });\n\n  observer.observe({ type: 'long-animation-frame', buffered: true });\n}\n\n/**\n * Start tracking interaction events.\n */\nfunction startTrackingInteractions() {\n  addPerformanceInstrumentationHandler('event', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.name === 'click') {\n        const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n        const duration = msToSec(entry.duration);\n\n        const spanOptions = {\n          name: htmlTreeAsString(entry.target),\n          op: `ui.interaction.${entry.name}`,\n          startTime: startTime,\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n          },\n        };\n\n        const componentName = getComponentName(entry.target);\n        if (componentName) {\n          spanOptions.attributes['ui.component_name'] = componentName;\n        }\n\n        startAndEndSpan(parent, startTime, startTime + duration, spanOptions);\n      }\n    }\n  });\n}\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value and last entry\n * to the `_measurements` object which ultimately is applied to the pageload span's measurements.\n */\nfunction _trackCLS() {\n  return addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry;\n  }, true);\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP() {\n  return addLcpInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n    _lcpEntry = entry ;\n  }, true);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  return addFidInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin );\n    const startTime = msToSec(entry.startTime);\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\nfunction _trackTtfb() {\n  return addTtfbInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['ttfb'] = { value: metric.value, unit: 'millisecond' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(span, options) {\n  const performance = getBrowserPerformanceAPI();\n  if (!performance || !performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  const performanceEntries = performance.getEntries();\n\n  const { op, start_timestamp: transactionStartTime } = spanToJSON(span);\n\n  performanceEntries.slice(_performanceCursor).forEach(entry => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(\n      // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.\n      // There is a SO post attempting to explain this, but it leaves one with open questions: https://stackoverflow.com/questions/23191918/peformance-getentries-and-negative-duration-display\n      // The way we clamp the value is probably not accurate, since we have observed this happen for things that may take a while to load, like for example the replay worker.\n      // TODO: Investigate why this happens and how to properly mitigate. For now, this is a workaround to prevent transactions being dropped due to negative duration spans.\n      Math.max(0, entry.duration),\n    );\n\n    if (op === 'navigation' && transactionStartTime && timeOrigin + startTime < transactionStartTime) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(span, entry , timeOrigin);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(span, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        _addResourceSpans(span, entry , entry.name, startTime, duration, timeOrigin);\n        break;\n      }\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(span);\n\n  // Measurements are only available for pageload transactions\n  if (op === 'pageload') {\n    _addTtfbRequestTimeToMeasurements(_measurements);\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      startAndEndSpan(span, fidMark.value, fidMark.value + msToSec(_measurements['fid'].value), {\n        name: 'first input delay',\n        op: 'ui.action',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    // TODO: Check if the first condition is still necessary: `onCLS` already only fires once `onFCP` was called.\n    if (!('fcp' in _measurements) || !options.recordClsOnPageloadSpan) {\n      delete _measurements.cls;\n    }\n\n    Object.entries(_measurements).forEach(([measurementName, measurement]) => {\n      setMeasurement(measurementName, measurement.value, measurement.unit);\n    });\n\n    // Set timeOrigin which denotes the timestamp which to base the LCP/FCP/FP/TTFB measurements on\n    span.setAttribute('performance.timeOrigin', timeOrigin);\n\n    // In prerendering scenarios, where a page might be prefetched and pre-rendered before the user clicks the link,\n    // the navigation starts earlier than when the user clicks it. Web Vitals should always be based on the\n    // user-perceived time, so they are not reported from the actual start of the navigation, but rather from the\n    // time where the user actively started the navigation, for example by clicking a link.\n    // This is user action is called \"activation\" and the time between navigation and activation is stored in\n    // the `activationStart` attribute of the \"navigation\" PerformanceEntry.\n    span.setAttribute('performance.activationStart', getActivationStart());\n\n    _setWebVitalAttributes(span);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/**\n * Create measure related spans.\n * Exported only for tests.\n */\nfunction _addMeasureSpans(\n  span,\n  entry,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  const navEntry = getNavigationEntry(false);\n  const requestTime = msToSec(navEntry ? navEntry.requestStart : 0);\n  // Because performance.measure accepts arbitrary timestamps it can produce\n  // spans that happen before the browser even makes a request for the page.\n  //\n  // An example of this is the automatically generated Next.js-before-hydration\n  // spans created by the Next.js framework.\n  //\n  // To prevent this we will pin the start timestamp to the request start time\n  // This does make duration inaccurate, so if this does happen, we will add\n  // an attribute to the span\n  const measureStartTimestamp = timeOrigin + Math.max(startTime, requestTime);\n  const startTimeStamp = timeOrigin + startTime;\n  const measureEndTimestamp = startTimeStamp + duration;\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n\n  if (measureStartTimestamp !== startTimeStamp) {\n    attributes['sentry.browser.measure_happened_before_request'] = true;\n    attributes['sentry.browser.measure_start_time'] = measureStartTimestamp;\n  }\n\n  startAndEndSpan(span, measureStartTimestamp, measureEndTimestamp, {\n    name: entry.name ,\n    op: entry.entryType ,\n    attributes,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\nfunction _addNavigationSpans(span, entry, timeOrigin) {\n  (['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'] ).forEach(event => {\n    _addPerformanceNavigationTiming(span, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(span, entry, 'secureConnection', timeOrigin, 'TLS/SSL');\n  _addPerformanceNavigationTiming(span, entry, 'fetch', timeOrigin, 'cache');\n  _addPerformanceNavigationTiming(span, entry, 'domainLookup', timeOrigin, 'DNS');\n\n  _addRequest(span, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  span,\n  entry,\n  event,\n  timeOrigin,\n  name = event,\n) {\n  const eventEnd = _getEndPropertyNameForNavigationTiming(event) ;\n  const end = entry[eventEnd];\n  const start = entry[`${event}Start`];\n  if (!start || !end) {\n    return;\n  }\n  startAndEndSpan(span, timeOrigin + msToSec(start), timeOrigin + msToSec(end), {\n    op: `browser.${name}`,\n    name: entry.name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n    },\n  });\n}\n\nfunction _getEndPropertyNameForNavigationTiming(event) {\n  if (event === 'secureConnection') {\n    return 'connectEnd';\n  }\n  if (event === 'fetch') {\n    return 'domainLookupStart';\n  }\n  return `${event}End`;\n}\n\n/** Create request and response related spans */\nfunction _addRequest(span, entry, timeOrigin) {\n  const requestStartTimestamp = timeOrigin + msToSec(entry.requestStart );\n  const responseEndTimestamp = timeOrigin + msToSec(entry.responseEnd );\n  const responseStartTimestamp = timeOrigin + msToSec(entry.responseStart );\n  if (entry.responseEnd) {\n    // It is possible that we are collecting these metrics when the page hasn't finished loading yet, for example when the HTML slowly streams in.\n    // In this case, ie. when the document request hasn't finished yet, `entry.responseEnd` will be 0.\n    // In order not to produce faulty spans, where the end timestamp is before the start timestamp, we will only collect\n    // these spans when the responseEnd value is available. The backend (Relay) would drop the entire span if it contained faulty spans.\n    startAndEndSpan(span, requestStartTimestamp, responseEndTimestamp, {\n      op: 'browser.request',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n\n    startAndEndSpan(span, responseStartTimestamp, responseEndTimestamp, {\n      op: 'browser.response',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n  }\n}\n\n/**\n * Create resource-related spans.\n * Exported only for tests.\n */\nfunction _addResourceSpans(\n  span,\n  entry,\n  resourceUrl,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  const parsedUrl = parseUrl(resourceUrl);\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n  setResourceEntrySizeData(attributes, entry, 'transferSize', 'http.response_transfer_size');\n  setResourceEntrySizeData(attributes, entry, 'encodedBodySize', 'http.response_content_length');\n  setResourceEntrySizeData(attributes, entry, 'decodedBodySize', 'http.decoded_response_content_length');\n\n  // `deliveryType` is experimental and does not exist everywhere\n  const deliveryType = (entry ).deliveryType;\n  if (deliveryType != null) {\n    attributes['http.response_delivery_type'] = deliveryType;\n  }\n\n  // Types do not reflect this property yet\n  const renderBlockingStatus = (entry )\n    .renderBlockingStatus;\n  if (renderBlockingStatus) {\n    attributes['resource.render_blocking_status'] = renderBlockingStatus;\n  }\n\n  if (parsedUrl.protocol) {\n    attributes['url.scheme'] = parsedUrl.protocol.split(':').pop(); // the protocol returned by parseUrl includes a :, but OTEL spec does not, so we remove it.\n  }\n\n  if (parsedUrl.host) {\n    attributes['server.address'] = parsedUrl.host;\n  }\n\n  attributes['url.same_origin'] = resourceUrl.includes(WINDOW.location.origin);\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  startAndEndSpan(span, startTimestamp, endTimestamp, {\n    name: resourceUrl.replace(WINDOW.location.origin, ''),\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    attributes,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(span) {\n  const navigator = WINDOW.navigator ;\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      span.setAttribute('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      span.setAttribute('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    span.setAttribute('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    span.setAttribute('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to span to allow debugging */\nfunction _setWebVitalAttributes(span) {\n  if (_lcpEntry) {\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      span.setAttribute('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      span.setAttribute('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      span.setAttribute('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    if (_lcpEntry.loadTime != null) {\n      // loadTime is the time of LCP that's related to receiving the LCP element response..\n      span.setAttribute('lcp.loadTime', _lcpEntry.loadTime);\n    }\n\n    if (_lcpEntry.renderTime != null) {\n      // renderTime is loadTime + rendering time\n      // it's 0 if the LCP element is loaded from a 3rd party origin that doesn't send the\n      // `Timing-Allow-Origin` header.\n      span.setAttribute('lcp.renderTime', _lcpEntry.renderTime);\n    }\n\n    span.setAttribute('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    _clsEntry.sources.forEach((source, index) =>\n      span.setAttribute(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nfunction setResourceEntrySizeData(\n  attributes,\n  entry,\n  key,\n  dataKey,\n) {\n  const entryVal = entry[key];\n  if (entryVal != null && entryVal < MAX_INT_AS_BYTES) {\n    attributes[dataKey] = entryVal;\n  }\n}\n\n/**\n * Add ttfb request time information to measurements.\n *\n * ttfb information is added via vendored web vitals library.\n */\nfunction _addTtfbRequestTimeToMeasurements(_measurements) {\n  const navEntry = getNavigationEntry(false);\n  if (!navEntry) {\n    return;\n  }\n\n  const { responseStart, requestStart } = navEntry;\n\n  if (requestStart <= responseStart) {\n    _measurements['ttfb.requestTime'] = {\n      value: responseStart - requestStart,\n      unit: 'millisecond',\n    };\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingInteractions, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingWebVitals };\n//# sourceMappingURL=browserMetrics.js.map\n","import { addHandler, maybeInstrument, triggerHandlers, fill, addNonEnumerableProperty, uuid4 } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID;\nlet lastCapturedEventType;\nlet lastCapturedEventTargetId;\n\n/**\n * Add an instrumentation handler for when a click or a keypress happens.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addClickKeypressInstrumentationHandler(handler) {\n  const type = 'dom';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nfunction instrumentDOM() {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n    const globalObject = WINDOW ;\n    const targetObj = globalObject[target];\n    const proto = targetObj && targetObj.prototype;\n\n    // eslint-disable-next-line no-prototype-builtins\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            const handlers = (this.__sentry_instrumentation_handlers__ =\n              this.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListeners` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function ( type, listener, options) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const handlers = this.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount--;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete this.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListeners` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\nfunction isSimilarToLastCapturedEvent(event) {\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (event.type !== lastCapturedEventType) {\n    return false;\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 (!event.target || (event.target )._sentryId !== lastCapturedEventTargetId) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return true;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(eventType, target) {\n  // We are only interested in filtering `keypress` events for now.\n  if (eventType !== 'keypress') {\n    return false;\n  }\n\n  if (!target || !target.tagName) {\n    return true;\n  }\n\n  // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n  // e.g.tabbing through elements, hotkeys, etc.\n  if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n */\nfunction makeDOMEventHandler(\n  handler,\n  globalListener = false,\n) {\n  return (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 || event['_sentryCaptured']) {\n      return;\n    }\n\n    const target = getEventTarget(event);\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event.type, target)) {\n      return;\n    }\n\n    // Mark event as \"seen\"\n    addNonEnumerableProperty(event, '_sentryCaptured', true);\n\n    if (target && !target._sentryId) {\n      // Add UUID to event target so we can identify if\n      addNonEnumerableProperty(target, '_sentryId', uuid4());\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.\n    // If there is a last captured event, 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    if (!isSimilarToLastCapturedEvent(event)) {\n      const handlerData = { event, name, global: globalListener };\n      handler(handlerData);\n      lastCapturedEventType = event.type;\n      lastCapturedEventTargetId = target ? target._sentryId : undefined;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      lastCapturedEventTargetId = undefined;\n      lastCapturedEventType = undefined;\n    }, DEBOUNCE_DURATION);\n  };\n}\n\nfunction getEventTarget(event) {\n  try {\n    return event.target ;\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n    return null;\n  }\n}\n\nexport { addClickKeypressInstrumentationHandler, instrumentDOM };\n//# sourceMappingURL=dom.js.map\n","import { addHandler, maybeInstrument, supportsHistory, triggerHandlers, fill } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nlet lastHref;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addHistoryInstrumentationHandler(handler) {\n  const type = 'history';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function ( ...args) {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    const handlerData = { from, to };\n    triggerHandlers('history', handlerData);\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        const handlerData = { from, to };\n        triggerHandlers('history', handlerData);\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nexport { addHistoryInstrumentationHandler };\n//# sourceMappingURL=history.js.map\n","import { isNativeFunction, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { WINDOW } from './types.js';\n\n/**\n * We generally want to use window.fetch / window.setTimeout.\n * However, in some cases this may be wrapped (e.g. by Zone.js for Angular),\n * so we try to get an unpatched version of this from a sandboxed iframe.\n */\n\nconst cachedImplementations = {};\n\n/**\n * Get the native implementation of a browser function.\n *\n * This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.\n *\n * The following methods can be retrieved:\n * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.\n * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.\n */\nfunction getNativeImplementation(\n  name,\n) {\n  const cached = cachedImplementations[name];\n  if (cached) {\n    return cached;\n  }\n\n  let impl = WINDOW[name] ;\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFunction(impl)) {\n    return (cachedImplementations[name] = impl.bind(WINDOW) );\n  }\n\n  const document = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow[name]) {\n        impl = contentWindow[name] ;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      // Could not create sandbox iframe, just use window.xxx\n      DEBUG_BUILD && logger.warn(`Could not create sandbox iframe for ${name} check, bailing to window.${name}: `, e);\n    }\n  }\n\n  // Sanity check: This _should_ not happen, but if it does, we just skip caching...\n  // This can happen e.g. in tests where fetch may not be available in the env, or similar.\n  if (!impl) {\n    return impl;\n  }\n\n  return (cachedImplementations[name] = impl.bind(WINDOW) );\n}\n\n/** Clear a cached implementation. */\nfunction clearCachedImplementation(name) {\n  cachedImplementations[name] = undefined;\n}\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction fetch(...rest) {\n  return getNativeImplementation('fetch')(...rest);\n}\n\n/**\n * Get an unwrapped `setTimeout` method.\n * This ensures that even if e.g. Angular wraps `setTimeout`, we get the native implementation,\n * avoiding triggering change detection.\n */\nfunction setTimeout(...rest) {\n  return getNativeImplementation('setTimeout')(...rest);\n}\n\nexport { clearCachedImplementation, fetch, getNativeImplementation, setTimeout };\n//# sourceMappingURL=getNativeImplementation.js.map\n","import { addHandler, maybeInstrument, timestampInSeconds, isString, triggerHandlers } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nconst SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addXhrInstrumentationHandler(handler) {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nfunction instrumentXHR() {\n  if (!(WINDOW ).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.open = new Proxy(xhrproto.open, {\n    apply(originalOpen, xhrOpenThisArg, xhrOpenArgArray) {\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your XHR call did not\n      //       have a stack trace. If you are using HttpClient integration,\n      //       this is the expected behavior, as we are using this virtual error to capture\n      //       the location of your XHR call, and group your HttpClient events accordingly.\n      const virtualError = new Error();\n\n      const startTimestamp = timestampInSeconds() * 1000;\n\n      // open() should always be called with two or more arguments\n      // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n      const method = isString(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : undefined;\n      const url = parseUrl(xhrOpenArgArray[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n      }\n\n      xhrOpenThisArg[SENTRY_XHR_DATA_KEY] = {\n        method,\n        url,\n        request_headers: {},\n      };\n\n      // if Sentry key appears in URL, don't capture it as a request\n      if (method === 'POST' && url.match(/sentry_key/)) {\n        xhrOpenThisArg.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (xhrOpenThisArg.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhrOpenThisArg.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          const handlerData = {\n            endTimestamp: timestampInSeconds() * 1000,\n            startTimestamp,\n            xhr: xhrOpenThisArg,\n            virtualError,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === 'function') {\n        xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {\n          apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray) {\n            onreadystatechangeHandler();\n            return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);\n          },\n        });\n      } else {\n        xhrOpenThisArg.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {\n        apply(\n          originalSetRequestHeader,\n          setRequestHeaderThisArg,\n          setRequestHeaderArgArray,\n        ) {\n          const [header, value] = setRequestHeaderArgArray;\n\n          const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);\n        },\n      });\n\n      return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n    },\n  });\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.send = new Proxy(xhrproto.send, {\n    apply(originalSend, sendThisArg, sendArgArray) {\n      const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(sendThisArg, sendArgArray);\n      }\n\n      if (sendArgArray[0] !== undefined) {\n        sentryXhrData.body = sendArgArray[0];\n      }\n\n      const handlerData = {\n        startTimestamp: timestampInSeconds() * 1000,\n        xhr: sendThisArg,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(sendThisArg, sendArgArray);\n    },\n  });\n}\n\nfunction parseUrl(url) {\n  if (isString(url)) {\n    return url;\n  }\n\n  try {\n    // url can be a string or URL\n    // but since URL is not available in IE11, we do not check for it,\n    // but simply assume it is an URL and return `toString()` from it (which returns the full URL)\n    // If that fails, we just return undefined\n    return (url ).toString();\n  } catch (e2) {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n\nexport { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler, instrumentXHR };\n//# sourceMappingURL=xhr.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, getRootSpan, spanToJSON, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { addInpInstrumentationHandler, addPerformanceInstrumentationHandler, isPerformanceEventTiming } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startStandaloneWebVitalSpan } from './utils.js';\n\nconst LAST_INTERACTIONS = [];\nconst INTERACTIONS_SPAN_MAP = new Map();\n\n/**\n * Start tracking INP webvital events.\n */\nfunction startTrackingINP() {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    const inpCallback = _trackINP();\n\n    return () => {\n      inpCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\nconst INP_ENTRY_MAP = {\n  click: 'click',\n  pointerdown: 'click',\n  pointerup: 'click',\n  mousedown: 'click',\n  mouseup: 'click',\n  touchstart: 'click',\n  touchend: 'click',\n  mouseover: 'hover',\n  mouseout: 'hover',\n  mouseenter: 'hover',\n  mouseleave: 'hover',\n  pointerover: 'hover',\n  pointerout: 'hover',\n  pointerenter: 'hover',\n  pointerleave: 'hover',\n  dragstart: 'drag',\n  dragend: 'drag',\n  drag: 'drag',\n  dragenter: 'drag',\n  dragleave: 'drag',\n  dragover: 'drag',\n  drop: 'drag',\n  keydown: 'press',\n  keyup: 'press',\n  keypress: 'press',\n  input: 'press',\n};\n\n/** Starts tracking the Interaction to Next Paint on the current page. */\nfunction _trackINP() {\n  return addInpInstrumentationHandler(({ metric }) => {\n    if (metric.value == undefined) {\n      return;\n    }\n\n    const entry = metric.entries.find(entry => entry.duration === metric.value && INP_ENTRY_MAP[entry.name]);\n\n    if (!entry) {\n      return;\n    }\n\n    const { interactionId } = entry;\n    const interactionType = INP_ENTRY_MAP[entry.name];\n\n    /** Build the INP span, create an envelope from the span, and then send the envelope */\n    const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n    const duration = msToSec(metric.value);\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan ? getRootSpan(activeSpan) : undefined;\n\n    // We first try to lookup the span from our INTERACTIONS_SPAN_MAP,\n    // where we cache the route per interactionId\n    const cachedSpan = interactionId != null ? INTERACTIONS_SPAN_MAP.get(interactionId) : undefined;\n\n    const spanToUse = cachedSpan || rootSpan;\n\n    // Else, we try to use the active span.\n    // Finally, we fall back to look at the transactionName on the scope\n    const routeName = spanToUse ? spanToJSON(spanToUse).description : getCurrentScope().getScopeData().transactionName;\n\n    const name = htmlTreeAsString(entry.target);\n    const attributes = dropUndefinedKeys({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.inp',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `ui.interaction.${interactionType}`,\n      [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: entry.duration,\n    });\n\n    const span = startStandaloneWebVitalSpan({\n      name,\n      transaction: routeName,\n      attributes,\n      startTime,\n    });\n\n    if (span) {\n      span.addEvent('inp', {\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: 'millisecond',\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: metric.value,\n      });\n\n      span.end(startTime + duration);\n    }\n  });\n}\n\n/**\n * Register a listener to cache route information for INP interactions.\n * TODO(v9): `latestRoute` no longer needs to be passed in and will be removed in v9.\n */\nfunction registerInpInteractionListener(_latestRoute) {\n  const handleEntries = ({ entries }) => {\n    const activeSpan = getActiveSpan();\n    const activeRootSpan = activeSpan && getRootSpan(activeSpan);\n\n    entries.forEach(entry => {\n      if (!isPerformanceEventTiming(entry) || !activeRootSpan) {\n        return;\n      }\n\n      const interactionId = entry.interactionId;\n      if (interactionId == null) {\n        return;\n      }\n\n      // If the interaction was already recorded before, nothing more to do\n      if (INTERACTIONS_SPAN_MAP.has(interactionId)) {\n        return;\n      }\n\n      // We keep max. 10 interactions in the list, then remove the oldest one & clean up\n      if (LAST_INTERACTIONS.length > 10) {\n        const last = LAST_INTERACTIONS.shift() ;\n        INTERACTIONS_SPAN_MAP.delete(last);\n      }\n\n      // We add the interaction to the list of recorded interactions\n      // and store the span for this interaction\n      LAST_INTERACTIONS.push(interactionId);\n      INTERACTIONS_SPAN_MAP.set(interactionId, activeRootSpan);\n    });\n  };\n\n  addPerformanceInstrumentationHandler('event', handleEntries);\n  addPerformanceInstrumentationHandler('first-input', handleEntries);\n}\n\nexport { registerInpInteractionListener, startTrackingINP };\n//# sourceMappingURL=inp.js.map\n","import { getNativeImplementation, clearCachedImplementation } from '@sentry-internal/browser-utils';\nimport { createTransport, rejectedSyncPromise } from '@sentry/core';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeImplementation('fetch'),\n) {\n  let pendingBodySize = 0;\n  let pendingCount = 0;\n\n  function makeRequest(request) {\n    const requestSize = request.body.length;\n    pendingBodySize += requestSize;\n    pendingCount++;\n\n    const requestOptions = {\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. when finishing 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):\n      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n      //   We will therefore only activate the flag when we're below that limit.\n      // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n      keepalive: pendingBodySize <= 60000 && pendingCount < 15,\n      ...options.fetchOptions,\n    };\n\n    if (!nativeFetch) {\n      clearCachedImplementation('fetch');\n      return rejectedSyncPromise('No fetch implementation available');\n    }\n\n    try {\n      // TODO: This may need a `suppressTracing` call in the future when we switch the browser SDK to OTEL\n      return nativeFetch(options.url, requestOptions).then(response => {\n        pendingBodySize -= requestSize;\n        pendingCount--;\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      clearCachedImplementation('fetch');\n      pendingBodySize -= requestSize;\n      pendingCount--;\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createStackParser, UNKNOWN_FUNCTION } from '@sentry/core';\n\n// This was originally forked from https://github.com/csnover/TraceKit, and was largely\n// re - written as part of raven - js.\n//\n// This code was later copied to the JavaScript mono - repo and further modified and\n// refactored over the years.\n\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  const frame = {\n    filename,\n    function: func === '<anonymous>' ? UNKNOWN_FUNCTION : func,\n    in_app: true, // All browser frames are considered in_app\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// This regex matches frames that have no function name (ie. are at the top level of a module).\n// For example \"at http://localhost:5000//script.js:1:126\"\n// Frames _with_ function names usually look as follows: \"at commitLayoutEffects (react-dom.development.js:23426:1)\"\nconst chromeRegexNoFnName = /^\\s*at (\\S+?)(?::(\\d+))(?::(\\d+))\\s*$/i;\n\n// This regex matches all the frames that have a function name.\nconst chromeRegex =\n  /^\\s*at (?:(.+?\\)(?: \\[.+\\])?|.*?) ?\\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn = line => {\n  // If the stack line has no function name, we need to parse it differently\n  const noFnParts = chromeRegexNoFnName.exec(line) ;\n\n  if (noFnParts) {\n    const [, filename, line, col] = noFnParts;\n    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col);\n  }\n\n  const parts = chromeRegex.exec(line) ;\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]) ;\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nconst chromeStackLineParser = [CHROME_PRIORITY, chromeStackParserFn];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko = line => {\n  const parts = geckoREgex.exec(line) ;\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]) ;\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nconst geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs = line => {\n  const parts = winjsRegex.exec(line) ;\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nconst winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10 = line => {\n  const parts = opera10Regex.exec(line) ;\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nconst opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11 = line => {\n  const parts = opera11Regex.exec(line) ;\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nconst opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nconst defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser];\n\nconst defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func, filename) => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? (func.split('@')[0] ) : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { addClickKeypressInstrumentationHandler, addXhrInstrumentationHandler, addHistoryInstrumentationHandler, SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';\nimport { defineIntegration, addConsoleInstrumentationHandler, addFetchInstrumentationHandler, getClient, addBreadcrumb, getEventDescription, logger, htmlTreeAsString, getComponentName, severityLevelFromString, safeJoin, getBreadcrumbLogLevelFromHttpStatusCode, parseUrl } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/* eslint-disable max-lines */\n\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options = {}) => {\n  const _options = {\n    console: true,\n    dom: true,\n    fetch: true,\n    history: true,\n    sentry: true,\n    xhr: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      if (_options.console) {\n        addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n      }\n      if (_options.dom) {\n        addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n      }\n      if (_options.xhr) {\n        addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n      }\n      if (_options.fetch) {\n        addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n      }\n      if (_options.history) {\n        addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n      }\n      if (_options.sentry) {\n        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n      }\n    },\n  };\n}) ;\n\nconst breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client) {\n  return function addSentryBreadcrumb(event) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    addBreadcrumb(\n      {\n        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n        event_id: event.event_id,\n        level: event.level,\n        message: getEventDescription(event),\n      },\n      {\n        event,\n      },\n    );\n  };\n}\n\n/**\n * A HOC that creates 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 */\nfunction _getDomBreadcrumbHandler(\n  client,\n  dom,\n) {\n  return function _innerDomBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let target;\n    let componentName;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    let maxStringLength =\n      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n        );\n      maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n    }\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      const event = handlerData.event ;\n      const element = _isEvent(event) ? event.target : event;\n\n      target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n      componentName = getComponentName(element);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: `ui.${handlerData.name}`,\n      message: target,\n    };\n\n    if (componentName) {\n      breadcrumb.data = { 'ui.component_name': componentName };\n    }\n\n    addBreadcrumb(breadcrumb, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client) {\n  return function _consoleBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: severityLevelFromString(handlerData.level),\n      message: safeJoin(handlerData.args, ' '),\n    };\n\n    if (handlerData.level === 'assert') {\n      if (handlerData.args[0] === false) {\n        breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n        breadcrumb.data.arguments = handlerData.args.slice(1);\n      } else {\n        // Don't capture a breadcrumb for passed assertions\n        return;\n      }\n    }\n\n    addBreadcrumb(breadcrumb, {\n      input: handlerData.args,\n      level: handlerData.level,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client) {\n  return function _xhrBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n    // We only capture complete, non-sentry requests\n    if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n      return;\n    }\n\n    const { method, url, status_code, body } = sentryXhrData;\n\n    const data = {\n      method,\n      url,\n      status_code,\n    };\n\n    const hint = {\n      xhr: handlerData.xhr,\n      input: body,\n      startTimestamp,\n      endTimestamp,\n    };\n\n    const level = getBreadcrumbLogLevelFromHttpStatusCode(status_code);\n\n    addBreadcrumb(\n      {\n        category: 'xhr',\n        data,\n        type: 'http',\n        level,\n      },\n      hint,\n    );\n  };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client) {\n  return function _fetchBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    // We only capture complete fetch requests\n    if (!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      const data = handlerData.fetchData;\n      const hint = {\n        data: handlerData.error,\n        input: handlerData.args,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          level: 'error',\n          type: 'http',\n        },\n        hint,\n      );\n    } else {\n      const response = handlerData.response ;\n      const data = {\n        ...handlerData.fetchData,\n        status_code: response && response.status,\n      };\n      const hint = {\n        input: handlerData.args,\n        response,\n        startTimestamp,\n        endTimestamp,\n      };\n      const level = getBreadcrumbLogLevelFromHttpStatusCode(data.status_code);\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          type: 'http',\n          level,\n        },\n        hint,\n      );\n    }\n  };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client) {\n  return function _historyBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let from = handlerData.from;\n    let to = handlerData.to;\n    const parsedLoc = parseUrl(WINDOW.location.href);\n    let parsedFrom = from ? parseUrl(from) : undefined;\n    const parsedTo = parseUrl(to);\n\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom || !parsedFrom.path) {\n      parsedFrom = parsedLoc;\n    }\n\n    // Use only the path component of the URL if the URL matches the current\n    // document (almost all the time when using pushState)\n    if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n      to = parsedTo.relative;\n    }\n    if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n      from = parsedFrom.relative;\n    }\n\n    addBreadcrumb({\n      category: 'navigation',\n      data: {\n        from,\n        to,\n      },\n    });\n  };\n}\n\nfunction _isEvent(event) {\n  return !!event && !!(event ).target;\n}\n\nexport { breadcrumbsIntegration };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { defineIntegration, fill, getFunctionName, getOriginalFunction } from '@sentry/core';\nimport { WINDOW, wrap } from '../helpers.js';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'BrowserApiErrors';\n\nconst _browserApiErrorsIntegration = ((options = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    },\n  };\n}) ;\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n */\nconst browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\nfunction _wrapTimeFunction(original) {\n  return function ( ...args) {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: false,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\nfunction _wrapRAF(original) {\n  return function ( callback) {\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend) {\n  return function ( ...args) {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before BrowserApiErrors, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\nfunction _wrapEventTarget(target) {\n  const globalObject = WINDOW ;\n  const targetObj = globalObject[target];\n  const proto = targetObj && targetObj.prototype;\n\n  // eslint-disable-next-line no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function ( eventName, fn, options) {\n      try {\n        if (isEventListenerObject(fn)) {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (e2) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        wrap(fn, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener)\n\n {\n    return function ( 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      try {\n        const originalEventHandler = (fn ).__sentry_wrapped__;\n        if (originalEventHandler) {\n          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n        }\n      } catch (e) {\n        // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n      }\n      return originalRemoveEventListener.call(this, eventName, fn, options);\n    };\n  });\n}\n\nfunction isEventListenerObject(obj) {\n  return typeof (obj ).handleEvent === 'function';\n}\n\nexport { browserApiErrorsIntegration };\n//# sourceMappingURL=browserapierrors.js.map\n","import { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport { defineIntegration, logger, startSession, captureSession } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.\n * More information: https://docs.sentry.io/product/releases/health/\n *\n * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/\n */\nconst browserSessionIntegration = defineIntegration(() => {\n  return {\n    name: 'BrowserSession',\n    setupOnce() {\n      if (typeof WINDOW.document === 'undefined') {\n        DEBUG_BUILD &&\n          logger.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');\n        return;\n      }\n\n      // The session duration for browser sessions does not track a meaningful\n      // concept that can be used as a metric.\n      // Automatically captured sessions are akin to page views, and thus we\n      // discard their duration.\n      startSession({ ignoreDuration: true });\n      captureSession();\n\n      // We want to create a session for every navigation as well\n      addHistoryInstrumentationHandler(({ from, to }) => {\n        // Don't create an additional session for the initial route or if the location did not change\n        if (from !== undefined && from !== to) {\n          startSession({ ignoreDuration: true });\n          captureSession();\n        }\n      });\n    },\n  };\n});\n\nexport { browserSessionIntegration };\n//# sourceMappingURL=browsersession.js.map\n","import { defineIntegration, addGlobalErrorInstrumentationHandler, getClient, captureEvent, addGlobalUnhandledRejectionInstrumentationHandler, isPrimitive, isString, getLocationHref, UNKNOWN_FUNCTION, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options = {}) => {\n  const _options = {\n    onerror: true,\n    onunhandledrejection: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      Error.stackTraceLimit = 50;\n    },\n    setup(client) {\n      if (_options.onerror) {\n        _installGlobalOnErrorHandler(client);\n        globalHandlerLog('onerror');\n      }\n      if (_options.onunhandledrejection) {\n        _installGlobalOnUnhandledRejectionHandler(client);\n        globalHandlerLog('onunhandledrejection');\n      }\n    },\n  };\n}) ;\n\nconst globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\nfunction _installGlobalOnErrorHandler(client) {\n  addGlobalErrorInstrumentationHandler(data => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const { msg, url, line, column, error } = data;\n\n    const event = _enhanceEventWithInitialFrame(\n      eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n      url,\n      line,\n      column,\n    );\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onerror',\n      },\n    });\n  });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client) {\n  addGlobalUnhandledRejectionInstrumentationHandler(e => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const error = _getUnhandledRejectionError(e );\n\n    const event = isPrimitive(error)\n      ? _eventFromRejectionWithPrimitive(error)\n      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n  });\n}\n\nfunction _getUnhandledRejectionError(error) {\n  if (isPrimitive(error)) {\n    return error;\n  }\n\n  // dig the object of the rejection out of known event types\n  try {\n\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 (error )) {\n      return (error ).reason;\n    }\n\n    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n    // https://github.com/getsentry/sentry-javascript/issues/2380\n    if ('detail' in (error ) && 'reason' in (error ).detail) {\n      return (error ).detail.reason;\n    }\n  } catch (e2) {} // eslint-disable-line no-empty\n\n  return error;\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\nfunction _enhanceEventWithInitialFrame(\n  event,\n  url,\n  line,\n  column,\n) {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = column;\n  const lineno = line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: UNKNOWN_FUNCTION,\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions() {\n  const client = getClient();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return options;\n}\n\nexport { globalHandlersIntegration };\n//# sourceMappingURL=globalhandlers.js.map\n","import { defineIntegration } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * Collects information about HTTP request headers and\n * attaches them to the event.\n */\nconst httpContextIntegration = defineIntegration(() => {\n  return {\n    name: 'HttpContext',\n    preprocessEvent(event) {\n      // if none of the information we want exists, don't bother\n      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n        return;\n      }\n\n      // grab as much info as exists and add it to the event\n      const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n      const { referrer } = WINDOW.document || {};\n      const { userAgent } = WINDOW.navigator || {};\n\n      const headers = {\n        ...(event.request && event.request.headers),\n        ...(referrer && { Referer: referrer }),\n        ...(userAgent && { 'User-Agent': userAgent }),\n      };\n      const request = { ...event.request, ...(url && { url }), headers };\n\n      event.request = request;\n    },\n  };\n});\n\nexport { httpContextIntegration };\n//# sourceMappingURL=httpcontext.js.map\n","import { defineIntegration, applyAggregateErrorsToEvent } from '@sentry/core';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options = {}) => {\n  const limit = options.limit || DEFAULT_LIMIT;\n  const key = options.key || DEFAULT_KEY;\n\n  return {\n    name: INTEGRATION_NAME,\n    preprocessEvent(event, hint, client) {\n      const options = client.getOptions();\n\n      applyAggregateErrorsToEvent(\n        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n        exceptionFromError,\n        options.stackParser,\n        options.maxValueLength,\n        key,\n        limit,\n        event,\n        hint,\n      );\n    },\n  };\n}) ;\n\n/**\n * Aggregrate linked errors in an event.\n */\nconst linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n\nexport { linkedErrorsIntegration };\n//# sourceMappingURL=linkederrors.js.map\n","import { inboundFiltersIntegration, functionToStringIntegration, dedupeIntegration, consoleSandbox, supportsFetch, logger, stackParserFromStackParserOptions, getIntegrationsToSetup, initAndBind, getCurrentScope, lastEventId, getReportDialogEndpoint, getClient } from '@sentry/core';\nimport { BrowserClient } from './client.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { WINDOW } from './helpers.js';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs.js';\nimport { browserApiErrorsIntegration } from './integrations/browserapierrors.js';\nimport { browserSessionIntegration } from './integrations/browsersession.js';\nimport { globalHandlersIntegration } from './integrations/globalhandlers.js';\nimport { httpContextIntegration } from './integrations/httpcontext.js';\nimport { linkedErrorsIntegration } from './integrations/linkederrors.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport { makeFetchTransport } from './transports/fetch.js';\n\n/** Get the default integrations for the browser SDK. */\nfunction getDefaultIntegrations(options) {\n  /**\n   * Note: Please make sure this stays in sync with Angular SDK, which re-exports\n   * `getDefaultIntegrations` but with an adjusted set of integrations.\n   */\n  const integrations = [\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    browserApiErrorsIntegration(),\n    breadcrumbsIntegration(),\n    globalHandlersIntegration(),\n    linkedErrorsIntegration(),\n    dedupeIntegration(),\n    httpContextIntegration(),\n  ];\n\n  // eslint-disable-next-line deprecation/deprecation\n  if (options.autoSessionTracking !== false) {\n    integrations.push(browserSessionIntegration());\n  }\n\n  return integrations;\n}\n\nfunction applyDefaultOptions(optionsArg = {}) {\n  const defaultOptions = {\n    defaultIntegrations: getDefaultIntegrations(optionsArg),\n    release:\n      typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n        ? __SENTRY_RELEASE__\n        : WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id // This supports the variable that sentry-webpack-plugin injects\n          ? WINDOW.SENTRY_RELEASE.id\n          : undefined,\n    autoSessionTracking: true,\n    sendClientReports: true,\n  };\n\n  // TODO: Instead of dropping just `defaultIntegrations`, we should simply\n  // call `dropUndefinedKeys` on the entire `optionsArg`.\n  // However, for this to work we need to adjust the `hasTracingEnabled()` logic\n  // first as it differentiates between `undefined` and the key not being in the object.\n  if (optionsArg.defaultIntegrations == null) {\n    delete optionsArg.defaultIntegrations;\n  }\n\n  return { ...defaultOptions, ...optionsArg };\n}\n\nfunction shouldShowBrowserExtensionError() {\n  const windowWithMaybeExtension =\n    typeof WINDOW.window !== 'undefined' && (WINDOW );\n  if (!windowWithMaybeExtension) {\n    // No need to show the error if we're not in a browser window environment (e.g. service workers)\n    return false;\n  }\n\n  const extensionKey = windowWithMaybeExtension.chrome ? 'chrome' : 'browser';\n  const extensionObject = windowWithMaybeExtension[extensionKey];\n\n  const runtimeId = extensionObject && extensionObject.runtime && extensionObject.runtime.id;\n  const href = (WINDOW.location && WINDOW.location.href) || '';\n\n  const extensionProtocols = ['chrome-extension:', 'moz-extension:', 'ms-browser-extension:', 'safari-web-extension:'];\n\n  // Running the SDK in a dedicated extension page and calling Sentry.init is fine; no risk of data leakage\n  const isDedicatedExtensionPage =\n    !!runtimeId && WINDOW === WINDOW.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}//`));\n\n  // Running the SDK in NW.js, which appears like a browser extension but isn't, is also fine\n  // see: https://github.com/getsentry/sentry-javascript/issues/12668\n  const isNWjs = typeof windowWithMaybeExtension.nw !== 'undefined';\n\n  return !!runtimeId && !isDedicatedExtensionPage && !isNWjs;\n}\n\n/**\n * A magic string that build tooling can leverage in order to inject a release value into the SDK.\n */\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { 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 */\nfunction init(browserOptions = {}) {\n  const options = applyDefaultOptions(browserOptions);\n\n  if (!options.skipBrowserExtensionCheck && shouldShowBrowserExtensionError()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(\n        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',\n      );\n    });\n    return;\n  }\n\n  if (DEBUG_BUILD) {\n    if (!supportsFetch()) {\n      logger.warn(\n        'No Fetch API detected. The Sentry SDK requires a Fetch API compatible environment to send events. Please add a Fetch API polyfill.',\n      );\n    }\n  }\n  const clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeFetchTransport,\n  };\n\n  return initAndBind(BrowserClient, clientOptions);\n}\n\n/**\n * All properties the report dialog supports\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 */\nfunction showReportDialog(options = {}) {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const scope = getCurrentScope();\n  const client = scope.getClient();\n  const dsn = client && client.getDsn();\n\n  if (!dsn) {\n    DEBUG_BUILD && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    const eventId = lastEventId();\n    if (eventId) {\n      options.eventId = eventId;\n    }\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.crossOrigin = 'anonymous';\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    script.onload = options.onLoad;\n  }\n\n  const { onClose } = options;\n  if (onClose) {\n    const reportDialogClosedMessageHandler = (event) => {\n      if (event.data === '__sentry_reportdialog_closed__') {\n        try {\n          onClose();\n        } finally {\n          WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n        }\n      }\n    };\n    WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\n}\n\n/**\n * Captures user feedback and sends it to Sentry.\n *\n * @deprecated Use `captureFeedback` instead.\n */\nfunction captureUserFeedback(feedback) {\n  const client = getClient();\n  if (client) {\n    // eslint-disable-next-line deprecation/deprecation\n    client.captureUserFeedback(feedback);\n  }\n}\n\nexport { captureUserFeedback, forceLoad, getDefaultIntegrations, init, onLoad, showReportDialog };\n//# sourceMappingURL=sdk.js.map\n","import { addXhrInstrumentationHandler, addPerformanceInstrumentationHandler, SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';\nimport { addFetchEndInstrumentationHandler, addFetchInstrumentationHandler, instrumentFetchRequest, parseUrl, spanToJSON, browserPerformanceTimeOrigin, hasTracingEnabled, setHttpStatus, getActiveSpan, startInactiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SentryNonRecordingSpan, getTraceData, stringMatchesSomePattern } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/** Options for Request Instrumentation */\n\nconst responseToSpanId = new WeakMap();\nconst spanIdToEndTimestamp = new Map();\n\nconst defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  enableHTTPTimings: true,\n  trackFetchStreamPerformance: false,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nfunction instrumentOutgoingRequests(client, _options) {\n  const {\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    tracePropagationTargets,\n  } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    trackFetchStreamPerformance: defaultRequestInstrumentationOptions.trackFetchStreamPerformance,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_) => true;\n\n  const shouldAttachHeadersWithTargets = (url) => shouldAttachHeaders(url, tracePropagationTargets);\n\n  const spans = {};\n\n  if (traceFetch) {\n    // Keeping track of http requests, whose body payloads resolved later than the initial resolved request\n    // e.g. streaming using server sent events (SSE)\n    client.addEventProcessor(event => {\n      if (event.type === 'transaction' && event.spans) {\n        event.spans.forEach(span => {\n          if (span.op === 'http.client') {\n            const updatedTimestamp = spanIdToEndTimestamp.get(span.span_id);\n            if (updatedTimestamp) {\n              span.timestamp = updatedTimestamp / 1000;\n              spanIdToEndTimestamp.delete(span.span_id);\n            }\n          }\n        });\n      }\n      return event;\n    });\n\n    if (trackFetchStreamPerformance) {\n      addFetchEndInstrumentationHandler(handlerData => {\n        if (handlerData.response) {\n          const span = responseToSpanId.get(handlerData.response);\n          if (span && handlerData.endTimestamp) {\n            spanIdToEndTimestamp.set(span, handlerData.endTimestamp);\n          }\n        }\n      });\n    }\n\n    addFetchInstrumentationHandler(handlerData => {\n      const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n\n      if (handlerData.response && handlerData.fetchData.__span) {\n        responseToSpanId.set(handlerData.response, handlerData.fetchData.__span);\n      }\n\n      // We cannot use `window.location` in the generic fetch instrumentation,\n      // but we need it for reliable `server.address` attribute.\n      // so we extend this in here\n      if (createdSpan) {\n        const fullUrl = getFullURL(handlerData.fetchData.url);\n        const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n        createdSpan.setAttributes({\n          'http.url': fullUrl,\n          'server.address': host,\n        });\n      }\n\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n\n  if (traceXHR) {\n    addXhrInstrumentationHandler(handlerData => {\n      const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n}\n\nfunction isPerformanceResourceTiming(entry) {\n  return (\n    entry.entryType === 'resource' &&\n    'initiatorType' in entry &&\n    typeof (entry ).nextHopProtocol === 'string' &&\n    (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')\n  );\n}\n\n/**\n * Creates a temporary observer to listen to the next fetch/xhr resourcing timings,\n * so that when timings hit their per-browser limit they don't need to be removed.\n *\n * @param span A span that has yet to be finished, must contain `url` on data.\n */\nfunction addHTTPTimings(span) {\n  const { url } = spanToJSON(span).data || {};\n\n  if (!url || typeof url !== 'string') {\n    return;\n  }\n\n  const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => {\n    entries.forEach(entry => {\n      if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) {\n        const spanData = resourceTimingEntryToSpanData(entry);\n        spanData.forEach(data => span.setAttribute(...data));\n        // In the next tick, clean this handler up\n        // We have to wait here because otherwise this cleans itself up before it is fully done\n        setTimeout(cleanup);\n      }\n    });\n  });\n}\n\n/**\n * Converts ALPN protocol ids to name and version.\n *\n * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)\n * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol\n */\nfunction extractNetworkProtocol(nextHopProtocol) {\n  let name = 'unknown';\n  let version = 'unknown';\n  let _name = '';\n  for (const char of nextHopProtocol) {\n    // http/1.1 etc.\n    if (char === '/') {\n      [name, version] = nextHopProtocol.split('/') ;\n      break;\n    }\n    // h2, h3 etc.\n    if (!isNaN(Number(char))) {\n      name = _name === 'h' ? 'http' : _name;\n      version = nextHopProtocol.split(_name)[1] ;\n      break;\n    }\n    _name += char;\n  }\n  if (_name === nextHopProtocol) {\n    // webrtc, ftp, etc.\n    name = _name;\n  }\n  return { name, version };\n}\n\nfunction getAbsoluteTime(time = 0) {\n  return ((browserPerformanceTimeOrigin || performance.timeOrigin) + time) / 1000;\n}\n\nfunction resourceTimingEntryToSpanData(resourceTiming) {\n  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);\n\n  const timingSpanData = [];\n\n  timingSpanData.push(['network.protocol.version', version], ['network.protocol.name', name]);\n\n  if (!browserPerformanceTimeOrigin) {\n    return timingSpanData;\n  }\n  return [\n    ...timingSpanData,\n    ['http.request.redirect_start', getAbsoluteTime(resourceTiming.redirectStart)],\n    ['http.request.fetch_start', getAbsoluteTime(resourceTiming.fetchStart)],\n    ['http.request.domain_lookup_start', getAbsoluteTime(resourceTiming.domainLookupStart)],\n    ['http.request.domain_lookup_end', getAbsoluteTime(resourceTiming.domainLookupEnd)],\n    ['http.request.connect_start', getAbsoluteTime(resourceTiming.connectStart)],\n    ['http.request.secure_connection_start', getAbsoluteTime(resourceTiming.secureConnectionStart)],\n    ['http.request.connection_end', getAbsoluteTime(resourceTiming.connectEnd)],\n    ['http.request.request_start', getAbsoluteTime(resourceTiming.requestStart)],\n    ['http.request.response_start', getAbsoluteTime(resourceTiming.responseStart)],\n    ['http.request.response_end', getAbsoluteTime(resourceTiming.responseEnd)],\n  ];\n}\n\n/**\n * A function that determines whether to attach tracing headers to a request.\n * We only export this function for testing purposes.\n */\nfunction shouldAttachHeaders(\n  targetUrl,\n  tracePropagationTargets,\n) {\n  // window.location.href not being defined is an edge case in the browser but we need to handle it.\n  // Potentially dangerous situations where it may not be defined: Browser Extensions, Web Workers, patching of the location obj\n  const href = WINDOW.location && WINDOW.location.href;\n\n  if (!href) {\n    // If there is no window.location.origin, we default to only attaching tracing headers to relative requests, i.e. ones that start with `/`\n    // BIG DISCLAIMER: Users can call URLs with a double slash (fetch(\"//example.com/api\")), this is a shorthand for \"send to the same protocol\",\n    // so we need a to exclude those requests, because they might be cross origin.\n    const isRelativeSameOriginRequest = !!targetUrl.match(/^\\/(?!\\/)/);\n    if (!tracePropagationTargets) {\n      return isRelativeSameOriginRequest;\n    } else {\n      return stringMatchesSomePattern(targetUrl, tracePropagationTargets);\n    }\n  } else {\n    let resolvedUrl;\n    let currentOrigin;\n\n    // URL parsing may fail, we default to not attaching trace headers in that case.\n    try {\n      resolvedUrl = new URL(targetUrl, href);\n      currentOrigin = new URL(href).origin;\n    } catch (e) {\n      return false;\n    }\n\n    const isSameOriginRequest = resolvedUrl.origin === currentOrigin;\n    if (!tracePropagationTargets) {\n      return isSameOriginRequest;\n    } else {\n      return (\n        stringMatchesSomePattern(resolvedUrl.toString(), tracePropagationTargets) ||\n        (isSameOriginRequest && stringMatchesSomePattern(resolvedUrl.pathname, tracePropagationTargets))\n      );\n    }\n  }\n}\n\n/**\n * Create and track xhr request spans\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction xhrCallback(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n) {\n  const xhr = handlerData.xhr;\n  const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(sentryXhrData.url);\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span && sentryXhrData.status_code !== undefined) {\n      setHttpStatus(span, sentryXhrData.status_code);\n      span.end();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const fullUrl = getFullURL(sentryXhrData.url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${sentryXhrData.method} ${sentryXhrData.url}`,\n          attributes: {\n            type: 'xhr',\n            'http.method': sentryXhrData.method,\n            'http.url': fullUrl,\n            url: sentryXhrData.url,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;\n  spans[xhr.__sentry_xhr_span_id__] = span;\n\n  if (shouldAttachHeaders(sentryXhrData.url)) {\n    addTracingHeadersToXhrRequest(\n      xhr,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasTracingEnabled() && hasParent ? span : undefined,\n    );\n  }\n\n  return span;\n}\n\nfunction addTracingHeadersToXhrRequest(xhr, span) {\n  const { 'sentry-trace': sentryTrace, baggage } = getTraceData({ span });\n\n  if (sentryTrace) {\n    setHeaderOnXhr(xhr, sentryTrace, baggage);\n  }\n}\n\nfunction setHeaderOnXhr(\n  xhr,\n  sentryTraceHeader,\n  sentryBaggageHeader,\n) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    xhr.setRequestHeader('sentry-trace', sentryTraceHeader);\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      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      xhr.setRequestHeader('baggage', sentryBaggageHeader);\n    }\n  } catch (_) {\n    // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n  }\n}\n\nfunction getFullURL(url) {\n  try {\n    // By adding a base URL to new URL(), this will also work for relative urls\n    // If `url` is a full URL, the base URL is ignored anyhow\n    const parsed = new URL(url, WINDOW.location.origin);\n    return parsed.href;\n  } catch (e2) {\n    return undefined;\n  }\n}\n\nexport { defaultRequestInstrumentationOptions, extractNetworkProtocol, instrumentOutgoingRequests, shouldAttachHeaders, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { getActiveSpan, getRootSpan, spanToJSON, logger, SPAN_STATUS_ERROR } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeSpan = getActiveSpan();\n      if (!activeSpan) {\n        return;\n      }\n\n      const rootSpan = getRootSpan(activeSpan);\n\n      if (WINDOW.document.hidden && rootSpan) {\n        const cancelledStatus = 'cancelled';\n\n        const { op, status } = spanToJSON(rootSpan);\n\n        if (DEBUG_BUILD) {\n          logger.log(`[Tracing] Transaction: ${cancelledStatus} -> since tab moved to the background, op: ${op}`);\n        }\n\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!status) {\n          rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: cancelledStatus });\n        }\n\n        rootSpan.setAttribute('sentry.cancellation_reason', 'document.hidden');\n        rootSpan.end();\n      }\n    });\n  } else {\n    DEBUG_BUILD && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","import { startTrackingWebVitals, startTrackingINP, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingInteractions, addHistoryInstrumentationHandler, registerInpInteractionListener, addPerformanceEntries } from '@sentry-internal/browser-utils';\nimport { TRACING_DEFAULTS, registerSpanErrorInstrumentation, GLOBAL_OBJ, getClient, propagationContextFromHeaders, getCurrentScope, spanToJSON, getRootSpan, spanIsSampled, getDynamicSamplingContextFromSpan, browserPerformanceTimeOrigin, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, getActiveSpan, getIsolationScope, generateTraceId, getDomElement, startIdleSpan, logger, SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\n\n/* eslint-disable max-lines */\n\nconst BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableLongAnimationFrame: true,\n  enableInp: true,\n  _experiments: {},\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nconst browserTracingIntegration = ((_options = {}) => {\n  registerSpanErrorInstrumentation();\n\n  const {\n    enableInp,\n    enableLongTask,\n    enableLongAnimationFrame,\n    _experiments: { enableInteractions, enableStandaloneClsSpans },\n    beforeStartSpan,\n    idleTimeout,\n    finalTimeout,\n    childSpanTimeout,\n    markBackgroundSpan,\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    instrumentPageLoad,\n    instrumentNavigation,\n  } = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ..._options,\n  };\n\n  const _collectWebVitals = startTrackingWebVitals({ recordClsStandaloneSpans: enableStandaloneClsSpans || false });\n\n  if (enableInp) {\n    startTrackingINP();\n  }\n\n  if (\n    enableLongAnimationFrame &&\n    GLOBAL_OBJ.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes &&\n    PerformanceObserver.supportedEntryTypes.includes('long-animation-frame')\n  ) {\n    startTrackingLongAnimationFrames();\n  } else if (enableLongTask) {\n    startTrackingLongTasks();\n  }\n\n  if (enableInteractions) {\n    startTrackingInteractions();\n  }\n\n  const latestRoute = {\n    name: undefined,\n    source: undefined,\n  };\n\n  /** Create routing idle transaction. */\n  function _createRouteSpan(client, startSpanOptions) {\n    const isPageloadTransaction = startSpanOptions.op === 'pageload';\n\n    const finalStartSpanOptions = beforeStartSpan\n      ? beforeStartSpan(startSpanOptions)\n      : startSpanOptions;\n\n    const attributes = finalStartSpanOptions.attributes || {};\n\n    // If `finalStartSpanOptions.name` is different than `startSpanOptions.name`\n    // it is because `beforeStartSpan` set a custom name. Therefore we set the source to 'custom'.\n    if (startSpanOptions.name !== finalStartSpanOptions.name) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'custom';\n      finalStartSpanOptions.attributes = attributes;\n    }\n\n    latestRoute.name = finalStartSpanOptions.name;\n    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const idleSpan = startIdleSpan(finalStartSpanOptions, {\n      idleTimeout,\n      finalTimeout,\n      childSpanTimeout,\n      // should wait for finish signal if it's a pageload transaction\n      disableAutoFinish: isPageloadTransaction,\n      beforeSpanEnd: span => {\n        _collectWebVitals();\n        addPerformanceEntries(span, { recordClsOnPageloadSpan: !enableStandaloneClsSpans });\n      },\n    });\n\n    function emitFinish() {\n      if (['interactive', 'complete'].includes(WINDOW.document.readyState)) {\n        client.emit('idleSpanEnableAutoFinish', idleSpan);\n      }\n    }\n\n    if (isPageloadTransaction && WINDOW.document) {\n      WINDOW.document.addEventListener('readystatechange', () => {\n        emitFinish();\n      });\n\n      emitFinish();\n    }\n\n    return idleSpan;\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    afterAllSetup(client) {\n      let activeSpan;\n      let startingUrl = WINDOW.location && WINDOW.location.href;\n\n      function maybeEndActiveSpan() {\n        if (activeSpan && !spanToJSON(activeSpan).timestamp) {\n          DEBUG_BUILD && logger.log(`[Tracing] Finishing current active span with op: ${spanToJSON(activeSpan).op}`);\n          // If there's an open active span, we need to finish it before creating an new one.\n          activeSpan.end();\n        }\n      }\n\n      client.on('startNavigationSpan', startSpanOptions => {\n        if (getClient() !== client) {\n          return;\n        }\n\n        maybeEndActiveSpan();\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'navigation',\n          ...startSpanOptions,\n        });\n      });\n\n      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {\n        if (getClient() !== client) {\n          return;\n        }\n        maybeEndActiveSpan();\n\n        const sentryTrace = traceOptions.sentryTrace || getMetaContent('sentry-trace');\n        const baggage = traceOptions.baggage || getMetaContent('baggage');\n\n        const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n        getCurrentScope().setPropagationContext(propagationContext);\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'pageload',\n          ...startSpanOptions,\n        });\n      });\n\n      // A trace should to stay the consistent over the entire time span of one route.\n      // Therefore, when the initial pageload or navigation root span ends, we update the\n      // scope's propagation context to keep span-specific attributes like the `sampled` decision and\n      // the dynamic sampling context valid, even after the root span has ended.\n      // This ensures that the trace data is consistent for the entire duration of the route.\n      client.on('spanEnd', span => {\n        const op = spanToJSON(span).op;\n        if (span !== getRootSpan(span) || (op !== 'navigation' && op !== 'pageload')) {\n          return;\n        }\n\n        const scope = getCurrentScope();\n        const oldPropagationContext = scope.getPropagationContext();\n\n        scope.setPropagationContext({\n          ...oldPropagationContext,\n          sampled: oldPropagationContext.sampled !== undefined ? oldPropagationContext.sampled : spanIsSampled(span),\n          dsc: oldPropagationContext.dsc || getDynamicSamplingContextFromSpan(span),\n        });\n      });\n\n      if (WINDOW.location) {\n        if (instrumentPageLoad) {\n          startBrowserTracingPageLoadSpan(client, {\n            name: WINDOW.location.pathname,\n            // pageload should always start at timeOrigin (and needs to be in s, not ms)\n            startTime: browserPerformanceTimeOrigin ? browserPerformanceTimeOrigin / 1000 : undefined,\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.browser',\n            },\n          });\n        }\n\n        if (instrumentNavigation) {\n          addHistoryInstrumentationHandler(({ to, from }) => {\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              startBrowserTracingNavigationSpan(client, {\n                name: WINDOW.location.pathname,\n                attributes: {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.browser',\n                },\n              });\n            }\n          });\n        }\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (enableInteractions) {\n        registerInteractionListener(idleTimeout, finalTimeout, childSpanTimeout, latestRoute);\n      }\n\n      if (enableInp) {\n        registerInpInteractionListener();\n      }\n\n      instrumentOutgoingRequests(client, {\n        traceFetch,\n        traceXHR,\n        trackFetchStreamPerformance,\n        tracePropagationTargets: client.getOptions().tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n      });\n    },\n  };\n}) ;\n\n/**\n * Manually start a page load span.\n * This will only do something if a browser tracing integration integration has been setup.\n *\n * If you provide a custom `traceOptions` object, it will be used to continue the trace\n * instead of the default behavior, which is to look it up on the <meta> tags.\n */\nfunction startBrowserTracingPageLoadSpan(\n  client,\n  spanOptions,\n  traceOptions,\n) {\n  client.emit('startPageLoadSpan', spanOptions, traceOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'pageload' ? span : undefined;\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if a browser tracing integration has been setup.\n */\nfunction startBrowserTracingNavigationSpan(client, spanOptions) {\n  getIsolationScope().setPropagationContext({ traceId: generateTraceId() });\n  getCurrentScope().setPropagationContext({ traceId: generateTraceId() });\n\n  client.emit('startNavigationSpan', spanOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'navigation' ? span : undefined;\n}\n\n/** Returns the value of a meta tag */\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  // eslint-disable-next-line deprecation/deprecation\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : undefined;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  idleTimeout,\n  finalTimeout,\n  childSpanTimeout,\n  latestRoute,\n) {\n  let inflightInteractionSpan;\n  const registerInteractionTransaction = () => {\n    const op = 'ui.action.click';\n\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan && getRootSpan(activeSpan);\n    if (rootSpan) {\n      const currentRootSpanOp = spanToJSON(rootSpan).op;\n      if (['navigation', 'pageload'].includes(currentRootSpanOp )) {\n        DEBUG_BUILD &&\n          logger.warn(`[Tracing] Did not create ${op} span because a pageload or navigation span is in progress.`);\n        return undefined;\n      }\n    }\n\n    if (inflightInteractionSpan) {\n      inflightInteractionSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'interactionInterrupted');\n      inflightInteractionSpan.end();\n      inflightInteractionSpan = undefined;\n    }\n\n    if (!latestRoute.name) {\n      DEBUG_BUILD && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);\n      return undefined;\n    }\n\n    inflightInteractionSpan = startIdleSpan(\n      {\n        name: latestRoute.name,\n        op,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',\n        },\n      },\n      {\n        idleTimeout,\n        finalTimeout,\n        childSpanTimeout,\n      },\n    );\n  };\n\n  if (WINDOW.document) {\n    addEventListener('click', registerInteractionTransaction, { once: false, capture: true });\n  }\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, browserTracingIntegration, getMetaContent, startBrowserTracingNavigationSpan, startBrowserTracingPageLoadSpan };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","import { init as init$1, addEventProcessor } from '@sentry/browser';\nimport { applySdkMetadata, getDomElement } from '@sentry/core';\n\n/**\n * Inits the Svelte SDK\n */\nfunction init(options) {\n  const opts = {\n    ...options,\n  };\n\n  applySdkMetadata(opts, 'svelte');\n\n  const client = init$1(opts);\n\n  detectAndReportSvelteKit();\n\n  return client;\n}\n\n/**\n * Adds a global event processor to detect if the SDK is initialized in a SvelteKit frontend,\n * in which case we add SvelteKit an event.modules entry to outgoing events.\n * SvelteKit detection is performed only once, when the event processor is called for the\n * first time. We cannot perform this check upfront (directly when init is called) because\n * at this time, the HTML element might not yet be accessible.\n */\nfunction detectAndReportSvelteKit() {\n  let detectedSvelteKit = undefined;\n\n  const svelteKitProcessor = event => {\n    if (detectedSvelteKit === undefined) {\n      detectedSvelteKit = isSvelteKitApp();\n    }\n    if (detectedSvelteKit) {\n      event.modules = {\n        svelteKit: 'latest',\n        ...event.modules,\n      };\n    }\n    return event;\n  };\n  svelteKitProcessor.id = 'svelteKitProcessor';\n\n  addEventProcessor(svelteKitProcessor);\n}\n\n/**\n * To actually detect a SvelteKit frontend, we search the DOM for a special\n * div that's inserted by SvelteKit when the page is rendered. It's identified\n * by its id, 'svelte-announcer', and it's used to improve page accessibility.\n * This div is not present when only using Svelte without SvelteKit.\n *\n * @see https://github.com/sveltejs/kit/issues/307 for more information\n */\nfunction isSvelteKitApp() {\n  // eslint-disable-next-line deprecation/deprecation\n  return getDomElement('div#svelte-announcer') !== null;\n}\n\nexport { detectAndReportSvelteKit, init, isSvelteKitApp };\n//# sourceMappingURL=sdk.js.map\n","import { page, navigating } from '$app/stores';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, dropUndefinedKeys } from '@sentry/core';\nimport { browserTracingIntegration as browserTracingIntegration$1, WINDOW, startBrowserTracingPageLoadSpan, getCurrentScope, startBrowserTracingNavigationSpan, startInactiveSpan } from '@sentry/svelte';\n\n/**\n * A custom `BrowserTracing` integration for SvelteKit.\n */\nfunction browserTracingIntegration(\n  options = {},\n) {\n  const integration = {\n    ...browserTracingIntegration$1({\n      ...options,\n      instrumentNavigation: false,\n      instrumentPageLoad: false,\n    }),\n  };\n\n  return {\n    ...integration,\n    afterAllSetup: client => {\n      integration.afterAllSetup(client);\n\n      if (options.instrumentPageLoad !== false) {\n        _instrumentPageload(client);\n      }\n\n      if (options.instrumentNavigation !== false) {\n        _instrumentNavigations(client);\n      }\n    },\n  };\n}\n\nfunction _instrumentPageload(client) {\n  const initialPath = WINDOW && WINDOW.location && WINDOW.location.pathname;\n\n  const pageloadSpan = startBrowserTracingPageLoadSpan(client, {\n    name: initialPath,\n    op: 'pageload',\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.sveltekit',\n      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n    },\n  });\n  if (!pageloadSpan) {\n    return;\n  }\n\n  page.subscribe(page => {\n    if (!page) {\n      return;\n    }\n\n    const routeId = page.route && page.route.id;\n\n    if (routeId) {\n      pageloadSpan.updateName(routeId);\n      pageloadSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');\n      getCurrentScope().setTransactionName(routeId);\n    }\n  });\n}\n\n/**\n * Use the `navigating` store to start a transaction on navigations.\n */\nfunction _instrumentNavigations(client) {\n  let routingSpan;\n\n  navigating.subscribe(navigation => {\n    if (!navigation) {\n      // `navigating` emits a 'null' value when the navigation is completed.\n      // So in this case, we can finish the routing span. If the span was an idle span,\n      // it will finish automatically and if it was user-created users also need to finish it.\n      if (routingSpan) {\n        routingSpan.end();\n        routingSpan = undefined;\n      }\n      return;\n    }\n\n    const from = navigation.from;\n    const to = navigation.to;\n\n    // for the origin we can fall back to window.location.pathname because in this emission, it still is set to the origin path\n    const rawRouteOrigin = (from && from.url.pathname) || (WINDOW && WINDOW.location && WINDOW.location.pathname);\n\n    const rawRouteDestination = to && to.url.pathname;\n\n    // We don't want to create transactions for navigations of same origin and destination.\n    // We need to look at the raw URL here because parameterized routes can still differ in their raw parameters.\n    if (rawRouteOrigin === rawRouteDestination) {\n      return;\n    }\n\n    const parameterizedRouteOrigin = from && from.route.id;\n    const parameterizedRouteDestination = to && to.route.id;\n\n    if (routingSpan) {\n      // If a routing span is still open from a previous navigation, we finish it.\n      // This is important for e.g. redirects when a new navigation root span finishes\n      // the first root span. If we don't `.end()` the previous span, it will get\n      // status 'cancelled' which isn't entirely correct.\n      routingSpan.end();\n    }\n\n    const navigationInfo = dropUndefinedKeys({\n      //  `navigation.type` denotes the origin of the navigation. e.g.:\n      //   - link (clicking on a link)\n      //   - goto (programmatic via goto() or redirect())\n      //   - popstate (back/forward navigation)\n      'sentry.sveltekit.navigation.type': navigation.type,\n      'sentry.sveltekit.navigation.from': parameterizedRouteOrigin || undefined,\n      'sentry.sveltekit.navigation.to': parameterizedRouteDestination || undefined,\n    });\n\n    startBrowserTracingNavigationSpan(client, {\n      name: parameterizedRouteDestination || rawRouteDestination || 'unknown',\n      op: 'navigation',\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.sveltekit',\n        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: parameterizedRouteDestination ? 'route' : 'url',\n        ...navigationInfo,\n      },\n    });\n\n    routingSpan = startInactiveSpan({\n      op: 'ui.sveltekit.routing',\n      name: 'SvelteKit Route Change',\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.sveltekit',\n        ...navigationInfo,\n      },\n      onlyIfParent: true,\n    });\n  });\n}\n\nexport { browserTracingIntegration };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","import { applySdkMetadata } from '@sentry/core';\nimport { init as init$1, getDefaultIntegrations as getDefaultIntegrations$1, WINDOW } from '@sentry/svelte';\nimport { browserTracingIntegration } from './browserTracingIntegration.js';\n\n/**\n * Initialize the client side of the Sentry SvelteKit SDK.\n *\n * @param options Configuration options for the SDK.\n */\nfunction init(options) {\n  const opts = {\n    defaultIntegrations: getDefaultIntegrations(options),\n    ...options,\n  };\n\n  applySdkMetadata(opts, 'sveltekit', ['sveltekit', 'svelte']);\n\n  // 1. Switch window.fetch to our fetch proxy we injected earlier\n  const actualFetch = switchToFetchProxy();\n\n  // 2. Initialize the SDK which will instrument our proxy\n  const client = init$1(opts);\n\n  // 3. Restore the original fetch now that our proxy is instrumented\n  if (actualFetch) {\n    restoreFetch(actualFetch);\n  }\n\n  return client;\n}\n\nfunction getDefaultIntegrations(options) {\n  // This evaluates to true unless __SENTRY_TRACING__ is text-replaced with \"false\",\n  // in which case everything inside will get tree-shaken away\n  if (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n    return [...getDefaultIntegrations$1(options), browserTracingIntegration()];\n  }\n\n  return getDefaultIntegrations$1(options);\n}\n\n/**\n * During server-side page load, we injected a <script> that wraps `window.fetch` so that\n * before a `fetch` call is forwarded to the original `window.fetch`, a function we control\n * is also invoked. This function is put onto the global object (`window._sentryFetchProxy`)\n * so that we can access it here.\n *\n * In this function we briefly set our fetch proxy as `window.fetch` so that the SDK can\n * instrument it.\n *\n * After initializing the SDK, `restoreFetch` must be called to put back whatever was on `window.fetch` before.\n *\n * @see ../server/handle.ts (https://github.com/getsentry/sentry-javascript/blob/8d92180c900c2ac98fd127d53703a415c1f191dd/packages/sveltekit/src/server/handle.ts#L60-L81)\n *\n * @returns the function that was previously on `window.fetch`.\n */\nfunction switchToFetchProxy() {\n  const globalWithSentryFetchProxy = WINDOW ;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const actualFetch = globalWithSentryFetchProxy.fetch;\n\n  if (globalWithSentryFetchProxy._sentryFetchProxy && actualFetch) {\n    globalWithSentryFetchProxy.fetch = globalWithSentryFetchProxy._sentryFetchProxy;\n    return actualFetch;\n  }\n  return undefined;\n}\n\n/**\n * Restores the function @param actualFetch to `window.fetch`\n * and puts our fetch proxy back onto `window._sentryFetchProxy`.\n */\nfunction restoreFetch(actualFetch) {\n  const globalWithSentryFetchProxy = WINDOW ;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  globalWithSentryFetchProxy._sentryFetchProxy = globalWithSentryFetchProxy.fetch;\n  globalWithSentryFetchProxy.fetch = actualFetch;\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","import { consoleSandbox } from '@sentry/core';\nimport { captureException } from '@sentry/svelte';\n\n// The SvelteKit default error handler just logs the error to the console\n// see: https://github.com/sveltejs/kit/blob/369e7d6851f543a40c947e033bfc4a9506fdc0a8/packages/kit/src/core/sync/write_client_manifest.js#LL127C2-L127C2\nfunction defaultErrorHandler({ error }) {\n  consoleSandbox(() => {\n    // eslint-disable-next-line no-console\n    console.error(error);\n  });\n}\n\n/**\n * Wrapper for the SvelteKit error handler that sends the error to Sentry.\n *\n * @param handleError The original SvelteKit error handler.\n */\nfunction handleErrorWithSentry(handleError = defaultErrorHandler) {\n  return (input) => {\n    // SvelteKit 2.0 offers a reliable way to check for a 404 error:\n    if (input.status !== 404) {\n      captureException(input.error, {\n        mechanism: {\n          type: 'sveltekit',\n          handled: false,\n        },\n      });\n    }\n\n    // We're extra cautious with SafeHandleServerErrorInput - this type is not compatible with HandleServerErrorInput\n    // @ts-expect-error - we're still passing the same object, just with a different (backwards-compatible) type\n    return handleError(input);\n  };\n}\n\nexport { handleErrorWithSentry };\n//# sourceMappingURL=handleError.js.map\n","import * as Sentry from '@sentry/sveltekit';\n\nimport { env } from '$env/dynamic/public';\n\nSentry.init({\n\tdsn: env.PUBLIC_SENTRY_DNS_FRONTEND,\n\tenvironment: env.PUBLIC_ENVIRONMENT,\n\t// We recommend adjusting this value in production, or using tracesSampler\n\t// for finer control\n\ttracesSampleRate: parseFloat(env.PUBLIC_SENTRY_TRACES_SAMPLE_RATE)\n\n\t// Optional: Initialize Session Replay only for production environments\n\t// ...(env.PUBLIC_ENVIRONMENT.includes('prod') && {\n\t// \tintegrations: [Sentry.replayIntegration()],\n\t// \treplaysSessionSampleRate: 0.1,\n\t// \treplaysOnErrorSampleRate: 1.0\n\t// })\n});\n\nconst myErrorHandler = ({ error, event }) => {\n\tconsole.error('An error occurred on the client side:', error, event);\n};\n\nexport const handleError = Sentry.handleErrorWithSentry(myErrorHandler);\n\n// or alternatively, if you don't have a custom error handler:\n// export const handleError = handleErrorWithSentry();\n","export const matchers = {};","<!-- This file is generated by @sveltejs/kit — do not edit it! -->\n\n<script>\n\timport { setContext, afterUpdate, onMount, tick } from 'svelte';\n\timport { browser } from '$app/environment';\n\n\t// stores\n\texport let stores;\n\texport let page;\n\t\n\texport let constructors;\n\texport let components = [];\n\texport let form;\n\texport let data_0 = null;\n\texport let data_1 = null;\n\texport let data_2 = null;\n\texport let data_3 = null;\n\n\tif (!browser) {\n\t\tsetContext('__svelte__', stores);\n\t}\n\n\t$: stores.page.set(page);\n\tafterUpdate(stores.page.notify);\n\n\tlet mounted = false;\n\tlet navigated = false;\n\tlet title = null;\n\n\tonMount(() => {\n\t\tconst unsubscribe = stores.page.subscribe(() => {\n\t\t\tif (mounted) {\n\t\t\t\tnavigated = true;\n\t\t\t\ttick().then(() => {\n\t\t\t\t\ttitle = document.title || 'untitled page';\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\tmounted = true;\n\t\treturn unsubscribe;\n\t});\n\n\t\n</script>\n\n{#if constructors[1]}\n\t<svelte:component this={constructors[0]} bind:this={components[0]} data={data_0}>\n\t\t\t\t\t\t{#if constructors[2]}\n\t\t\t\t\t\t\t<svelte:component this={constructors[1]} bind:this={components[1]} data={data_1}>\n\t\t\t\t\t\t\t\t\t\t\t\t{#if constructors[3]}\n\t\t\t\t\t\t\t\t\t\t\t\t\t<svelte:component this={constructors[2]} bind:this={components[2]} data={data_2}>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<svelte:component this={constructors[3]} bind:this={components[3]} data={data_3} {form} />\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</svelte:component>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t{:else}\n\t\t\t\t\t\t\t\t\t\t\t\t\t<svelte:component this={constructors[2]} bind:this={components[2]} data={data_2} {form} />\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t{/if}\n\t\t\t\t\t\t\t\t\t\t\t</svelte:component>\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t{:else}\n\t\t\t\t\t\t\t<svelte:component this={constructors[1]} bind:this={components[1]} data={data_1} {form} />\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t{/if}\n\t\t\t\t\t</svelte:component>\n\t\n{:else}\n\t<svelte:component this={constructors[0]} bind:this={components[0]} data={data_0} {form} />\n\t\n{/if}\n\n{#if mounted}\n\t<div id=\"svelte-announcer\" aria-live=\"assertive\" aria-atomic=\"true\" style=\"position: absolute; left: 0; top: 0; clip: rect(0 0 0 0); clip-path: inset(50%); overflow: hidden; white-space: nowrap; width: 1px; height: 1px\">\n\t\t{#if navigated}\n\t\t\t{title}\n\t\t{/if}\n\t</div>\n{/if}","import * as client_hooks from '../../../src/hooks.client.ts';\n\n\nexport { matchers } from './matchers.js';\n\nexport const nodes = [\n\t() => import('./nodes/0'),\n\t() => import('./nodes/1'),\n\t() => import('./nodes/2'),\n\t() => import('./nodes/3'),\n\t() => import('./nodes/4'),\n\t() => import('./nodes/5'),\n\t() => import('./nodes/6'),\n\t() => import('./nodes/7'),\n\t() => import('./nodes/8'),\n\t() => import('./nodes/9'),\n\t() => import('./nodes/10'),\n\t() => import('./nodes/11'),\n\t() => import('./nodes/12'),\n\t() => import('./nodes/13'),\n\t() => import('./nodes/14'),\n\t() => import('./nodes/15'),\n\t() => import('./nodes/16'),\n\t() => import('./nodes/17'),\n\t() => import('./nodes/18'),\n\t() => import('./nodes/19'),\n\t() => import('./nodes/20'),\n\t() => import('./nodes/21'),\n\t() => import('./nodes/22'),\n\t() => import('./nodes/23'),\n\t() => import('./nodes/24'),\n\t() => import('./nodes/25'),\n\t() => import('./nodes/26'),\n\t() => import('./nodes/27'),\n\t() => import('./nodes/28'),\n\t() => import('./nodes/29'),\n\t() => import('./nodes/30'),\n\t() => import('./nodes/31'),\n\t() => import('./nodes/32'),\n\t() => import('./nodes/33'),\n\t() => import('./nodes/34'),\n\t() => import('./nodes/35'),\n\t() => import('./nodes/36'),\n\t() => import('./nodes/37'),\n\t() => import('./nodes/38'),\n\t() => import('./nodes/39'),\n\t() => import('./nodes/40'),\n\t() => import('./nodes/41'),\n\t() => import('./nodes/42'),\n\t() => import('./nodes/43'),\n\t() => import('./nodes/44'),\n\t() => import('./nodes/45'),\n\t() => import('./nodes/46'),\n\t() => import('./nodes/47'),\n\t() => import('./nodes/48'),\n\t() => import('./nodes/49'),\n\t() => import('./nodes/50'),\n\t() => import('./nodes/51'),\n\t() => import('./nodes/52'),\n\t() => import('./nodes/53')\n];\n\nexport const server_loads = [];\n\nexport const dictionary = {\n\t\t\"/(app)\": [8,[2]],\n\t\t\"/(app)/admin\": [9,[2,3]],\n\t\t\"/(app)/admin/settings\": [10,[2,3]],\n\t\t\"/(app)/assistants\": [11,[2,4]],\n\t\t\"/auth\": [50],\n\t\t\"/auth/reset-password\": [51],\n\t\t\"/(app)/connections\": [14,[2]],\n\t\t\"/(app)/c\": [12,[2]],\n\t\t\"/(app)/c/[id]\": [13,[2,5]],\n\t\t\"/(app)/dashboard\": [15,[2]],\n\t\t\"/error\": [52],\n\t\t\"/(app)/quick_actions\": [16,[2,6]],\n\t\t\"/s/[id]\": [53],\n\t\t\"/(app)/tutorials\": [17,[2]],\n\t\t\"/(app)/workers\": [18,[2]],\n\t\t\"/(app)/workers/[id]\": [19,[2]],\n\t\t\"/(app)/workspace\": [20,[2,7]],\n\t\t\"/(app)/workspace/documents\": [21,[2,7]],\n\t\t\"/(app)/workspace/models\": [22,[2,7]],\n\t\t\"/(app)/workspace/models/create\": [23,[2,7]],\n\t\t\"/(app)/workspace/models/edit\": [24,[2,7]],\n\t\t\"/(app)/workspace/modules\": [25,[2,7]],\n\t\t\"/(app)/workspace/modules/create\": [26,[2,7]],\n\t\t\"/(app)/workspace/modules/edit\": [27,[2,7]],\n\t\t\"/(app)/workspace/playground\": [28,[2,7]],\n\t\t\"/(app)/workspace/prompts\": [29,[2,7]],\n\t\t\"/(app)/workspace/prompts/create\": [30,[2,7]],\n\t\t\"/(app)/workspace/prompts/edit\": [31,[2,7]],\n\t\t\"/(app)/workspace/quick-action-categories\": [32,[2,7]],\n\t\t\"/(app)/workspace/quick-action-categories/create\": [33,[2,7]],\n\t\t\"/(app)/workspace/quick-action-categories/edit\": [34,[2,7]],\n\t\t\"/(app)/workspace/quick-actions\": [35,[2,7]],\n\t\t\"/(app)/workspace/quick-actions/create\": [36,[2,7]],\n\t\t\"/(app)/workspace/quick-actions/edit\": [37,[2,7]],\n\t\t\"/(app)/workspace/smart-contexts\": [38,[2,7]],\n\t\t\"/(app)/workspace/smart-contexts/create\": [39,[2,7]],\n\t\t\"/(app)/workspace/smart-contexts/edit\": [40,[2,7]],\n\t\t\"/(app)/workspace/tools\": [41,[2,7]],\n\t\t\"/(app)/workspace/tools/create\": [42,[2,7]],\n\t\t\"/(app)/workspace/tools/edit\": [43,[2,7]],\n\t\t\"/(app)/workspace/tutorials\": [44,[2,7]],\n\t\t\"/(app)/workspace/tutorials/create\": [45,[2,7]],\n\t\t\"/(app)/workspace/tutorials/edit\": [46,[2,7]],\n\t\t\"/(app)/workspace/workers\": [47,[2,7]],\n\t\t\"/(app)/workspace/workers/create\": [48,[2,7]],\n\t\t\"/(app)/workspace/workers/edit\": [49,[2,7]]\n\t};\n\nexport const hooks = {\n\thandleError: client_hooks.handleError || (({ error }) => { console.error(error) }),\n\n\treroute: (() => {})\n};\n\nexport { default as root } from '../root.svelte';"],"file":"_app/immutable/entry/app.DDSvtd-Y.js"}