{"version":3,"file":"datadog.js","mappings":"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","sources":["webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/globalObject.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/queueMicrotask.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://market-storefront/./node_modules/@envato/cookiebot-wrapper/node_modules/js-cookie/src/js.cookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/connectivity/connectivity.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack://market-storefront/./node_modules/@envato/cookiebot-wrapper/dist/index.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/intakeSites.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/timer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/utils/longTaskRegistry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/profilingCorrelation.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/utils/getDefaultViewName.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/utils/getCustomOrDefaultViewName.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/transport/buildProfileEventAttributes.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/transport/assembly.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/profiler.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/utils/getNumberOfSamples.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/requestIdleCallback.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/handlingStack.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/abstractHooks.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/flushController.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/bufferedData.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/encoder.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/defineContextMethod.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/contextConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/displayAlreadyInitializedError.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/rawRumEvent.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/vital/vitalCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/plugins.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/storeContextManager.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/contextManager.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/contextUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/contexts/globalContext.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/contexts/userContext.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/contexts/accountContext.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionStoreStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStateValidation.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/extension/extensionUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/allowedTrackingOrigins.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/sampler/sampler.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/identifier.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/configuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/jsonPathParser.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/remoteConfiguration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/preStartRum.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/resourceUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/discardNegativeDuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/firstInputPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/performanceObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/actionNameConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/getSelectorFromElement.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/privacyConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/privacy.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/clickChain.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/getActionNameFromElement.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/listenActionEvents.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/computeFrustration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/interactionSelectorCache.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/trackClickActions.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/actionCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/error/errorCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/error/trackConsoleError.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/error/trackReportError.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/taskQueue.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/matchRequestResourceEntry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/performanceUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/retrieveInitialDocumentResourceTiming.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/requestRegistry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/graphql.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/timezone.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstContentfulPaint.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackNavigationTimings.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLargestContentfulPaint.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstHidden.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInitialViewMetrics.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstInput.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/getClsAttributionImpactedArea.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCumulativeLayoutShift.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/interactionCountPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInteractionToNextPaint.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/scroll.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/viewportObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackScrollMetrics.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCommonViewMetrics.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLoadingTime.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackBfcacheMetrics.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/trackViews.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/trackViewEventCounts.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/bfCacheSupport.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/urlContexts.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/featureFlagContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/startCustomerDataTelemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/pageStateHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/cookieObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/ciVisibilityContext.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/eventRateLimiter/createEventRateLimiter.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/limitModification.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/hooks.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/event/eventCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/windowOpenObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/defaultContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/sessionContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/connectivityContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/trackingConsentContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/displayContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/startInitialViewMetricsTelemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/longAnimationFrame/longAnimationFrameCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/longTask/longTaskCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/internalContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/getSessionReplayUrl.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/formDataTransport.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/trackingConsent.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/computeStackTrace.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMove.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMouseInteraction.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackScroll.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewportResize.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMediaInteraction.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackStyleSheet.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFocus.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFrustration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewEnd.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationStats.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeDocument.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackInput.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMutation.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationScope.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/nodeIds.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/startFullSnapshots.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/recordIds.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/startRecordBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startSegmentTelemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/pageMayExitObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/tags.js","webpack://market-storefront/webpack/bootstrap","webpack://market-storefront/webpack/runtime/define property getters","webpack://market-storefront/webpack/runtime/hasOwnProperty shorthand","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateEncoder.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/scriptLoadingError.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateWorker.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/isBrowserSupported.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/getSessionReplayLink.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/postStartStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/startRecorderInitTelemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/lazyLoadRecorder.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/lazyLoadProfiler.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/preStartStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/profilerApi.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/profilingContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/profilingSupported.js","webpack://market-storefront/./app/javascript/utils/consent.js","webpack://market-storefront/./app/javascript/packs/datadog.js"],"sourcesContent":["/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject() {\n    if (typeof globalThis === 'object') {\n        return globalThis;\n    }\n    Object.defineProperty(Object.prototype, '_dd_temp_', {\n        get() {\n            return this;\n        },\n        configurable: true,\n    });\n    // @ts-ignore _dd_temp is defined using defineProperty\n    let globalObject = _dd_temp_;\n    // @ts-ignore _dd_temp is defined using defineProperty\n    delete Object.prototype._dd_temp_;\n    if (typeof globalObject !== 'object') {\n        // on safari _dd_temp_ is available on window but not globally\n        // fallback on other browser globals check\n        if (typeof self === 'object') {\n            globalObject = self;\n        }\n        else if (typeof window === 'object') {\n            globalObject = window;\n        }\n        else {\n            globalObject = {};\n        }\n    }\n    return globalObject;\n}\n/**\n * Cached reference to the global object so it can be imported and re-used without\n * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.\n */\n// eslint-disable-next-line local-rules/disallow-side-effects\nexport const globalObject = getGlobalObject();\nexport const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject;\n//# sourceMappingURL=globalObject.js.map","export const MAX_STATS_HISTORY = 1000;\nlet statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    let replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    const toDelete = statsPerView.keys().next().value;\n    if (toDelete) {\n        statsPerView.delete(toDelete);\n    }\n}\n//# sourceMappingURL=replayStats.js.map","import { monitor } from './monitor';\nimport { globalObject } from './globalObject';\nexport function queueMicrotask(callback) {\n    var _a;\n    const nativeImplementation = (_a = globalObject.queueMicrotask) === null || _a === void 0 ? void 0 : _a.bind(globalObject);\n    if (typeof nativeImplementation === 'function') {\n        nativeImplementation(monitor(callback));\n    }\n    else {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- the callback is monitored, so it'll never throw\n        Promise.resolve().then(monitor(callback));\n    }\n}\n//# sourceMappingURL=queueMicrotask.js.map","import { queueMicrotask } from './queueMicrotask';\n// eslint-disable-next-line no-restricted-syntax\nexport class Observable {\n    constructor(onFirstSubscribe) {\n        this.onFirstSubscribe = onFirstSubscribe;\n        this.observers = [];\n    }\n    subscribe(observer) {\n        this.addObserver(observer);\n        return {\n            unsubscribe: () => this.removeObserver(observer),\n        };\n    }\n    notify(data) {\n        this.observers.forEach((observer) => observer(data));\n    }\n    addObserver(observer) {\n        this.observers.push(observer);\n        if (this.observers.length === 1 && this.onFirstSubscribe) {\n            this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined;\n        }\n    }\n    removeObserver(observer) {\n        this.observers = this.observers.filter((other) => observer !== other);\n        if (!this.observers.length && this.onLastUnsubscribe) {\n            this.onLastUnsubscribe();\n        }\n    }\n}\nexport function mergeObservables(...observables) {\n    return new Observable((globalObservable) => {\n        const subscriptions = observables.map((observable) => observable.subscribe((data) => globalObservable.notify(data)));\n        return () => subscriptions.forEach((subscription) => subscription.unsubscribe());\n    });\n}\n// eslint-disable-next-line no-restricted-syntax\nexport class BufferedObservable extends Observable {\n    constructor(maxBufferSize) {\n        super();\n        this.maxBufferSize = maxBufferSize;\n        this.buffer = [];\n    }\n    notify(data) {\n        this.buffer.push(data);\n        if (this.buffer.length > this.maxBufferSize) {\n            this.buffer.shift();\n        }\n        super.notify(data);\n    }\n    subscribe(observer) {\n        let closed = false;\n        const subscription = {\n            unsubscribe: () => {\n                closed = true;\n                this.removeObserver(observer);\n            },\n        };\n        queueMicrotask(() => {\n            for (const data of this.buffer) {\n                if (closed) {\n                    return;\n                }\n                observer(data);\n            }\n            if (!closed) {\n                this.addObserver(observer);\n            }\n        });\n        return subscription;\n    }\n    /**\n     * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not\n     * needed anymore. This can be seen as a performance optimization, and things will work probably\n     * even if this method isn't called, but still useful to clarify our intent and lowering our\n     * memory impact.\n     */\n    unbuffer() {\n        queueMicrotask(() => {\n            this.maxBufferSize = this.buffer.length = 0;\n        });\n    }\n}\n//# sourceMappingURL=observable.js.map","/*!\n * JavaScript Cookie v2.2.1\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader;\n\tif (typeof define === 'function' && define.amd) {\n\t\tdefine(factory);\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (typeof exports === 'object') {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction decode (s) {\n\t\treturn s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api() {}\n\n\t\tfunction set (key, value, attributes) {\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tattributes = extend({\n\t\t\t\tpath: '/'\n\t\t\t}, api.defaults, attributes);\n\n\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\tattributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5);\n\t\t\t}\n\n\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\ttry {\n\t\t\t\tvar result = JSON.stringify(value);\n\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\tvalue = result;\n\t\t\t\t}\n\t\t\t} catch (e) {}\n\n\t\t\tvalue = converter.write ?\n\t\t\t\tconverter.write(value, key) :\n\t\t\t\tencodeURIComponent(String(value))\n\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\n\t\t\tkey = encodeURIComponent(String(key))\n\t\t\t\t.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent)\n\t\t\t\t.replace(/[\\(\\)]/g, escape);\n\n\t\t\tvar stringifiedAttributes = '';\n\t\t\tfor (var attributeName in attributes) {\n\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Considers RFC 6265 section 5.2:\n\t\t\t\t// ...\n\t\t\t\t// 3.  If the remaining unparsed-attributes contains a %x3B (\";\")\n\t\t\t\t//     character:\n\t\t\t\t// Consume the characters of the unparsed-attributes up to,\n\t\t\t\t// not including, the first %x3B (\";\") character.\n\t\t\t\t// ...\n\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName].split(';')[0];\n\t\t\t}\n\n\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t}\n\n\t\tfunction get (key, json) {\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar jar = {};\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all.\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (!json && cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = decode(parts[0]);\n\t\t\t\t\tcookie = (converter.read || converter)(cookie, name) ||\n\t\t\t\t\t\tdecode(cookie);\n\n\t\t\t\t\tif (json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tjar[name] = cookie;\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn key ? jar[key] : jar;\n\t\t}\n\n\t\tapi.set = set;\n\t\tapi.get = function (key) {\n\t\t\treturn get(key, false /* read as raw */);\n\t\t};\n\t\tapi.getJSON = function (key) {\n\t\t\treturn get(key, true /* read as json */);\n\t\t};\n\t\tapi.remove = function (key, attributes) {\n\t\t\tset(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.defaults = {};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n","import { monitor } from '../tools/monitor';\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\n/**\n * Add an event listener to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n */\nexport function addEventListener(configuration, eventTarget, eventName, listener, options) {\n    return addEventListeners(configuration, eventTarget, [eventName], listener, options);\n}\n/**\n * Add event listeners to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n *\n * * with `once: true`, the listener will be called at most once, even if different events are listened\n */\nexport function addEventListeners(configuration, eventTarget, eventNames, listener, { once, capture, passive } = {}) {\n    const listenerWithMonitor = monitor((event) => {\n        if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {\n            return;\n        }\n        if (once) {\n            stop();\n        }\n        listener(event);\n    });\n    const options = passive ? { capture, passive } : capture;\n    // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)\n    const listenerTarget = window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget;\n    const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener');\n    eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options));\n    function stop() {\n        const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener');\n        eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options));\n    }\n    return {\n        stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","import { globalObject } from '../../tools/globalObject';\nexport function getConnectivity() {\n    var _a;\n    const navigator = globalObject.navigator;\n    return {\n        status: navigator.onLine ? 'connected' : 'not_connected',\n        interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,\n        effective_type: (_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType,\n    };\n}\n//# sourceMappingURL=connectivity.js.map","import { noop } from '../tools/utils/functionUtils';\nimport { addEventListener } from './addEventListener';\nexport function runOnReadyState(configuration, expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n        return { stop: noop };\n    }\n    const eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n    return addEventListener(configuration, window, eventName, callback, { once: true });\n}\nexport function asyncRunOnReadyState(configuration, expectedReadyState) {\n    return new Promise((resolve) => {\n        runOnReadyState(configuration, expectedReadyState, resolve);\n    });\n}\n//# sourceMappingURL=runOnReadyState.js.map","/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value) {\n    if (value === null) {\n        return 'null';\n    }\n    if (Array.isArray(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n//# sourceMappingURL=typeUtils.js.map","export function isServerError(status) {\n    return status >= 500;\n}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (_a) {\n        // clone can throw if the response has already been used by another instrumentation or is disturbed\n        return;\n    }\n}\n//# sourceMappingURL=responseUtils.js.map","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || (function () {\n    var ownKeys = function(o) {\n        ownKeys = Object.getOwnPropertyNames || function (o) {\n            var ar = [];\n            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n            return ar;\n        };\n        return ownKeys(o);\n    };\n    return function (mod) {\n        if (mod && mod.__esModule) return mod;\n        var result = {};\n        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n        __setModuleDefault(result, mod);\n        return result;\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.userHasOptedOutOfCookiesForCategory = exports.consented = exports.checkCookieConsent = exports.deferRun = exports.Consent = void 0;\nvar Cookies = __importStar(require(\"js-cookie\"));\nvar queue = [];\nvar Consent;\n(function (Consent) {\n    Consent[\"statistics\"] = \"statistics\";\n    Consent[\"marketing\"] = \"marketing\";\n    Consent[\"necessary\"] = \"necessary\";\n    Consent[\"preferences\"] = \"preferences\";\n})(Consent || (exports.Consent = Consent = {}));\nvar execute = function () {\n    while (queue.length) {\n        var cookiebotJob = queue.shift();\n        if (cookiebotJob) {\n            var job = cookiebotJob.job, consent = cookiebotJob.consent;\n            // what to do if Cookiebot fail to load or blocked?\n            if ((0, exports.consented)(consent)) {\n                job();\n            }\n        }\n    }\n};\nvar deferRun = function (job, consent) {\n    if (typeof window !== 'undefined') {\n        queue.push({ job: job, consent: consent });\n        if (window.Cookiebot && window.Cookiebot.hasResponse) {\n            execute();\n        }\n    }\n};\nexports.deferRun = deferRun;\nif (typeof window !== 'undefined') {\n    window.addEventListener('CookiebotOnAccept', function () {\n        execute();\n    }, false);\n}\nvar checkCookieConsent = function (CookieString, consent) {\n    if (!CookieString) {\n        return false;\n    }\n    // For user outside of targeted area\n    if (CookieString === '-1') {\n        return true;\n    }\n    try {\n        var parsedCookieConsent = JSON.parse(CookieString.replace(/%2c/g, ',')\n            .replace(/'/g, '\"')\n            .replace(/([{\\[,])\\s*([a-zA-Z0-9_]+?):/g, '$1\"$2\":'));\n        return parsedCookieConsent && !!parsedCookieConsent[consent];\n    }\n    catch (e) {\n        return false;\n    }\n};\nexports.checkCookieConsent = checkCookieConsent;\nvar consented = function (consent) {\n    if (!(typeof window !== 'undefined')) {\n        return false;\n    }\n    // when cookiebot is avaiable use it\n    if (!!(window && window.Cookiebot && window.Cookiebot.consent)) {\n        return !!window.Cookiebot.consent[consent];\n    }\n    // manually parse cookie if Cookiebot is not avaiable\n    var CookieConsent = Cookies.get('CookieConsent');\n    return (0, exports.checkCookieConsent)(CookieConsent, consent);\n};\nexports.consented = consented;\nvar userHasOptedOutOfCookiesForCategory = function (consent) {\n    if (!(typeof window !== 'undefined')) {\n        return false;\n    }\n    // when cookiebot is avaiable\n    if (!!(window && window.Cookiebot && window.Cookiebot.consent)) {\n        if (window.Cookiebot.hasResponse) {\n            return !window.Cookiebot.consent[consent];\n        }\n        else {\n            return false;\n        }\n    }\n    // manually parse cookie if Cookiebot is not avaiable\n    var CookieConsent = Cookies.get('CookieConsent');\n    if (!CookieConsent) {\n        return false;\n    }\n    // For user outside of targeted area\n    if (CookieConsent === '-1') {\n        return false;\n    }\n    try {\n        var parsedCookieConsent = JSON.parse(CookieConsent.replace(/%2c/g, ',')\n            .replace(/'/g, '\"')\n            .replace(/([{\\[,])\\s*([a-zA-Z0-9_]+?):/g, '$1\"$2\":'));\n        return parsedCookieConsent && !parsedCookieConsent[consent];\n    }\n    catch (e) {\n        return false;\n    }\n};\nexports.userHasOptedOutOfCookiesForCategory = userHasOptedOutOfCookiesForCategory;\n//# sourceMappingURL=index.js.map","import { display } from './display';\nlet onMonitorErrorCollected;\nlet debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n    onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n    debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n    onMonitorErrorCollected = undefined;\n    debugMode = false;\n}\nexport function monitored(_, __, descriptor) {\n    const originalMethod = descriptor.value;\n    descriptor.value = function (...args) {\n        const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        monitorError(e);\n    }\n}\nexport function monitorError(e) {\n    displayIfDebugEnabled(e);\n    if (onMonitorErrorCollected) {\n        try {\n            onMonitorErrorCollected(e);\n        }\n        catch (e) {\n            displayIfDebugEnabled(e);\n        }\n    }\n}\nexport function displayIfDebugEnabled(...args) {\n    if (debugMode) {\n        display.error('[MONITOR]', ...args);\n    }\n}\n//# sourceMappingURL=monitor.js.map","/* eslint-disable local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport const ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\n/**\n * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove\n * \"console.*\" references. This causes some issue as we expect `console.*` to be defined.\n * As a workaround, let's use a variable alias, so those expressions won't be taken into account by\n * simple static analysis.\n *\n * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/\n * [2]: https://github.com/terser/terser#compress-options (look for drop_console)\n */\nexport const globalConsole = console;\nexport const originalConsoleMethods = {};\nObject.keys(ConsoleApiName).forEach((name) => {\n    originalConsoleMethods[name] = globalConsole[name];\n});\nconst PREFIX = 'Datadog Browser SDK:';\nexport const display = {\n    debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),\n    log: originalConsoleMethods.log.bind(globalConsole, PREFIX),\n    info: originalConsoleMethods.info.bind(globalConsole, PREFIX),\n    warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),\n    error: originalConsoleMethods.error.bind(globalConsole, PREFIX),\n};\nexport const DOCS_ORIGIN = 'https://docs.datadoghq.com';\nexport const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`;\nexport const MORE_DETAILS = 'More details:';\n//# sourceMappingURL=display.js.map","import { globalObject } from './globalObject';\nexport function sendToExtension(type, payload) {\n    const callback = globalObject.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type, payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.js.map","export const INTAKE_SITE_STAGING = 'datad0g.com';\nexport const INTAKE_SITE_FED_STAGING = 'dd0g-gov.com';\nexport const INTAKE_SITE_US1 = 'datadoghq.com';\nexport const INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport const INTAKE_SITE_US1_FED = 'ddog-gov.com';\nexport const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com';\nexport const INTAKE_URL_PARAMETERS = ['ddsource', 'dd-api-key', 'dd-request-id'];\n//# sourceMappingURL=intakeSites.js.map","import { display } from '../display';\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { detachToJsonMethod } from './jsonStringify';\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nconst SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nconst JSON_PATH_ROOT_ELEMENT = '$';\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nconst KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {\n    // Unbind any toJSON function we may have on [] or {} prototypes\n    const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    const containerQueue = [];\n    const visitedObjectsWithPath = new WeakMap();\n    const sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n    const serializedSanitizedData = JSON.stringify(sanitizedData);\n    let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0;\n    if (accumulatedCharacterCount > maxCharacterCount) {\n        warnOverCharacterLimit(maxCharacterCount, 'discarded', source);\n        return undefined;\n    }\n    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n        const containerToProcess = containerQueue.shift();\n        let separatorLength = 0; // 0 for the first element, 1 for subsequent elements\n        // Arrays and Objects have to be handled distinctly to ensure\n        // we do not pick up non-numerical properties from Arrays\n        if (Array.isArray(containerToProcess.source)) {\n            for (let key = 0; key < containerToProcess.source.length; key++) {\n                const targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                if (targetData !== undefined) {\n                    accumulatedCharacterCount += JSON.stringify(targetData).length;\n                }\n                else {\n                    // When an element of an Array (targetData) is undefined, it is serialized as null:\n                    // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n                    accumulatedCharacterCount += 4;\n                }\n                accumulatedCharacterCount += separatorLength;\n                separatorLength = 1;\n                if (accumulatedCharacterCount > maxCharacterCount) {\n                    warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                    break;\n                }\n                ;\n                containerToProcess.target[key] = targetData;\n            }\n        }\n        else {\n            for (const key in containerToProcess.source) {\n                if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n                    const targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                    // When a property of an object has an undefined value, it will be dropped during serialization:\n                    // JSON.stringify({a:undefined}) => '{}'\n                    if (targetData !== undefined) {\n                        accumulatedCharacterCount +=\n                            JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;\n                        separatorLength = 1;\n                    }\n                    if (accumulatedCharacterCount > maxCharacterCount) {\n                        warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                        break;\n                    }\n                    ;\n                    containerToProcess.target[key] = targetData;\n                }\n            }\n        }\n    }\n    // Rebind detached toJSON functions\n    restoreObjectPrototypeToJson();\n    restoreArrayPrototypeToJson();\n    return sanitizedData;\n}\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {\n    // Start by handling toJSON, as we want to sanitize its output\n    const sourceToSanitize = tryToApplyToJSON(source);\n    if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n        return sanitizePrimitivesAndFunctions(sourceToSanitize);\n    }\n    const sanitizedSource = sanitizeObjects(sourceToSanitize);\n    if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n        return sanitizedSource;\n    }\n    // Handle potential cyclic references\n    // We need to use source as sourceToSanitize could be a reference to a new object\n    // At this stage, we know the source is an object type\n    const sourceAsObject = source;\n    if (visitedObjectsWithPath.has(sourceAsObject)) {\n        return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)}]`;\n    }\n    // Add processed source to queue\n    const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath;\n    const target = Array.isArray(sourceToSanitize) ? [] : {};\n    visitedObjectsWithPath.set(sourceAsObject, currentPath);\n    queue.push({ source: sourceToSanitize, target, path: currentPath });\n    return target;\n}\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value) {\n    // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n    if (typeof value === 'bigint') {\n        return `[BigInt] ${value.toString()}`;\n    }\n    // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n    // so it won't prevent stringify from serializing later\n    if (typeof value === 'function') {\n        return `[Function] ${value.name || 'unknown'}`;\n    }\n    // JSON.stringify() does not serialize symbols.\n    if (typeof value === 'symbol') {\n        return `[Symbol] ${value.description || value.toString()}`;\n    }\n    return value;\n}\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n */\nfunction sanitizeObjects(value) {\n    try {\n        if (value instanceof Event) {\n            return sanitizeEvent(value);\n        }\n        if (value instanceof RegExp) {\n            return `[RegExp] ${value.toString()}`;\n        }\n        // Handle all remaining object types in a generic way\n        const result = Object.prototype.toString.call(value);\n        const match = result.match(/\\[object (.*)\\]/);\n        if (match && match[1]) {\n            return `[${match[1]}]`;\n        }\n    }\n    catch (_a) {\n        // If the previous serialization attempts failed, and we cannot convert using\n        // Object.prototype.toString, declare the value unserializable\n    }\n    return '[Unserializable]';\n}\nfunction sanitizeEvent(event) {\n    return {\n        type: event.type,\n        isTrusted: event.isTrusted,\n        currentTarget: event.currentTarget ? sanitizeObjects(event.currentTarget) : null,\n        target: event.target ? sanitizeObjects(event.target) : null,\n    };\n}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n    const object = value;\n    if (object && typeof object.toJSON === 'function') {\n        try {\n            return object.toJSON();\n        }\n        catch (_a) {\n            // If toJSON fails, we continue by trying to serialize the value manually\n        }\n    }\n    return value;\n}\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount, changeType, source) {\n    display.warn(`The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`, source);\n}\n//# sourceMappingURL=sanitize.js.map","import { setTimeout, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n    const needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    let inWaitPeriod = false;\n    let pendingExecutionWithParameters;\n    let pendingTimeoutId;\n    return {\n        throttled: (...parameters) => {\n            if (inWaitPeriod) {\n                pendingExecutionWithParameters = parameters;\n                return;\n            }\n            if (needLeadingExecution) {\n                fn(...parameters);\n            }\n            else {\n                pendingExecutionWithParameters = parameters;\n            }\n            inWaitPeriod = true;\n            pendingTimeoutId = setTimeout(() => {\n                if (needTrailingExecution && pendingExecutionWithParameters) {\n                    fn(...pendingExecutionWithParameters);\n                }\n                inWaitPeriod = false;\n                pendingExecutionWithParameters = undefined;\n            }, wait);\n        },\n        cancel: () => {\n            clearTimeout(pendingTimeoutId);\n            inWaitPeriod = false;\n            pendingExecutionWithParameters = undefined;\n        },\n    };\n}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() { }\n//# sourceMappingURL=functionUtils.js.map","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';\nimport { monitor } from './monitor';\nimport { getGlobalObject } from './globalObject';\nexport function setTimeout(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay);\n}\nexport function clearTimeout(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);\n}\nexport function setInterval(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId);\n}\n//# sourceMappingURL=timer.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nimport { createHandlingStack } from './stackTrace/handlingStack';\n/**\n * Instruments a method on a object, calling the given callback before the original method is\n * invoked. The callback receives an object with information about the method call.\n *\n * This function makes sure that we are \"good citizens\" regarding third party instrumentations: when\n * removing the instrumentation, the original method is usually restored, but if a third party\n * instrumentation was set after ours, we keep it in place and just replace our instrumentation with\n * a noop.\n *\n * Note: it is generally better to instrument methods that are \"owned\" by the object instead of ones\n * that are inherited from the prototype chain. Example:\n * * do:    `instrumentMethod(Array.prototype, 'push', ...)`\n * * don't: `instrumentMethod([], 'push', ...)`\n *\n * This method is also used to set event handler properties (ex: window.onerror = ...), as it has\n * the same requirements as instrumenting a method:\n * * if the event handler is already set by a third party, we need to call it and not just blindly\n * override it.\n * * if the event handler is set by a third party after us, we need to keep it in place when\n * removing ours.\n *\n * @example\n *\n *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {\n *    console.log('Before calling fetch on', target, 'with parameters', parameters)\n *\n *    onPostCall((result) => {\n *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)\n *    })\n *  })\n */\nexport function instrumentMethod(targetPrototype, method, onPreCall, { computeHandlingStack } = {}) {\n    let original = targetPrototype[method];\n    if (typeof original !== 'function') {\n        if (method in targetPrototype && method.startsWith('on')) {\n            original = noop;\n        }\n        else {\n            return { stop: noop };\n        }\n    }\n    let stopped = false;\n    const instrumentation = function () {\n        if (stopped) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n            return original.apply(this, arguments);\n        }\n        const parameters = Array.from(arguments);\n        let postCallCallback;\n        callMonitored(onPreCall, null, [\n            {\n                target: this,\n                parameters,\n                onPostCall: (callback) => {\n                    postCallCallback = callback;\n                },\n                handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,\n            },\n        ]);\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        const result = original.apply(this, parameters);\n        if (postCallCallback) {\n            callMonitored(postCallCallback, null, [result]);\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return result;\n    };\n    targetPrototype[method] = instrumentation;\n    return {\n        stop: () => {\n            stopped = true;\n            // If the instrumentation has been removed by a third party, keep the last one\n            if (targetPrototype[method] === instrumentation) {\n                targetPrototype[method] = original;\n            }\n        },\n    };\n}\nexport function instrumentSetter(targetPrototype, property, after) {\n    const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    const stoppedInstrumentation = noop;\n    let instrumentation = (target, value) => {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(() => {\n            if (instrumentation !== stoppedInstrumentation) {\n                after(target, value);\n            }\n        }, 0);\n    };\n    const instrumentationWrapper = function (value) {\n        originalDescriptor.set.call(this, value);\n        instrumentation(this, value);\n    };\n    Object.defineProperty(targetPrototype, property, {\n        set: instrumentationWrapper,\n    });\n    return {\n        stop: () => {\n            var _a;\n            if (((_a = Object.getOwnPropertyDescriptor(targetPrototype, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n                Object.defineProperty(targetPrototype, property, originalDescriptor);\n            }\n            instrumentation = stoppedInstrumentation;\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { sanitize } from '../../tools/serialisation/sanitize';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nexport const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError({ stackTrace, originalError, handlingStack, componentStack, startClocks, nonErrorPrefix, useFallbackStack = true, source, handling, }) {\n    const isErrorInstance = isError(originalError);\n    if (!stackTrace && isErrorInstance) {\n        stackTrace = computeStackTrace(originalError);\n    }\n    return {\n        startClocks,\n        source,\n        handling,\n        handlingStack,\n        componentStack,\n        originalError,\n        type: stackTrace ? stackTrace.name : undefined,\n        message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),\n        stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,\n        causes: isErrorInstance ? flattenErrorCauses(originalError, source) : undefined,\n        fingerprint: tryToGetFingerprint(originalError),\n        context: tryToGetErrorContext(originalError),\n    };\n}\nfunction computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {\n    // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n    // TODO rework tracekit integration to avoid scattering error building logic\n    return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name)\n        ? stackTrace.message\n        : !isErrorInstance\n            ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))}`\n            : 'Empty message';\n}\nexport function tryToGetFingerprint(originalError) {\n    return isError(originalError) && 'dd_fingerprint' in originalError ? String(originalError.dd_fingerprint) : undefined;\n}\nexport function tryToGetErrorContext(originalError) {\n    if (originalError !== null && typeof originalError === 'object' && 'dd_context' in originalError) {\n        return originalError.dd_context;\n    }\n}\nexport function getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function isError(error) {\n    return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]';\n}\nexport function flattenErrorCauses(error, parentSource) {\n    let currentError = error;\n    const causes = [];\n    while (isError(currentError === null || currentError === void 0 ? void 0 : currentError.cause) && causes.length < 10) {\n        const stackTrace = computeStackTrace(currentError.cause);\n        causes.push({\n            message: currentError.cause.message,\n            source: parentSource,\n            type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n            stack: stackTrace && toStackTraceString(stackTrace),\n        });\n        currentError = currentError.cause;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.js.map","// Maps PerformanceEntry start-time to the corresponding long task id (from RUM LongTaskEvent),\n// We need this to link RUM Long Tasks with RUM Profiler stack traces\n// Given that long task takes at least 50ms and we export profile at least every 60 seconds, we can have up to 1200 entries (60s / 50ms = 1200).\nconst registry = new Map();\nexport function disableLongTaskRegistry() {\n    registry.clear(); // Free-up the memory\n}\n/**\n * Store the long task ID in the registry for the Profiler to link it with the corresponding Profile.\n */\nexport function setLongTaskId(longTaskId, startTime) {\n    registry.set(startTime, longTaskId);\n}\nexport function getLongTaskId(startTime) {\n    return registry.get(startTime);\n}\n/**\n * Delete the Long Task from the registry once we have collected it.\n *\n * @param collectionRelativeTime - The relative time of the collection\n */\nexport function cleanupLongTaskRegistryAfterCollection(collectionRelativeTime) {\n    for (const performanceStartTime of registry.keys()) {\n        if (performanceStartTime < collectionRelativeTime) {\n            // We collected this Long Task already, no need to keep it in the registry.\n            registry.delete(performanceStartTime);\n        }\n    }\n}\n//# sourceMappingURL=longTaskRegistry.js.map","import { RumEventType } from '@datadog/browser-rum-core';\nimport { setLongTaskId } from './utils/longTaskRegistry';\n/**\n * Store the Long Task ID in the registry for the Profiler to link it with the corresponding Profile.\n *\n * @param options - The options for the function\n * @param options.rawRumEvent - The Raw RUM event\n * @param options.startTime - The start time of the event (in this case the Long Task Performance Entry start time)\n */\nexport function mayStoreLongTaskIdForProfilerCorrelation({ rawRumEvent, startTime, }) {\n    if (rawRumEvent.type !== RumEventType.LONG_TASK) {\n        return;\n    }\n    const longTaskId = rawRumEvent.long_task.id;\n    // Store longTaskId in the registry for the Profiler to link it with the corresponding Profile.\n    setLongTaskId(longTaskId, startTime);\n}\n//# sourceMappingURL=profilingCorrelation.js.map","// This is the regex used to extract the path from the url (from SimpleUrlGroupingProcessor.java)\n// It's a bit different from the one in the java code because we removed the lookbehind unsupported by Safari.\nconst PATH_MIXED_ALPHANUMERICS = /\\/(?![vV]\\d{1,2}\\/)([^/\\d?]*\\d+[^/?]*)/g;\nexport function getDefaultViewName(viewPathUrl) {\n    if (!viewPathUrl) {\n        return '/';\n    }\n    // Replace all the mixed alphanumerics with a ?\n    return viewPathUrl.replace(PATH_MIXED_ALPHANUMERICS, '/?');\n}\n//# sourceMappingURL=getDefaultViewName.js.map","import { getDefaultViewName } from './getDefaultViewName';\nexport const getCustomOrDefaultViewName = (customViewName, viewPathUrl) => customViewName || getDefaultViewName(viewPathUrl);\n//# sourceMappingURL=getCustomOrDefaultViewName.js.map","/**\n * Builds attributes for the Profile Event.\n *\n * @param profilerTrace - Profiler trace\n * @param applicationId - application id.\n * @param sessionId - session id.\n * @returns Additional attributes.\n */\nexport function buildProfileEventAttributes(profilerTrace, applicationId, sessionId) {\n    const attributes = {\n        application: {\n            id: applicationId,\n        },\n    };\n    if (sessionId) {\n        attributes.session = {\n            id: sessionId,\n        };\n    }\n    // Extract view ids and names from the profiler trace and add them as attributes of the profile event.\n    // This will be used to filter the profiles by @view.id and/or @view.name.\n    const { ids, names } = extractViewIdsAndNames(profilerTrace.views);\n    if (ids.length) {\n        attributes.view = {\n            id: ids,\n            name: names,\n        };\n    }\n    const longTaskIds = profilerTrace.longTasks.map((longTask) => longTask.id).filter((id) => id !== undefined);\n    if (longTaskIds.length) {\n        attributes.long_task = { id: longTaskIds };\n    }\n    return attributes;\n}\nfunction extractViewIdsAndNames(views) {\n    const result = { ids: [], names: [] };\n    for (const view of views) {\n        result.ids.push(view.viewId);\n        if (view.viewName) {\n            result.names.push(view.viewName);\n        }\n    }\n    // Remove duplicates\n    result.names = Array.from(new Set(result.names));\n    return result;\n}\n//# sourceMappingURL=buildProfileEventAttributes.js.map","import { buildTags, currentDrift } from '@datadog/browser-core';\nimport { buildProfileEventAttributes } from './buildProfileEventAttributes';\nexport function assembleProfilingPayload(profilerTrace, configuration, sessionId) {\n    const event = buildProfileEvent(profilerTrace, configuration, sessionId);\n    return {\n        event,\n        'wall-time.json': profilerTrace,\n    };\n}\nfunction buildProfileEvent(profilerTrace, configuration, sessionId) {\n    const tags = buildTags(configuration); // TODO: get that from the tagContext hook\n    const profileAttributes = buildProfileEventAttributes(profilerTrace, configuration.applicationId, sessionId);\n    const profileEventTags = buildProfileEventTags(tags);\n    const profileEvent = {\n        ...profileAttributes,\n        attachments: ['wall-time.json'],\n        start: new Date(profilerTrace.startClocks.timeStamp).toISOString(),\n        end: new Date(profilerTrace.endClocks.timeStamp).toISOString(),\n        family: 'chrome',\n        runtime: 'chrome',\n        format: 'json',\n        version: 4, // Ingestion event version (not the version application tag)\n        tags_profiler: profileEventTags.join(','),\n        _dd: {\n            clock_drift: currentDrift(),\n        },\n    };\n    return profileEvent;\n}\n/**\n * Builds tags for the Profile Event.\n *\n * @param tags - RUM tags\n * @returns Combined tags for the Profile Event.\n */\nfunction buildProfileEventTags(tags) {\n    // Tags already contains the common tags for all events. (service, env, version, etc.)\n    // Here we are adding some specific-to-profiling tags.\n    const profileEventTags = tags.concat(['language:javascript', 'runtime:chrome', 'family:chrome', 'host:browser']);\n    return profileEventTags;\n}\n//# sourceMappingURL=assembly.js.map","import { addEventListener, clearTimeout, setTimeout, monitorError, display, getGlobalObject, relativeToClocks, clocksOrigin, clocksNow, elapsed, } from '@datadog/browser-core';\nimport { createFormDataTransport, RumPerformanceEntryType, supportPerformanceTimingEvent, } from '@datadog/browser-rum-core';\nimport { getNumberOfSamples } from './utils/getNumberOfSamples';\nimport { cleanupLongTaskRegistryAfterCollection, getLongTaskId } from './utils/longTaskRegistry';\nimport { mayStoreLongTaskIdForProfilerCorrelation } from './profilingCorrelation';\nimport { getCustomOrDefaultViewName } from './utils/getCustomOrDefaultViewName';\nimport { assembleProfilingPayload } from './transport/assembly';\nexport const DEFAULT_RUM_PROFILER_CONFIGURATION = {\n    sampleIntervalMs: 10, // Sample stack trace every 10ms\n    collectIntervalMs: 60000, // Collect data every minute\n    minProfileDurationMs: 5000, // Require at least 5 seconds of profile data to reduce noise and cost\n    minNumberOfSamples: 50, // Require at least 50 samples (~500 ms) to report a profile to reduce noise and cost\n};\nexport function createRumProfiler(configuration, lifeCycle, session, profilingContextManager, createEncoder, profilerConfiguration = DEFAULT_RUM_PROFILER_CONFIGURATION) {\n    const transport = createFormDataTransport(configuration, lifeCycle, createEncoder, 6 /* DeflateEncoderStreamId.PROFILING */);\n    const isLongAnimationFrameEnabled = supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME);\n    let lastViewEntry;\n    // Global clean-up tasks for listeners that are not specific to a profiler instance (eg. visibility change, before unload)\n    const globalCleanupTasks = [];\n    let instance = { state: 'stopped' };\n    function start(viewEntry) {\n        if (instance.state === 'running') {\n            return;\n        }\n        // Add initial view\n        // Note: `viewEntry.name` is only filled when users use manual view creation via `startView` method.\n        lastViewEntry = viewEntry\n            ? {\n                startClocks: viewEntry.startClocks,\n                viewId: viewEntry.id,\n                viewName: getCustomOrDefaultViewName(viewEntry.name, document.location.pathname),\n            }\n            : undefined;\n        // Add global clean-up tasks for listeners that are not specific to a profiler instance (eg. visibility change, before unload)\n        globalCleanupTasks.push(addEventListener(configuration, window, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, handleVisibilityChange).stop, addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, handleBeforeUnload).stop);\n        // Start profiler instance\n        startNextProfilerInstance();\n    }\n    async function stop() {\n        // Stop current profiler instance\n        await stopProfilerInstance('stopped');\n        // Cleanup global listeners\n        globalCleanupTasks.forEach((task) => task());\n        // Cleanup Long Task Registry as we no longer need to correlate them with RUM\n        cleanupLongTaskRegistryAfterCollection(clocksNow().relative);\n        // Update Profiling status once the Profiler has been stopped.\n        profilingContextManager.set({ status: 'stopped', error_reason: undefined });\n    }\n    /**\n     * Whenever a new Profiler instance is started, we need to add event listeners to surroundings (RUM Events, Long Tasks, etc) to enrich the Profiler data.\n     * If the instance is already running, we can keep the same event listeners.\n     */\n    function addEventListeners(existingInstance) {\n        if (existingInstance.state === 'running') {\n            // Instance is already running, so we can keep same event listeners.\n            return {\n                cleanupTasks: existingInstance.cleanupTasks,\n                observer: existingInstance.observer,\n            };\n        }\n        // Store clean-up tasks for this instance (tasks to be executed when the Profiler is stopped or paused.)\n        const cleanupTasks = [];\n        let observer;\n        // Register everything linked to Long Tasks correlations with RUM, when enabled.\n        if (configuration.trackLongTasks) {\n            // Setup event listeners, and since we only listen to Long Tasks for now, we activate the Performance Observer only when they are tracked.\n            observer = new PerformanceObserver(handlePerformance);\n            observer.observe({\n                entryTypes: [getLongTaskEntryType()],\n            });\n            // Whenever an Event is collected, when it's a Long Task, we may store the long task id for profiler correlation.\n            const rawEventCollectedSubscription = lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, (data) => {\n                mayStoreLongTaskIdForProfilerCorrelation(data);\n            });\n            cleanupTasks.push(() => observer === null || observer === void 0 ? void 0 : observer.disconnect());\n            cleanupTasks.push(rawEventCollectedSubscription.unsubscribe);\n        }\n        // Whenever the View is updated, we add a views entry to the profiler instance.\n        const viewUpdatedSubscription = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, (view) => {\n            const viewEntry = {\n                viewId: view.id,\n                // Note: `viewName` is only filled when users use manual view creation via `startView` method.\n                viewName: getCustomOrDefaultViewName(view.name, document.location.pathname),\n                startClocks: view.startClocks,\n            };\n            collectViewEntry(viewEntry);\n            // Update last view entry\n            lastViewEntry = viewEntry;\n        });\n        cleanupTasks.push(viewUpdatedSubscription.unsubscribe);\n        return {\n            cleanupTasks,\n            observer,\n        };\n    }\n    function startNextProfilerInstance() {\n        // These APIs might be unavailable in some browsers\n        const globalThisProfiler = getGlobalObject().Profiler;\n        if (!globalThisProfiler) {\n            profilingContextManager.set({ status: 'error', error_reason: 'not-supported-by-browser' });\n            throw new Error('RUM Profiler is not supported in this browser.');\n        }\n        // Don't wait for data collection to start next instance\n        collectProfilerInstance(instance).catch(monitorError);\n        const { cleanupTasks, observer } = addEventListeners(instance);\n        let profiler;\n        try {\n            // We have to create new Profiler each time we start a new instance\n            profiler = new globalThisProfiler({\n                sampleInterval: profilerConfiguration.sampleIntervalMs,\n                // Keep buffer size at 1.5 times of minimum required to collect data for a profiling instance\n                maxBufferSize: Math.round((profilerConfiguration.collectIntervalMs * 1.5) / profilerConfiguration.sampleIntervalMs),\n            });\n        }\n        catch (e) {\n            if (e instanceof Error && e.message.includes('disabled by Document Policy')) {\n                // Missing Response Header (`js-profiling`) that is required to enable the profiler.\n                // We should suggest the user to enable the Response Header in their server configuration.\n                display.warn('[DD_RUM] Profiler startup failed. Ensure your server includes the `Document-Policy: js-profiling` response header when serving HTML pages.', e);\n                profilingContextManager.set({ status: 'error', error_reason: 'missing-document-policy-header' });\n            }\n            else {\n                profilingContextManager.set({ status: 'error', error_reason: 'unexpected-exception' });\n            }\n            return;\n        }\n        profilingContextManager.set({ status: 'running', error_reason: undefined });\n        // Kick-off the new instance\n        instance = {\n            state: 'running',\n            startClocks: clocksNow(),\n            profiler,\n            timeoutId: setTimeout(startNextProfilerInstance, profilerConfiguration.collectIntervalMs),\n            longTasks: [],\n            views: [],\n            cleanupTasks,\n            observer,\n        };\n        // Add last view entry\n        collectViewEntry(lastViewEntry);\n        // Add event handler case we overflow the buffer\n        profiler.addEventListener('samplebufferfull', handleSampleBufferFull);\n    }\n    async function collectProfilerInstance(lastInstance) {\n        var _a, _b;\n        if (lastInstance.state !== 'running') {\n            return;\n        }\n        // Empty the performance observer buffer\n        handleLongTaskEntries((_b = (_a = lastInstance.observer) === null || _a === void 0 ? void 0 : _a.takeRecords()) !== null && _b !== void 0 ? _b : []);\n        // Cleanup instance\n        clearTimeout(lastInstance.timeoutId);\n        lastInstance.profiler.removeEventListener('samplebufferfull', handleSampleBufferFull);\n        // Store instance data snapshot in local variables to use in async callback\n        const { startClocks, longTasks, views } = lastInstance;\n        // Capturing when we stop the profiler so we use this time as a reference to clean-up long task registry, eg. remove the long tasks that we collected already\n        const collectClocks = clocksNow();\n        // Stop current profiler to get trace\n        await lastInstance.profiler\n            .stop()\n            .then((trace) => {\n            const endClocks = clocksNow();\n            const hasLongTasks = longTasks.length > 0;\n            const isBelowDurationThreshold = elapsed(startClocks.timeStamp, endClocks.timeStamp) < profilerConfiguration.minProfileDurationMs;\n            const isBelowSampleThreshold = getNumberOfSamples(trace.samples) < profilerConfiguration.minNumberOfSamples;\n            if (!hasLongTasks && (isBelowDurationThreshold || isBelowSampleThreshold)) {\n                // Skip very short profiles to reduce noise and cost, but keep them if they contain long tasks.\n                return;\n            }\n            handleProfilerTrace(\n            // Enrich trace with time and instance data\n            Object.assign(trace, {\n                startClocks,\n                endClocks,\n                clocksOrigin: clocksOrigin(),\n                longTasks,\n                views,\n                sampleInterval: profilerConfiguration.sampleIntervalMs,\n            }));\n            // Clear long task registry, remove entries that we collected already (eg. avoid slowly growing memory usage by keeping outdated entries)\n            cleanupLongTaskRegistryAfterCollection(collectClocks.relative);\n        })\n            .catch(monitorError);\n    }\n    async function stopProfilerInstance(nextState) {\n        if (instance.state !== 'running') {\n            return;\n        }\n        // Cleanup tasks\n        instance.cleanupTasks.forEach((cleanupTask) => cleanupTask());\n        await collectProfilerInstance(instance);\n        instance = { state: nextState };\n    }\n    function collectViewEntry(viewEntry) {\n        if (instance.state !== 'running' || !viewEntry) {\n            return;\n        }\n        // Add entry to views\n        instance.views.push(viewEntry);\n    }\n    function handleProfilerTrace(trace) {\n        var _a;\n        // Find current session to assign it to the Profile.\n        const sessionId = (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id;\n        const payload = assembleProfilingPayload(trace, configuration, sessionId);\n        void transport.send(payload);\n    }\n    function handleSampleBufferFull() {\n        startNextProfilerInstance();\n    }\n    function handlePerformance(list) {\n        handleLongTaskEntries(list.getEntries());\n    }\n    function handleLongTaskEntries(entries) {\n        if (instance.state !== 'running') {\n            return;\n        }\n        for (const entry of entries) {\n            if (entry.duration < profilerConfiguration.sampleIntervalMs) {\n                // Skip entries shorter than sample interval to reduce noise and size of profile\n                continue;\n            }\n            const startClocks = relativeToClocks(entry.startTime);\n            const longTaskId = getLongTaskId(startClocks.relative);\n            // Store Long Task entry, which is a lightweight version of the PerformanceEntry\n            instance.longTasks.push({\n                id: longTaskId,\n                duration: entry.duration,\n                entryType: entry.entryType,\n                startClocks,\n            });\n        }\n    }\n    function handleVisibilityChange() {\n        if (document.visibilityState === 'hidden' && instance.state === 'running') {\n            // Pause when tab is hidden. We use paused state to distinguish between\n            // paused by visibility change and stopped by user.\n            // If profiler is paused by the visibility change, we should resume when\n            // tab becomes visible again. That's not the case when user stops the profiler.\n            stopProfilerInstance('paused').catch(monitorError);\n        }\n        else if (document.visibilityState === 'visible' && instance.state === 'paused') {\n            // Resume when tab becomes visible again\n            startNextProfilerInstance();\n        }\n    }\n    function handleBeforeUnload() {\n        // `unload` can in some cases be triggered while the page is still active (link to a different protocol like mailto:).\n        // We can immediately flush (by starting a new profiler instance) to make sure we receive the data, and at the same time keep the profiler active.\n        // In case of the regular unload, the profiler will be shut down anyway.\n        startNextProfilerInstance();\n    }\n    function getLongTaskEntryType() {\n        return isLongAnimationFrameEnabled ? 'long-animation-frame' : 'longtask';\n    }\n    function isStopped() {\n        return instance.state === 'stopped';\n    }\n    function isRunning() {\n        return instance.state === 'running';\n    }\n    function isPaused() {\n        return instance.state === 'paused';\n    }\n    return { start, stop, isStopped, isRunning, isPaused };\n}\n//# sourceMappingURL=profiler.js.map","/**\n * Counts number of samples when the thread was not idle (stackId is defined)\n *\n * @param samples - Array of collected samples\n * @returns Number of samples\n */\nexport function getNumberOfSamples(samples) {\n    let numberOfSamples = 0;\n    for (const sample of samples) {\n        if (sample.stackId !== undefined) {\n            numberOfSamples++;\n        }\n    }\n    return numberOfSamples;\n}\n//# sourceMappingURL=getNumberOfSamples.js.map","import { setTimeout, clearTimeout } from './timer';\nimport { monitor } from './monitor';\nimport { dateNow } from './utils/timeUtils';\n/**\n * 'requestIdleCallback' with a shim.\n */\nexport function requestIdleCallback(callback, opts) {\n    // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n    if (window.requestIdleCallback && window.cancelIdleCallback) {\n        const id = window.requestIdleCallback(monitor(callback), opts);\n        return () => window.cancelIdleCallback(id);\n    }\n    return requestIdleCallbackShim(callback);\n}\nexport const MAX_TASK_TIME = 50;\n/*\n * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback\n * Note: there is no simple way to support the \"timeout\" option, so we ignore it.\n */\nexport function requestIdleCallbackShim(callback) {\n    const start = dateNow();\n    const timeoutId = setTimeout(() => {\n        callback({\n            didTimeout: false,\n            timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),\n        });\n    }, 0);\n    return () => clearTimeout(timeoutId);\n}\n//# sourceMappingURL=requestIdleCallback.js.map","export function isChromium() {\n    return detectBrowserCached() === 0 /* Browser.CHROMIUM */;\n}\nexport function isSafari() {\n    return detectBrowserCached() === 1 /* Browser.SAFARI */;\n}\nlet browserCache;\nfunction detectBrowserCached() {\n    return browserCache !== null && browserCache !== void 0 ? browserCache : (browserCache = detectBrowser());\n}\n// Exported only for tests\nexport function detectBrowser(browserWindow = window) {\n    var _a;\n    const userAgent = browserWindow.navigator.userAgent;\n    if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) {\n        return 0 /* Browser.CHROMIUM */;\n    }\n    if (\n    // navigator.vendor is deprecated, but it is the most resilient way we found to detect\n    // \"Apple maintained browsers\" (AKA Safari). If one day it gets removed, we still have the\n    // useragent test as a semi-working fallback.\n    ((_a = browserWindow.navigator.vendor) === null || _a === void 0 ? void 0 : _a.indexOf('Apple')) === 0 ||\n        (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))) {\n        return 1 /* Browser.SAFARI */;\n    }\n    return 2 /* Browser.OTHER */;\n}\n//# sourceMappingURL=browserDetection.js.map","import { noop } from '../utils/functionUtils';\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n    if (typeof value !== 'object' || value === null) {\n        return JSON.stringify(value);\n    }\n    // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n    // subclasses.\n    const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    const restoreValueToJson = detachToJsonMethod(value);\n    try {\n        return JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        return '<error: unable to serialize object>';\n    }\n    finally {\n        restoreObjectPrototypeToJson();\n        restoreArrayPrototypeToJson();\n        restoreValuePrototypeToJson();\n        restoreValueToJson();\n    }\n}\nexport function detachToJsonMethod(value) {\n    const object = value;\n    const objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return () => {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\n//# sourceMappingURL=jsonStringify.js.map","import { callMonitored } from '../monitor';\nimport { computeStackTrace } from './computeStackTrace';\n/**\n * Creates a stacktrace without SDK internal frames.\n * Constraints:\n * - Has to be called at the utmost position of the call stack.\n * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack(type) {\n    /**\n     * Skip the two internal frames:\n     * - SDK API (console.error, ...)\n     * - this function\n     * in order to keep only the user calls\n     */\n    const internalFramesToSkip = 2;\n    const error = new Error(type);\n    error.name = 'HandlingStack';\n    let formattedStack;\n    callMonitored(() => {\n        const stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\nexport function toStackTraceString(stack) {\n    let result = formatErrorMessage(stack);\n    stack.stack.forEach((frame) => {\n        const func = frame.func === '?' ? '<anonymous>' : frame.func;\n        const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : '';\n        const line = frame.line ? `:${frame.line}` : '';\n        const column = frame.line && frame.column ? `:${frame.column}` : '';\n        result += `\\n  at ${func}${args} @ ${frame.url}${line}${column}`;\n    });\n    return result;\n}\nexport function formatErrorMessage(stack) {\n    return `${stack.name || 'Error'}: ${stack.message}`;\n}\n//# sourceMappingURL=handlingStack.js.map","import { globalObject } from '../globalObject';\nexport function normalizeUrl(url) {\n    return buildUrl(url, location.href).href;\n}\nexport function isValidUrl(url) {\n    try {\n        return !!buildUrl(url);\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getPathName(url) {\n    const pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : `/${pathname}`;\n}\nexport function buildUrl(url, base) {\n    const { URL } = getPristineWindow();\n    try {\n        return base !== undefined ? new URL(url, base) : new URL(url);\n    }\n    catch (error) {\n        throw new Error(`Failed to construct URL: ${String(error)}`);\n    }\n}\n/**\n * Get native URL constructor from a clean iframe\n * This avoids polyfill issues by getting the native implementation from a fresh iframe context\n * Falls back to the original URL constructor if iframe approach fails\n */\nlet getPristineGlobalObjectCache;\nexport function getPristineWindow() {\n    if (!getPristineGlobalObjectCache) {\n        let iframe;\n        let pristineWindow;\n        try {\n            iframe = document.createElement('iframe');\n            iframe.style.display = 'none';\n            document.body.appendChild(iframe);\n            pristineWindow = iframe.contentWindow;\n        }\n        catch (_a) {\n            pristineWindow = globalObject;\n        }\n        getPristineGlobalObjectCache = {\n            URL: pristineWindow.URL,\n        };\n        iframe === null || iframe === void 0 ? void 0 : iframe.remove();\n    }\n    return getPristineGlobalObjectCache;\n}\n//# sourceMappingURL=urlPolyfill.js.map","import { getGlobalObject } from '../tools/globalObject';\nexport function getEventBridge() {\n    const eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getCapabilities() {\n            var _a;\n            return JSON.parse(((_a = eventBridgeGlobal.getCapabilities) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal)) || '[]');\n        },\n        getPrivacyLevel() {\n            var _a;\n            return (_a = eventBridgeGlobal.getPrivacyLevel) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal);\n        },\n        getAllowedWebViewHosts() {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send(eventType, event, viewId) {\n            const view = viewId ? { id: viewId } : undefined;\n            eventBridgeGlobal.send(JSON.stringify({ eventType, event, view }));\n        },\n    };\n}\nexport function bridgeSupports(capability) {\n    const bridge = getEventBridge();\n    return !!bridge && bridge.getCapabilities().includes(capability);\n}\nexport function canUseEventBridge(currentHost) {\n    var _a;\n    if (currentHost === void 0) { currentHost = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname; }\n    const bridge = getEventBridge();\n    return (!!bridge &&\n        bridge\n            .getAllowedWebViewHosts()\n            .some((allowedHost) => currentHost === allowedHost || currentHost.endsWith(`.${allowedHost}`)));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageMayExitObservable';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nexport function createBatch({ encoder, request, flushController, messageBytesLimit, }) {\n    let upsertBuffer = {};\n    const flushSubscription = flushController.flushObservable.subscribe((event) => flush(event));\n    function push(serializedMessage, estimatedMessageBytesCount, key) {\n        flushController.notifyBeforeAddMessage(estimatedMessageBytesCount);\n        if (key !== undefined) {\n            upsertBuffer[key] = serializedMessage;\n            flushController.notifyAfterAddMessage();\n        }\n        else {\n            encoder.write(encoder.isEmpty ? serializedMessage : `\\n${serializedMessage}`, (realMessageBytesCount) => {\n                flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount);\n            });\n        }\n    }\n    function hasMessageFor(key) {\n        return key !== undefined && upsertBuffer[key] !== undefined;\n    }\n    function remove(key) {\n        const removedMessage = upsertBuffer[key];\n        delete upsertBuffer[key];\n        const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage);\n        flushController.notifyAfterRemoveMessage(messageBytesCount);\n    }\n    function addOrUpdate(message, key) {\n        const serializedMessage = jsonStringify(message);\n        const estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage);\n        if (estimatedMessageBytesCount >= messageBytesLimit) {\n            display.warn(`Discarded a message whose size was bigger than the maximum allowed size ${messageBytesLimit}KB. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#technical-limitations`);\n            return;\n        }\n        if (hasMessageFor(key)) {\n            remove(key);\n        }\n        push(serializedMessage, estimatedMessageBytesCount, key);\n    }\n    function flush(event) {\n        const upsertMessages = objectValues(upsertBuffer).join('\\n');\n        upsertBuffer = {};\n        const pageMightExit = isPageExitReason(event.reason);\n        const send = pageMightExit ? request.sendOnExit : request.send;\n        if (pageMightExit &&\n            // Note: checking that the encoder is async is not strictly needed, but it's an optimization:\n            // if the encoder is async we need to send two requests in some cases (one for encoded data\n            // and the other for non-encoded data). But if it's not async, we don't have to worry about\n            // it and always send a single request.\n            encoder.isAsync) {\n            const encoderResult = encoder.finishSync();\n            // Send encoded messages\n            if (encoderResult.outputBytesCount) {\n                send(formatPayloadFromEncoder(encoderResult));\n            }\n            // Send messages that are not yet encoded at this point\n            const pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\\n');\n            if (pendingMessages) {\n                send({\n                    data: pendingMessages,\n                    bytesCount: computeBytesCount(pendingMessages),\n                });\n            }\n        }\n        else {\n            if (upsertMessages) {\n                encoder.write(encoder.isEmpty ? upsertMessages : `\\n${upsertMessages}`);\n            }\n            encoder.finish((encoderResult) => {\n                send(formatPayloadFromEncoder(encoderResult));\n            });\n        }\n    }\n    return {\n        flushController,\n        add: addOrUpdate,\n        upsert: addOrUpdate,\n        stop: flushSubscription.unsubscribe,\n    };\n}\nfunction formatPayloadFromEncoder(encoderResult) {\n    let data;\n    if (typeof encoderResult.output === 'string') {\n        data = encoderResult.output;\n    }\n    else {\n        data = new Blob([encoderResult.output], {\n            // This will set the 'Content-Type: text/plain' header. Reasoning:\n            // * The intake rejects the request if there is no content type.\n            // * The browser will issue CORS preflight requests if we set it to 'application/json', which\n            // could induce higher intake load (and maybe has other impacts).\n            // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by\n            // new lines.\n            type: 'text/plain',\n        });\n    }\n    return {\n        data,\n        bytesCount: encoderResult.outputBytesCount,\n        encoding: encoderResult.encoding,\n    };\n}\n//# sourceMappingURL=batch.js.map","import { setTimeout } from '../tools/timer';\nimport { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { isServerError } from '../tools/utils/responseUtils';\nimport { ErrorSource } from '../domain/error/error.types';\nexport const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport const MAX_ONGOING_REQUESTS = 32;\nexport const MAX_QUEUE_BYTES_COUNT = 20 * ONE_MEBI_BYTE;\nexport const MAX_BACKOFF_TIME = ONE_MINUTE;\nexport const INITIAL_BACKOFF_TIME = ONE_SECOND;\nexport function sendWithRetryStrategy(payload, state, sendStrategy, trackType, reportError, requestObservable) {\n    if (state.transportStatus === 0 /* TransportStatus.UP */ &&\n        state.queuedPayloads.size() === 0 &&\n        state.bandwidthMonitor.canHandle(payload)) {\n        send(payload, state, sendStrategy, requestObservable, {\n            onSuccess: () => retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, trackType, reportError, requestObservable),\n            onFailure: () => {\n                if (!state.queuedPayloads.enqueue(payload)) {\n                    requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload });\n                }\n                scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);\n            },\n        });\n    }\n    else {\n        if (!state.queuedPayloads.enqueue(payload)) {\n            requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload });\n        }\n    }\n}\nfunction scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable) {\n    if (state.transportStatus !== 2 /* TransportStatus.DOWN */) {\n        return;\n    }\n    setTimeout(() => {\n        const payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, requestObservable, {\n            onSuccess: () => {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, trackType, reportError, requestObservable);\n            },\n            onFailure: () => {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);\n            },\n        });\n    }, state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, requestObservable, { onSuccess, onFailure }) {\n    state.bandwidthMonitor.add(payload);\n    sendStrategy(payload, (response) => {\n        state.bandwidthMonitor.remove(payload);\n        if (!shouldRetryRequest(response)) {\n            state.transportStatus = 0 /* TransportStatus.UP */;\n            requestObservable.notify({ type: 'success', bandwidth: state.bandwidthMonitor.stats(), payload });\n            onSuccess();\n        }\n        else {\n            // do not consider transport down if another ongoing request could succeed\n            state.transportStatus =\n                state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 /* TransportStatus.FAILURE_DETECTED */ : 2 /* TransportStatus.DOWN */;\n            payload.retry = {\n                count: payload.retry ? payload.retry.count + 1 : 1,\n                lastFailureStatus: response.status,\n            };\n            requestObservable.notify({ type: 'failure', bandwidth: state.bandwidthMonitor.stats(), payload });\n            onFailure();\n        }\n    });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError, requestObservable) {\n    if (reason === 0 /* RetryReason.AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n        reportError({\n            message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n        });\n        state.queueFullReported = true;\n    }\n    const previousQueue = state.queuedPayloads;\n    state.queuedPayloads = newPayloadQueue();\n    while (previousQueue.size() > 0) {\n        sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, trackType, reportError, requestObservable);\n    }\n}\nfunction shouldRetryRequest(response) {\n    return (response.type !== 'opaque' &&\n        ((response.status === 0 && !navigator.onLine) ||\n            response.status === 408 ||\n            response.status === 429 ||\n            isServerError(response.status)));\n}\nexport function newRetryState() {\n    return {\n        transportStatus: 0 /* TransportStatus.UP */,\n        currentBackoffTime: INITIAL_BACKOFF_TIME,\n        bandwidthMonitor: newBandwidthMonitor(),\n        queuedPayloads: newPayloadQueue(),\n        queueFullReported: false,\n    };\n}\nfunction newPayloadQueue() {\n    const queue = [];\n    return {\n        bytesCount: 0,\n        enqueue(payload) {\n            if (this.isFull()) {\n                return false;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\n            return true;\n        },\n        first() {\n            return queue[0];\n        },\n        dequeue() {\n            const payload = queue.shift();\n            if (payload) {\n                this.bytesCount -= payload.bytesCount;\n            }\n            return payload;\n        },\n        size() {\n            return queue.length;\n        },\n        isFull() {\n            return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n        },\n    };\n}\nfunction newBandwidthMonitor() {\n    return {\n        ongoingRequestCount: 0,\n        ongoingByteCount: 0,\n        canHandle(payload) {\n            return (this.ongoingRequestCount === 0 ||\n                (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n                    this.ongoingRequestCount < MAX_ONGOING_REQUESTS));\n        },\n        add(payload) {\n            this.ongoingRequestCount += 1;\n            this.ongoingByteCount += payload.bytesCount;\n        },\n        remove(payload) {\n            this.ongoingRequestCount -= 1;\n            this.ongoingByteCount -= payload.bytesCount;\n        },\n        stats() {\n            return {\n                ongoingByteCount: this.ongoingByteCount,\n                ongoingRequestCount: this.ongoingRequestCount,\n            };\n        },\n    };\n}\n//# sourceMappingURL=sendWithRetryStrategy.js.map","import { monitor, monitorError } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(endpointBuilders, bytesLimit, reportError) {\n    const observable = new Observable();\n    const retryState = newRetryState();\n    return {\n        observable,\n        send: (payload) => {\n            for (const endpointBuilder of endpointBuilders) {\n                sendWithRetryStrategy(payload, retryState, (payload, onResponse) => fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse), endpointBuilder.trackType, reportError, observable);\n            }\n        },\n        /**\n         * Since fetch keepalive behaves like regular fetch on Firefox,\n         * keep using sendBeaconStrategy on exit\n         */\n        sendOnExit: (payload) => {\n            for (const endpointBuilder of endpointBuilders) {\n                sendBeaconStrategy(endpointBuilder, bytesLimit, payload);\n            }\n        },\n    };\n}\nfunction sendBeaconStrategy(endpointBuilder, bytesLimit, payload) {\n    const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            const beaconUrl = endpointBuilder.build('beacon', payload);\n            const isQueued = navigator.sendBeacon(beaconUrl, payload.data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    fetchStrategy(endpointBuilder, payload);\n}\nlet hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        monitorError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse) {\n    const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        const fetchUrl = endpointBuilder.build('fetch-keepalive', payload);\n        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' })\n            .then(monitor((response) => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type })))\n            .catch(monitor(() => fetchStrategy(endpointBuilder, payload, onResponse)));\n    }\n    else {\n        fetchStrategy(endpointBuilder, payload, onResponse);\n    }\n}\nexport function fetchStrategy(endpointBuilder, payload, onResponse) {\n    const fetchUrl = endpointBuilder.build('fetch', payload);\n    fetch(fetchUrl, { method: 'POST', body: payload.data, mode: 'cors' })\n        .then(monitor((response) => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type })))\n        .catch(monitor(() => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: 0 })));\n}\nfunction isKeepAliveSupported() {\n    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n    try {\n        return window.Request && 'keepalive' in new Request('http://a');\n    }\n    catch (_a) {\n        return false;\n    }\n}\n//# sourceMappingURL=httpRequest.js.map","export const ONE_KIBI_BYTE = 1024;\nexport const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nconst HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n    // Accurate bytes count computations can degrade performances when there is a lot of events to process\n    if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n        return candidate.length;\n    }\n    if (window.TextEncoder !== undefined) {\n        return new TextEncoder().encode(candidate).length;\n    }\n    return new Blob([candidate]).size;\n}\nexport function concatBuffers(buffers) {\n    const length = buffers.reduce((total, buffer) => total + buffer.length, 0);\n    const result = new Uint8Array(length);\n    let offset = 0;\n    for (const buffer of buffers) {\n        result.set(buffer, offset);\n        offset += buffer.length;\n    }\n    return result;\n}\n//# sourceMappingURL=byteUtils.js.map","import { combine } from './mergeInto';\n// Discards the event from being sent\nexport const DISCARDED = 'DISCARDED';\n// Skips from the assembly of the event\nexport const SKIPPED = 'SKIPPED';\nexport function abstractHooks() {\n    const callbacks = {};\n    return {\n        register(hookName, callback) {\n            if (!callbacks[hookName]) {\n                callbacks[hookName] = [];\n            }\n            callbacks[hookName].push(callback);\n            return {\n                unregister: () => {\n                    callbacks[hookName] = callbacks[hookName].filter((cb) => cb !== callback);\n                },\n            };\n        },\n        triggerHook(hookName, param) {\n            const hookCallbacks = callbacks[hookName] || [];\n            const results = [];\n            for (const callback of hookCallbacks) {\n                const result = callback(param);\n                if (result === DISCARDED) {\n                    return DISCARDED;\n                }\n                if (result === SKIPPED) {\n                    continue;\n                }\n                results.push(result);\n            }\n            return combine(...results);\n        },\n    };\n}\n//# sourceMappingURL=abstractHooks.js.map","import { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController({ messagesLimit, bytesLimit, durationLimit, pageMayExitObservable, sessionExpireObservable, }) {\n    const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => flush(event.reason));\n    const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'));\n    const flushObservable = new Observable(() => () => {\n        pageMayExitSubscription.unsubscribe();\n        sessionExpireSubscription.unsubscribe();\n    });\n    let currentBytesCount = 0;\n    let currentMessagesCount = 0;\n    function flush(flushReason) {\n        if (currentMessagesCount === 0) {\n            return;\n        }\n        const messagesCount = currentMessagesCount;\n        const bytesCount = currentBytesCount;\n        currentMessagesCount = 0;\n        currentBytesCount = 0;\n        cancelDurationLimitTimeout();\n        flushObservable.notify({\n            reason: flushReason,\n            messagesCount,\n            bytesCount,\n        });\n    }\n    let durationLimitTimeoutId;\n    function scheduleDurationLimitTimeout() {\n        if (durationLimitTimeoutId === undefined) {\n            durationLimitTimeoutId = setTimeout(() => {\n                flush('duration_limit');\n            }, durationLimit);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable,\n        get messagesCount() {\n            return currentMessagesCount;\n        },\n        /**\n         * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right before adding the message, so no flush\n         * event can happen after `notifyBeforeAddMessage` and before adding the message.\n         *\n         * @param estimatedMessageBytesCount - an estimation of the message bytes count once it is\n         * actually added.\n         */\n        notifyBeforeAddMessage(estimatedMessageBytesCount) {\n            if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n            // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n            // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n            // to notify when a flush is needed (for example on page exit).\n            currentMessagesCount += 1;\n            currentBytesCount += estimatedMessageBytesCount;\n            scheduleDurationLimitTimeout();\n        },\n        /**\n         * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n         *\n         * This function can be called asynchronously after the message was added, but in this case it\n         * should not be called if a flush event occurred in between.\n         *\n         * @param messageBytesCountDiff - the difference between the estimated message bytes count and\n         * its actual bytes count once added to the pool.\n         */\n        notifyAfterAddMessage(messageBytesCountDiff = 0) {\n            currentBytesCount += messageBytesCountDiff;\n            if (currentMessagesCount >= messagesLimit) {\n                flush('messages_limit');\n            }\n            else if (currentBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n        },\n        /**\n         * Notifies that a message was removed from a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right after removing the message, so no flush\n         * event can happen after removing the message and before `notifyAfterRemoveMessage`.\n         *\n         * @param messageBytesCount - the message bytes count that was added to the pool. Should\n         * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and\n         * `notifyAfterAddMessage`.\n         */\n        notifyAfterRemoveMessage(messageBytesCount) {\n            currentBytesCount -= messageBytesCount;\n            currentMessagesCount -= 1;\n            if (currentMessagesCount === 0) {\n                cancelDurationLimitTimeout();\n            }\n        },\n    };\n}\n//# sourceMappingURL=flushController.js.map","import { instrumentMethod } from '../../tools/instrumentMethod';\nimport { Observable } from '../../tools/observable';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nimport { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace';\nimport { getGlobalObject } from '../../tools/globalObject';\nimport { computeRawError, isError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError() {\n    return new Observable((observer) => {\n        const handleRuntimeError = (originalError, stackTrace) => {\n            const rawError = computeRawError({\n                stackTrace,\n                originalError,\n                startClocks: clocksNow(),\n                nonErrorPrefix: \"Uncaught\" /* NonErrorPrefix.UNCAUGHT */,\n                source: ErrorSource.SOURCE,\n                handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n            });\n            observer.notify(rawError);\n        };\n        const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError);\n        const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError);\n        return () => {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        };\n    });\n}\nexport function instrumentOnError(callback) {\n    return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {\n        let stackTrace;\n        if (!isError(errorObj)) {\n            stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column);\n        }\n        callback(errorObj !== null && errorObj !== void 0 ? errorObj : messageObj, stackTrace);\n    });\n}\nexport function instrumentUnhandledRejection(callback) {\n    return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {\n        callback(e.reason || 'Empty reason');\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { BufferedObservable } from '../tools/observable';\nimport { trackRuntimeError } from './error/trackRuntimeError';\nconst BUFFER_LIMIT = 500;\nexport function startBufferingData(trackRuntimeErrorImpl = trackRuntimeError) {\n    const observable = new BufferedObservable(BUFFER_LIMIT);\n    const runtimeErrorSubscription = trackRuntimeErrorImpl().subscribe((error) => {\n        observable.notify({\n            type: 0 /* BufferedDataType.RUNTIME_ERROR */,\n            error,\n        });\n    });\n    return {\n        observable,\n        stop: () => {\n            runtimeErrorSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=bufferedData.js.map","import { computeBytesCount } from './utils/byteUtils';\nexport function createIdentityEncoder() {\n    let output = '';\n    let outputBytesCount = 0;\n    return {\n        isAsync: false,\n        get isEmpty() {\n            return !output;\n        },\n        write(data, callback) {\n            const additionalEncodedBytesCount = computeBytesCount(data);\n            outputBytesCount += additionalEncodedBytesCount;\n            output += data;\n            if (callback) {\n                callback(additionalEncodedBytesCount);\n            }\n        },\n        finish(callback) {\n            callback(this.finishSync());\n        },\n        finishSync() {\n            const result = {\n                output,\n                outputBytesCount,\n                rawBytesCount: outputBytesCount,\n                pendingData: '',\n            };\n            output = '';\n            outputBytesCount = 0;\n            return result;\n        },\n        estimateEncodedBytesCount(data) {\n            return data.length;\n        },\n    };\n}\n//# sourceMappingURL=encoder.js.map","import { addTelemetryUsage } from '../telemetry';\nimport { monitor } from '../../tools/monitor';\nexport function defineContextMethod(getStrategy, contextName, methodName, usage) {\n    return monitor((...args) => {\n        if (usage) {\n            addTelemetryUsage({ feature: usage });\n        }\n        return getStrategy()[contextName][methodName](...args);\n    });\n}\nexport function bufferContextCalls(preStartContextManager, name, bufferApiCalls) {\n    preStartContextManager.changeObservable.subscribe(() => {\n        const context = preStartContextManager.getContext();\n        bufferApiCalls.add((startResult) => startResult[name].setContext(context));\n    });\n}\n//# sourceMappingURL=defineContextMethod.js.map","// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes\nexport const CustomerContextKey = {\n    userContext: 'userContext',\n    globalContext: 'globalContext',\n    accountContext: 'accountContext',\n};\n// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes\nexport const ContextManagerMethod = {\n    getContext: 'getContext',\n    setContext: 'setContext',\n    setContextProperty: 'setContextProperty',\n    removeContextProperty: 'removeContextProperty',\n    clearContext: 'clearContext',\n};\n//# sourceMappingURL=contextConstants.js.map","import { display } from '../tools/display';\nexport function displayAlreadyInitializedError(sdkName, initConfiguration) {\n    if (!initConfiguration.silentMultipleInit) {\n        display.error(`${sdkName} is already initialized.`);\n    }\n}\n//# sourceMappingURL=displayAlreadyInitializedError.js.map","export const RumEventType = {\n    ACTION: 'action',\n    ERROR: 'error',\n    LONG_TASK: 'long_task',\n    VIEW: 'view',\n    RESOURCE: 'resource',\n    VITAL: 'vital',\n};\nexport const RumLongTaskEntryType = {\n    LONG_TASK: 'long-task',\n    LONG_ANIMATION_FRAME: 'long-animation-frame',\n};\nexport const ViewLoadingType = {\n    INITIAL_LOAD: 'initial_load',\n    ROUTE_CHANGE: 'route_change',\n    BF_CACHE: 'bf_cache',\n};\nexport const ActionType = {\n    CLICK: 'click',\n    CUSTOM: 'custom',\n};\nexport const FrustrationType = {\n    RAGE_CLICK: 'rage_click',\n    ERROR_CLICK: 'error_click',\n    DEAD_CLICK: 'dead_click',\n};\nexport const VitalType = {\n    DURATION: 'duration',\n    OPERATION_STEP: 'operation_step',\n};\n//# sourceMappingURL=rawRumEvent.types.js.map","/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder) {\n    return placeholder\n        ? // eslint-disable-next-line  no-bitwise\n            (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)\n        : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID);\n}\nconst COMMA_SEPARATED_KEY_VALUE = /([\\w-]+)\\s*=\\s*([^;]+)/g;\nexport function findCommaSeparatedValue(rawString, name) {\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    while (true) {\n        const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            if (match[1] === name) {\n                return match[2];\n            }\n        }\n        else {\n            break;\n        }\n    }\n}\nexport function findCommaSeparatedValues(rawString) {\n    const result = new Map();\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    while (true) {\n        const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            result.set(match[1], match[2]);\n        }\n        else {\n            break;\n        }\n    }\n    return result;\n}\nexport function safeTruncate(candidate, length, suffix = '') {\n    const lastChar = candidate.charCodeAt(length - 1);\n    const isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    const correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength) {\n        return candidate;\n    }\n    return `${candidate.slice(0, correctedLength)}${suffix}`;\n}\n//# sourceMappingURL=stringUtils.js.map","import { clocksNow, combine, elapsed, ExperimentalFeature, generateUUID, isExperimentalFeatureEnabled, sanitize, toServerDuration, } from '@datadog/browser-core';\nimport { RumEventType, VitalType } from '../../rawRumEvent.types';\nexport function createCustomVitalsState() {\n    const vitalsByName = new Map();\n    const vitalsByReference = new WeakMap();\n    return { vitalsByName, vitalsByReference };\n}\nexport function startVitalCollection(lifeCycle, pageStateHistory, customVitalsState) {\n    function isValid(vital) {\n        return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, vital.startClocks.relative, vital.duration);\n    }\n    function addDurationVital(vital) {\n        if (isValid(vital)) {\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processVital(vital));\n        }\n    }\n    function addOperationStepVital(name, stepType, options, failureReason) {\n        if (!isExperimentalFeatureEnabled(ExperimentalFeature.FEATURE_OPERATION_VITAL)) {\n            return;\n        }\n        const { operationKey, context, description } = options || {};\n        const vital = {\n            name,\n            type: VitalType.OPERATION_STEP,\n            operationKey,\n            failureReason,\n            stepType,\n            startClocks: clocksNow(),\n            context: sanitize(context),\n            description,\n        };\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processVital(vital));\n    }\n    return {\n        addOperationStepVital,\n        addDurationVital,\n        startDurationVital: (name, options = {}) => startDurationVital(customVitalsState, name, options),\n        stopDurationVital: (nameOrRef, options = {}) => {\n            stopDurationVital(addDurationVital, customVitalsState, nameOrRef, options);\n        },\n    };\n}\nexport function startDurationVital({ vitalsByName, vitalsByReference }, name, options = {}) {\n    const vital = {\n        name,\n        startClocks: clocksNow(),\n        ...options,\n    };\n    // To avoid leaking implementation details of the vital, we return a reference to it.\n    const reference = { __dd_vital_reference: true };\n    vitalsByName.set(name, vital);\n    // To avoid memory leaks caused by the creation of numerous references (e.g., from improper useEffect implementations), we use a WeakMap.\n    vitalsByReference.set(reference, vital);\n    return reference;\n}\nexport function stopDurationVital(stopCallback, { vitalsByName, vitalsByReference }, nameOrRef, options = {}) {\n    const vitalStart = typeof nameOrRef === 'string' ? vitalsByName.get(nameOrRef) : vitalsByReference.get(nameOrRef);\n    if (!vitalStart) {\n        return;\n    }\n    stopCallback(buildDurationVital(vitalStart, vitalStart.startClocks, options, clocksNow()));\n    if (typeof nameOrRef === 'string') {\n        vitalsByName.delete(nameOrRef);\n    }\n    else {\n        vitalsByReference.delete(nameOrRef);\n    }\n}\nfunction buildDurationVital(vitalStart, startClocks, stopOptions, stopClocks) {\n    var _a;\n    return {\n        name: vitalStart.name,\n        type: VitalType.DURATION,\n        startClocks,\n        duration: elapsed(startClocks.timeStamp, stopClocks.timeStamp),\n        context: combine(vitalStart.context, stopOptions.context),\n        description: (_a = stopOptions.description) !== null && _a !== void 0 ? _a : vitalStart.description,\n    };\n}\nfunction processVital(vital) {\n    const { startClocks, type, name, description, context } = vital;\n    const vitalData = {\n        id: generateUUID(),\n        type,\n        name,\n        description,\n        ...(type === VitalType.DURATION\n            ? { duration: toServerDuration(vital.duration) }\n            : {\n                step_type: vital.stepType,\n                operation_key: vital.operationKey,\n                failure_reason: vital.failureReason,\n            }),\n    };\n    return {\n        rawRumEvent: {\n            date: startClocks.timeStamp,\n            vital: vitalData,\n            type: RumEventType.VITAL,\n            context,\n        },\n        startTime: startClocks.relative,\n        duration: type === VitalType.DURATION ? vital.duration : undefined,\n        domainContext: {},\n    };\n}\n//# sourceMappingURL=vitalCollection.js.map","export function callPluginsMethod(plugins, methodName, parameter) {\n    if (!plugins) {\n        return;\n    }\n    for (const plugin of plugins) {\n        const method = plugin[methodName];\n        if (method) {\n            method(parameter);\n        }\n    }\n}\n//# sourceMappingURL=plugins.js.map","export function removeDuplicates(array) {\n    const set = new Set();\n    array.forEach((item) => set.add(item));\n    return Array.from(set);\n}\nexport function removeItem(array, item) {\n    const index = array.indexOf(item);\n    if (index >= 0) {\n        array.splice(index, 1);\n    }\n}\nexport function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrayUtils.js.map","import { removeItem } from './utils/arrayUtils';\nconst BUFFER_LIMIT = 500;\n/**\n * createBoundedBuffer creates a BoundedBuffer.\n *\n * @deprecated Use `BufferedObservable` instead.\n */\nexport function createBoundedBuffer() {\n    const buffer = [];\n    const add = (callback) => {\n        const length = buffer.push(callback);\n        if (length > BUFFER_LIMIT) {\n            buffer.splice(0, 1);\n        }\n    };\n    const remove = (callback) => {\n        removeItem(buffer, callback);\n    };\n    const drain = (arg) => {\n        buffer.forEach((callback) => callback(arg));\n        buffer.length = 0;\n    };\n    return {\n        add,\n        remove,\n        drain,\n    };\n}\n//# sourceMappingURL=boundedBuffer.js.map","import { addEventListener } from '../../browser/addEventListener';\nimport { combine } from '../../tools/mergeInto';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\nconst CONTEXT_STORE_KEY_PREFIX = '_dd_c';\nconst storageListeners = [];\nexport function storeContextManager(configuration, contextManager, productKey, customerDataType) {\n    const storageKey = buildStorageKey(productKey, customerDataType);\n    storageListeners.push(addEventListener(configuration, window, \"storage\" /* DOM_EVENT.STORAGE */, ({ key }) => {\n        if (storageKey === key) {\n            synchronizeWithStorage();\n        }\n    }));\n    contextManager.changeObservable.subscribe(dumpToStorage);\n    const contextFromStorage = combine(getFromStorage(), contextManager.getContext());\n    if (!isEmptyObject(contextFromStorage)) {\n        contextManager.setContext(contextFromStorage);\n    }\n    function synchronizeWithStorage() {\n        contextManager.setContext(getFromStorage());\n    }\n    function dumpToStorage() {\n        localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()));\n    }\n    function getFromStorage() {\n        const rawContext = localStorage.getItem(storageKey);\n        return rawContext ? JSON.parse(rawContext) : {};\n    }\n}\nexport function buildStorageKey(productKey, customerDataType) {\n    return `${CONTEXT_STORE_KEY_PREFIX}_${productKey}_${customerDataType}`;\n}\nexport function removeStorageListeners() {\n    storageListeners.map((listener) => listener.stop());\n}\n//# sourceMappingURL=storeContextManager.js.map","import { deepClone } from '../../tools/mergeInto';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { Observable } from '../../tools/observable';\nimport { display } from '../../tools/display';\nimport { checkContext } from './contextUtils';\nfunction ensureProperties(context, propertiesConfig, name) {\n    const newContext = { ...context };\n    for (const [key, { required, type }] of Object.entries(propertiesConfig)) {\n        /**\n         * Ensure specified properties are strings as defined here:\n         * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n         */\n        if (type === 'string' && !isDefined(newContext[key])) {\n            /* eslint-disable @typescript-eslint/no-base-to-string */\n            newContext[key] = String(newContext[key]);\n        }\n        if (required && isDefined(newContext[key])) {\n            display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`);\n        }\n    }\n    return newContext;\n}\nfunction isDefined(value) {\n    return value === undefined || value === null || value === '';\n}\nexport function createContextManager(name = '', { propertiesConfig = {}, } = {}) {\n    let context = {};\n    const changeObservable = new Observable();\n    const contextManager = {\n        getContext: () => deepClone(context),\n        setContext: (newContext) => {\n            if (checkContext(newContext)) {\n                context = sanitize(ensureProperties(newContext, propertiesConfig, name));\n            }\n            else {\n                contextManager.clearContext();\n            }\n            changeObservable.notify();\n        },\n        setContextProperty: (key, property) => {\n            context = sanitize(ensureProperties({ ...context, [key]: property }, propertiesConfig, name));\n            changeObservable.notify();\n        },\n        removeContextProperty: (key) => {\n            delete context[key];\n            ensureProperties(context, propertiesConfig, name);\n            changeObservable.notify();\n        },\n        clearContext: () => {\n            context = {};\n            changeObservable.notify();\n        },\n        changeObservable,\n    };\n    return contextManager;\n}\n//# sourceMappingURL=contextManager.js.map","import { display } from '../../tools/display';\nimport { getType } from '../../tools/utils/typeUtils';\n/**\n * Simple check to ensure an object is a valid context\n */\nexport function checkContext(maybeContext) {\n    const isValid = getType(maybeContext) === 'object';\n    if (!isValid) {\n        display.error('Unsupported context:', maybeContext);\n    }\n    return isValid;\n}\n//# sourceMappingURL=contextUtils.js.map","import { storeContextManager } from '../context/storeContextManager';\nimport { createContextManager } from '../context/contextManager';\nexport function startGlobalContext(hooks, configuration, productKey, useContextNamespace) {\n    const globalContextManager = buildGlobalContextManager();\n    if (configuration.storeContextsAcrossPages) {\n        storeContextManager(configuration, globalContextManager, productKey, 2 /* CustomerDataType.GlobalContext */);\n    }\n    hooks.register(0 /* HookNames.Assemble */, () => {\n        const context = globalContextManager.getContext();\n        return useContextNamespace ? { context } : context;\n    });\n    return globalContextManager;\n}\nexport function buildGlobalContextManager() {\n    return createContextManager('global context');\n}\n//# sourceMappingURL=globalContext.js.map","import { storeContextManager } from '../context/storeContextManager';\nimport { SKIPPED } from '../../tools/abstractHooks';\nimport { createContextManager } from '../context/contextManager';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\nexport function startUserContext(hooks, configuration, sessionManager, productKey) {\n    const userContextManager = buildUserContextManager();\n    if (configuration.storeContextsAcrossPages) {\n        storeContextManager(configuration, userContextManager, productKey, 1 /* CustomerDataType.User */);\n    }\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType, startTime }) => {\n        const user = userContextManager.getContext();\n        const session = sessionManager.findTrackedSession(startTime);\n        if (session && session.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {\n            user.anonymous_id = session.anonymousId;\n        }\n        if (isEmptyObject(user)) {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            usr: user,\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, ({ startTime }) => {\n        var _a;\n        return ({\n            anonymous_id: (_a = sessionManager.findTrackedSession(startTime)) === null || _a === void 0 ? void 0 : _a.anonymousId,\n        });\n    });\n    return userContextManager;\n}\nexport function buildUserContextManager() {\n    return createContextManager('user', {\n        propertiesConfig: {\n            id: { type: 'string' },\n            name: { type: 'string' },\n            email: { type: 'string' },\n        },\n    });\n}\n//# sourceMappingURL=userContext.js.map","import { storeContextManager } from '../context/storeContextManager';\nimport { SKIPPED } from '../../tools/abstractHooks';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { createContextManager } from '../context/contextManager';\nexport function startAccountContext(hooks, configuration, productKey) {\n    const accountContextManager = buildAccountContextManager();\n    if (configuration.storeContextsAcrossPages) {\n        storeContextManager(configuration, accountContextManager, productKey, 4 /* CustomerDataType.Account */);\n    }\n    hooks.register(0 /* HookNames.Assemble */, () => {\n        const account = accountContextManager.getContext();\n        if (isEmptyObject(account) || !account.id) {\n            return SKIPPED;\n        }\n        return {\n            account,\n        };\n    });\n    return accountContextManager;\n}\nexport function buildAccountContextManager() {\n    return createContextManager('account', {\n        propertiesConfig: {\n            id: { type: 'string', required: true },\n            name: { type: 'string' },\n        },\n    });\n}\n//# sourceMappingURL=accountContext.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nimport { globalObject } from '../tools/globalObject';\nlet fetchObservable;\nexport function initFetchObservable() {\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nexport function resetFetchObservable() {\n    fetchObservable = undefined;\n}\nfunction createFetchObservable() {\n    return new Observable((observable) => {\n        if (!globalObject.fetch) {\n            return;\n        }\n        const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {\n            computeHandlingStack: true,\n        });\n        return stop;\n    });\n}\nfunction beforeSend({ parameters, onPostCall, handlingStack }, observable) {\n    const [input, init] = parameters;\n    let methodFromParams = init && init.method;\n    if (methodFromParams === undefined && input instanceof Request) {\n        methodFromParams = input.method;\n    }\n    const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET';\n    const url = input instanceof Request ? input.url : normalizeUrl(String(input));\n    const startClocks = clocksNow();\n    const context = {\n        state: 'start',\n        init,\n        input,\n        method,\n        startClocks,\n        url,\n        handlingStack,\n    };\n    observable.notify(context);\n    // Those properties can be changed by observable subscribers\n    parameters[0] = context.input;\n    parameters[1] = context.init;\n    onPostCall((responsePromise) => afterSend(observable, responsePromise, context));\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    const context = startContext;\n    function reportFetch(partialContext) {\n        context.state = 'resolve';\n        Object.assign(context, partialContext);\n        observable.notify(context);\n    }\n    responsePromise.then(monitor((response) => {\n        reportFetch({\n            response,\n            responseType: response.type,\n            status: response.status,\n            isAborted: false,\n        });\n    }), monitor((error) => {\n        var _a, _b;\n        reportFetch({\n            status: 0,\n            isAborted: ((_b = (_a = context.init) === null || _a === void 0 ? void 0 : _a.signal) === null || _b === void 0 ? void 0 : _b.aborted) || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),\n            error,\n        });\n    }));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, findCommaSeparatedValues, generateUUID } from '../tools/utils/stringUtils';\nimport { buildUrl } from '../tools/utils/urlPolyfill';\nexport function setCookie(name, value, expireDelay = 0, options) {\n    const date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    const expires = `expires=${date.toUTCString()}`;\n    const sameSite = options && options.crossSite ? 'none' : 'strict';\n    const domain = options && options.domain ? `;domain=${options.domain}` : '';\n    const secure = options && options.secure ? ';secure' : '';\n    const partitioned = options && options.partitioned ? ';partitioned' : '';\n    document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`;\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nlet initCookieParsed;\n/**\n * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)\n * to avoid accessing document.cookie multiple times.\n */\nexport function getInitCookie(name) {\n    if (!initCookieParsed) {\n        initCookieParsed = findCommaSeparatedValues(document.cookie);\n    }\n    return initCookieParsed.get(name);\n}\nexport function resetInitCookies() {\n    initCookieParsed = undefined;\n}\nexport function deleteCookie(name, options) {\n    setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n    if (document.cookie === undefined || document.cookie === null) {\n        return false;\n    }\n    try {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        const testCookieName = `dd_cookie_test_${generateUUID()}`;\n        const testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n        const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n        deleteCookie(testCookieName, options);\n        return isCookieCorrectlySet;\n    }\n    catch (error) {\n        display.error(error);\n        return false;\n    }\n}\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nlet getCurrentSiteCache;\nexport function getCurrentSite(hostname = location.hostname, referrer = document.referrer) {\n    if (getCurrentSiteCache === undefined) {\n        const defaultHostName = getCookieDefaultHostName(hostname, referrer);\n        if (defaultHostName) {\n            // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n            // the test cookie lifetime\n            const testCookieName = `dd_site_test_${generateUUID()}`;\n            const testCookieValue = 'test';\n            const domainLevels = defaultHostName.split('.');\n            let candidateDomain = domainLevels.pop();\n            while (domainLevels.length && !getCookie(testCookieName)) {\n                candidateDomain = `${domainLevels.pop()}.${candidateDomain}`;\n                setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain });\n            }\n            deleteCookie(testCookieName, { domain: candidateDomain });\n            getCurrentSiteCache = candidateDomain;\n        }\n    }\n    return getCurrentSiteCache;\n}\nfunction getCookieDefaultHostName(hostname, referrer) {\n    try {\n        return hostname || buildUrl(referrer).hostname;\n    }\n    catch (_a) {\n        // Ignore\n    }\n}\nexport function resetGetCurrentSite() {\n    getCurrentSiteCache = undefined;\n}\n//# sourceMappingURL=cookie.js.map","import { getInitCookie } from '../../browser/cookie';\nimport { globalObject, isWorkerEnvironment } from '../../tools/globalObject';\nexport const SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function willSyntheticsInjectRum() {\n    if (isWorkerEnvironment) {\n        // We don't expect to run synthetics tests in a worker environment\n        return false;\n    }\n    return Boolean(globalObject._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    const value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    const value = window._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function isSyntheticsTest() {\n    return Boolean(getSyntheticsTestId() && getSyntheticsResultId());\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","export const SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils';\nexport const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\nexport const SESSION_COOKIE_EXPIRATION_DELAY = ONE_YEAR;\nexport const SESSION_NOT_TRACKED = '0';\n/**\n * @internal\n */\nexport const SessionPersistence = {\n    COOKIE: 'cookie',\n    LOCAL_STORAGE: 'local-storage',\n};\n//# sourceMappingURL=sessionConstants.js.map","export const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;\nexport const SESSION_ENTRY_SEPARATOR = '&';\nexport function isValidSessionString(sessionString) {\n    return (!!sessionString &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\n//# sourceMappingURL=sessionStateValidation.js.map","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation';\nexport const EXPIRED = '1';\nexport function getExpiredSessionState(previousSessionState, configuration) {\n    const expiredSessionState = {\n        isExpired: EXPIRED,\n    };\n    if (configuration.trackAnonymousUser) {\n        if (previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId) {\n            expiredSessionState.anonymousId = previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId;\n        }\n        else {\n            expiredSessionState.anonymousId = generateUUID();\n        }\n    }\n    return expiredSessionState;\n}\nexport function isSessionInNotStartedState(session) {\n    return isEmptyObject(session);\n}\nexport function isSessionStarted(session) {\n    return !isSessionInNotStartedState(session);\n}\nexport function isSessionInExpiredState(session) {\n    return session.isExpired !== undefined || !isActiveSession(session);\n}\n// An active session is a session in either `Tracked` or `NotTracked` state\nfunction isActiveSession(sessionState) {\n    // created and expire can be undefined for versions which was not storing them\n    // these checks could be removed when older versions will not be available/live anymore\n    return ((sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&\n        (sessionState.expire === undefined || dateNow() < Number(sessionState.expire)));\n}\nexport function expandSessionState(session) {\n    session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n    return (objectEntries(session)\n        // we use `aid` as a key for anonymousId\n        .map(([key, value]) => (key === 'anonymousId' ? `aid=${value}` : `${key}=${value}`))\n        .join(SESSION_ENTRY_SEPARATOR));\n}\nexport function toSessionState(sessionString) {\n    const session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach((entry) => {\n            const matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                const [, key, value] = matches;\n                if (key === 'aid') {\n                    // we use `aid` as a key for anonymousId\n                    session.anonymousId = value;\n                }\n                else {\n                    session[key] = value;\n                }\n            }\n        });\n    }\n    return session;\n}\n//# sourceMappingURL=sessionState.js.map","import { getInitCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionStarted } from './sessionState';\nexport const OLD_SESSION_COOKIE_NAME = '_dd';\nexport const OLD_RUM_COOKIE_NAME = '_dd_r';\nexport const OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport const RUM_SESSION_KEY = 'rum';\nexport const LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(cookieStoreStrategy) {\n    const sessionString = getInitCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME);\n        const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME);\n        const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME);\n        const session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        if (isSessionStarted(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { isChromium } from '../../../tools/utils/browserDetection';\nimport { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY, SessionPersistence, } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n    const cookieOptions = buildCookieOptions(initConfiguration);\n    return cookieOptions && areCookiesAuthorized(cookieOptions)\n        ? { type: SessionPersistence.COOKIE, cookieOptions }\n        : undefined;\n}\nexport function initCookieStrategy(configuration, cookieOptions) {\n    const cookieStore = {\n        /**\n         * Lock strategy allows mitigating issues due to concurrent access to cookie.\n         * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.\n         */\n        isLockEnabled: isChromium(),\n        persistSession: (sessionState) => storeSessionCookie(cookieOptions, configuration, sessionState, SESSION_EXPIRATION_DELAY),\n        retrieveSession: retrieveSessionCookie,\n        expireSession: (sessionState) => storeSessionCookie(cookieOptions, configuration, getExpiredSessionState(sessionState, configuration), SESSION_TIME_OUT_DELAY),\n    };\n    tryOldCookiesMigration(cookieStore);\n    return cookieStore;\n}\nfunction storeSessionCookie(options, configuration, sessionState, defaultTimeout) {\n    setCookie(SESSION_STORE_KEY, toSessionString(sessionState), configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout, options);\n}\nexport function retrieveSessionCookie() {\n    const sessionString = getCookie(SESSION_STORE_KEY);\n    const sessionState = toSessionState(sessionString);\n    return sessionState;\n}\nexport function buildCookieOptions(initConfiguration) {\n    const cookieOptions = {};\n    cookieOptions.secure =\n        !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        const currentSite = getCurrentSite();\n        if (!currentSite) {\n            return;\n        }\n        cookieOptions.domain = currentSite;\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { SessionPersistence } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nconst LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n    try {\n        const id = generateUUID();\n        const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`;\n        localStorage.setItem(testKey, id);\n        const retrievedId = localStorage.getItem(testKey);\n        localStorage.removeItem(testKey);\n        return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined;\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy(configuration) {\n    return {\n        isLockEnabled: false,\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        expireSession: (sessionState) => expireSessionFromLocalStorage(sessionState, configuration),\n    };\n}\nfunction persistInLocalStorage(sessionState) {\n    localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n    const sessionString = localStorage.getItem(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction expireSessionFromLocalStorage(previousSessionState, configuration) {\n    persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration));\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport const LOCK_RETRY_DELAY = 10;\nexport const LOCK_MAX_TRIES = 100;\n// Locks should be hold for a few milliseconds top, just the time it takes to read and write a\n// cookie. Using one second should be enough in most situations.\nexport const LOCK_EXPIRATION_DELAY = ONE_SECOND;\nconst LOCK_SEPARATOR = '--';\nconst bufferedOperations = [];\nlet ongoingOperations;\nexport function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries = 0) {\n    var _a;\n    const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy;\n    const persistWithLock = (session) => persistSession({ ...session, lock: currentLock });\n    const retrieveStore = () => {\n        const { lock, ...session } = sessionStoreStrategy.retrieveSession();\n        return {\n            session,\n            lock: lock && !isLockExpired(lock) ? lock : undefined,\n        };\n    };\n    if (!ongoingOperations) {\n        ongoingOperations = operations;\n    }\n    if (operations !== ongoingOperations) {\n        bufferedOperations.push(operations);\n        return;\n    }\n    if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {\n        next(sessionStoreStrategy);\n        return;\n    }\n    let currentLock;\n    let currentStore = retrieveStore();\n    if (isLockEnabled) {\n        // if someone has lock, retry later\n        if (currentStore.lock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n        // acquire lock\n        currentLock = createLock();\n        persistWithLock(currentStore.session);\n        // if lock is not acquired, retry later\n        currentStore = retrieveStore();\n        if (currentStore.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    let processedSession = operations.process(currentStore.session);\n    if (isLockEnabled) {\n        // if lock corrupted after process, retry later\n        currentStore = retrieveStore();\n        if (currentStore.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    if (processedSession) {\n        if (isSessionInExpiredState(processedSession)) {\n            expireSession(processedSession);\n        }\n        else {\n            expandSessionState(processedSession);\n            if (isLockEnabled) {\n                persistWithLock(processedSession);\n            }\n            else {\n                persistSession(processedSession);\n            }\n        }\n    }\n    if (isLockEnabled) {\n        // correctly handle lock around expiration would require to handle this case properly at several levels\n        // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n        if (!(processedSession && isSessionInExpiredState(processedSession))) {\n            // if lock corrupted after persist, retry later\n            currentStore = retrieveStore();\n            if (currentStore.lock !== currentLock) {\n                retryLater(operations, sessionStoreStrategy, numberOfRetries);\n                return;\n            }\n            persistSession(currentStore.session);\n            processedSession = currentStore.session;\n        }\n    }\n    // call after even if session is not persisted in order to perform operations on\n    // up-to-date session state value => the value could have been modified by another tab\n    (_a = operations.after) === null || _a === void 0 ? void 0 : _a.call(operations, processedSession || currentStore.session);\n    next(sessionStoreStrategy);\n}\nfunction retryLater(operations, sessionStore, currentNumberOfRetries) {\n    setTimeout(() => {\n        processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);\n    }, LOCK_RETRY_DELAY);\n}\nfunction next(sessionStore) {\n    ongoingOperations = undefined;\n    const nextOperations = bufferedOperations.shift();\n    if (nextOperations) {\n        processSessionStoreOperations(nextOperations, sessionStore);\n    }\n}\nexport function createLock() {\n    return generateUUID() + LOCK_SEPARATOR + timeStampNow();\n}\nfunction isLockExpired(lock) {\n    const [, timeStamp] = lock.split(LOCK_SEPARATOR);\n    return !timeStamp || elapsed(Number(timeStamp), timeStampNow()) > LOCK_EXPIRATION_DELAY;\n}\n//# sourceMappingURL=sessionStoreOperations.js.map","import { clearInterval, setInterval } from '../../tools/timer';\nimport { Observable } from '../../tools/observable';\nimport { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { display } from '../../tools/display';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { getExpiredSessionState, isSessionInExpiredState, isSessionInNotStartedState, isSessionStarted, } from './sessionState';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\nimport { SESSION_NOT_TRACKED, SessionPersistence } from './sessionConstants';\n/**\n * Every second, the storage will be polled to check for any change that can occur\n * to the session state in another browser tab, or another window.\n * This value has been determined from our previous cookie-only implementation.\n */\nexport const STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Selects the correct session store strategy type based on the configuration and storage\n * availability.\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    switch (initConfiguration.sessionPersistence) {\n        case SessionPersistence.COOKIE:\n            return selectCookieStrategy(initConfiguration);\n        case SessionPersistence.LOCAL_STORAGE:\n            return selectLocalStorageStrategy();\n        case undefined: {\n            let sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n            if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n                sessionStoreStrategyType = selectLocalStorageStrategy();\n            }\n            return sessionStoreStrategyType;\n        }\n        default:\n            display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`);\n    }\n}\nexport function getSessionStoreStrategy(sessionStoreStrategyType, configuration) {\n    return sessionStoreStrategyType.type === SessionPersistence.COOKIE\n        ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy(configuration);\n}\n/**\n * Different session concepts:\n * - tracked, the session has an id and is updated along the user navigation\n * - not tracked, the session does not have an id but it is updated along the user navigation\n * - inactive, no session in store or session expired, waiting for a renew session\n */\nexport function startSessionStore(sessionStoreStrategyType, configuration, productKey, computeTrackingType, sessionStoreStrategy = getSessionStoreStrategy(sessionStoreStrategyType, configuration)) {\n    const renewObservable = new Observable();\n    const expireObservable = new Observable();\n    const sessionStateUpdateObservable = new Observable();\n    const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n    let sessionCache;\n    startSession();\n    const { throttled: throttledExpandOrRenewSession, cancel: cancelExpandOrRenewSession } = throttle(() => {\n        processSessionStoreOperations({\n            process: (sessionState) => {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return;\n                }\n                const synchronizedSession = synchronizeSession(sessionState);\n                expandOrRenewSessionState(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: (sessionState) => {\n                if (isSessionStarted(sessionState) && !hasSessionInCache()) {\n                    renewSessionInCache(sessionState);\n                }\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }, STORAGE_POLL_DELAY);\n    function expandSession() {\n        processSessionStoreOperations({\n            process: (sessionState) => (hasSessionInCache() ? synchronizeSession(sessionState) : undefined),\n        }, sessionStoreStrategy);\n    }\n    /**\n     * allows two behaviors:\n     * - if the session is active, synchronize the session cache without updating the session store\n     * - if the session is not active, clear the session store and expire the session cache\n     */\n    function watchSession() {\n        const sessionState = sessionStoreStrategy.retrieveSession();\n        if (isSessionInExpiredState(sessionState)) {\n            processSessionStoreOperations({\n                process: (sessionState) => isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,\n                after: synchronizeSession,\n            }, sessionStoreStrategy);\n        }\n        else {\n            synchronizeSession(sessionState);\n        }\n    }\n    function synchronizeSession(sessionState) {\n        if (isSessionInExpiredState(sessionState)) {\n            sessionState = getExpiredSessionState(sessionState, configuration);\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(sessionState)) {\n                expireSessionInCache();\n            }\n            else {\n                sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState });\n                sessionCache = sessionState;\n            }\n        }\n        return sessionState;\n    }\n    function startSession() {\n        processSessionStoreOperations({\n            process: (sessionState) => {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return getExpiredSessionState(sessionState, configuration);\n                }\n            },\n            after: (sessionState) => {\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\n    function expandOrRenewSessionState(sessionState) {\n        if (isSessionInNotStartedState(sessionState)) {\n            return false;\n        }\n        const trackingType = computeTrackingType(sessionState[productKey]);\n        sessionState[productKey] = trackingType;\n        delete sessionState.isExpired;\n        if (trackingType !== SESSION_NOT_TRACKED && !sessionState.id) {\n            sessionState.id = generateUUID();\n            sessionState.created = String(dateNow());\n        }\n    }\n    function hasSessionInCache() {\n        return (sessionCache === null || sessionCache === void 0 ? void 0 : sessionCache[productKey]) !== undefined;\n    }\n    function isSessionInCacheOutdated(sessionState) {\n        return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];\n    }\n    function expireSessionInCache() {\n        sessionCache = getExpiredSessionState(sessionCache, configuration);\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function updateSessionState(partialSessionState) {\n        processSessionStoreOperations({\n            process: (sessionState) => ({ ...sessionState, ...partialSessionState }),\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    return {\n        expandOrRenewSession: throttledExpandOrRenewSession,\n        expandSession,\n        getSession: () => sessionCache,\n        renewObservable,\n        expireObservable,\n        sessionStateUpdateObservable,\n        restartSession: startSession,\n        expire: () => {\n            cancelExpandOrRenewSession();\n            sessionStoreStrategy.expireSession(sessionCache);\n            synchronizeSession(getExpiredSessionState(sessionCache, configuration));\n        },\n        stop: () => {\n            clearInterval(watchSessionTimeoutId);\n        },\n        updateSessionState,\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { display } from './display';\nimport { getType } from './utils/typeUtils';\nexport function isMatchOption(item) {\n    const itemType = getType(item);\n    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;\n}\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list, value, useStartsWith = false) {\n    return list.some((item) => {\n        try {\n            if (typeof item === 'function') {\n                return item(value);\n            }\n            else if (item instanceof RegExp) {\n                return item.test(value);\n            }\n            else if (typeof item === 'string') {\n                return useStartsWith ? value.startsWith(item) : item === value;\n            }\n        }\n        catch (e) {\n            display.error(e);\n        }\n        return false;\n    });\n}\n//# sourceMappingURL=matchOption.js.map","export const EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://'];\nexport function containsExtensionUrl(str) {\n    return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix));\n}\n/**\n * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.\n *\n * @param windowLocation - The current window location to check\n * @param stack - The error stack to check for extension URLs\n * @returns true if running in an unsupported browser extension environment\n */\nexport function isUnsupportedExtensionEnvironment(windowLocation, stack = '') {\n    // If the page itself is an extension page.\n    if (containsExtensionUrl(windowLocation)) {\n        return false;\n    }\n    // Since we generate the error on the init, we check the 2nd frame line.\n    const frameLines = stack.split('\\n').filter((line) => {\n        const trimmedLine = line.trim();\n        return trimmedLine.length && /^at\\s+|@/.test(trimmedLine);\n    });\n    const target = frameLines[1] || '';\n    return containsExtensionUrl(target);\n}\n//# sourceMappingURL=extensionUtils.js.map","import { display } from '../tools/display';\nimport { matchList } from '../tools/matchOption';\nimport { isUnsupportedExtensionEnvironment } from './extension/extensionUtils';\nexport const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN = 'Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.';\nexport const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = 'SDK initialized on a non-allowed domain.';\nexport function isAllowedTrackingOrigins(configuration, errorStack, windowOrigin = typeof location !== 'undefined' ? location.origin : '') {\n    const allowedTrackingOrigins = configuration.allowedTrackingOrigins;\n    if (!allowedTrackingOrigins) {\n        if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {\n            display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN);\n            return false;\n        }\n        return true;\n    }\n    const isAllowed = matchList(allowedTrackingOrigins, windowOrigin);\n    if (!isAllowed) {\n        display.error(ERROR_NOT_ALLOWED_TRACKING_ORIGIN);\n    }\n    return isAllowed;\n}\n//# sourceMappingURL=allowedTrackingOrigins.js.map","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_FED_STAGING, INTAKE_SITE_US1, PCI_INTAKE_HOST_US1 } from '../intakeSites';\nexport function createEndpointBuilder(initConfiguration, trackType, extraParameters) {\n    const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType);\n    return {\n        build(api, payload) {\n            const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters);\n            return buildUrlWithParameters(parameters);\n        },\n        trackType,\n    };\n}\n/**\n * Create a function used to build a full endpoint url from provided parameters. The goal of this\n * function is to pre-compute some parts of the URL to avoid re-computing everything on every\n * request, as only parameters are changing.\n */\nfunction createEndpointUrlWithParametersBuilder(initConfiguration, trackType) {\n    const path = `/api/v2/${trackType}`;\n    const proxy = initConfiguration.proxy;\n    if (typeof proxy === 'string') {\n        const normalizedProxyUrl = normalizeUrl(proxy);\n        return (parameters) => `${normalizedProxyUrl}?ddforward=${encodeURIComponent(`${path}?${parameters}`)}`;\n    }\n    if (typeof proxy === 'function') {\n        return (parameters) => proxy({ path, parameters });\n    }\n    const host = buildEndpointHost(trackType, initConfiguration);\n    return (parameters) => `https://${host}${path}?${parameters}`;\n}\nexport function buildEndpointHost(trackType, initConfiguration) {\n    const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration;\n    if (trackType === 'logs' && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {\n        return PCI_INTAKE_HOST_US1;\n    }\n    if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n        return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`;\n    }\n    if (site === INTAKE_SITE_FED_STAGING) {\n        return `http-intake.logs.${site}`;\n    }\n    const domainParts = site.split('.');\n    const extension = domainParts.pop();\n    return `browser-intake-${domainParts.join('-')}.${extension}`;\n}\n/**\n * Build parameters to be used for an intake request. Parameters should be re-built for each\n * request, as they change randomly.\n */\nfunction buildEndpointParameters({ clientToken, internalAnalyticsSubdomain, source = 'browser' }, trackType, api, { retry, encoding }, extraParameters = []) {\n    const parameters = [\n        `ddsource=${source}`,\n        `dd-api-key=${clientToken}`,\n        `dd-evp-origin-version=${encodeURIComponent(\"6.22.0\")}`,\n        'dd-evp-origin=browser',\n        `dd-request-id=${generateUUID()}`,\n    ].concat(extraParameters);\n    if (encoding) {\n        parameters.push(`dd-evp-encoding=${encoding}`);\n    }\n    if (trackType === 'rum') {\n        parameters.push(`batch_time=${timeStampNow()}`, `_dd.api=${api}`);\n        if (retry) {\n            parameters.push(`_dd.retry_count=${retry.count}`, `_dd.retry_after=${retry.lastFailureStatus}`);\n        }\n    }\n    if (internalAnalyticsSubdomain) {\n        parameters.reverse();\n    }\n    return parameters.join('&');\n}\n//# sourceMappingURL=endpointBuilder.js.map","import { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from '../intakeSites';\nimport { createEndpointBuilder } from './endpointBuilder';\nexport function computeTransportConfiguration(initConfiguration) {\n    const site = initConfiguration.site || INTAKE_SITE_US1;\n    const source = validateSource(initConfiguration.source);\n    const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source });\n    const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source });\n    return {\n        replica: replicaConfiguration,\n        site,\n        source,\n        ...endpointBuilders,\n    };\n}\nfunction validateSource(source) {\n    if (source === 'flutter' || source === 'unity') {\n        return source;\n    }\n    return 'browser';\n}\nfunction computeEndpointBuilders(initConfiguration) {\n    return {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),\n        profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),\n        exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    const replicaConfiguration = {\n        ...initConfiguration,\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    };\n    return {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [\n            `application.id=${initConfiguration.replica.applicationId}`,\n        ]),\n    };\n}\nexport function isIntakeUrl(url) {\n    // check if tags is present in the query string\n    return INTAKE_URL_PARAMETERS.every((param) => url.includes(param));\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display';\nimport { ONE_SECOND } from '../../tools/utils/timeUtils';\nimport { isPercentage } from '../../tools/utils/numberUtils';\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { objectHasValue } from '../../tools/utils/objectUtils';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { TrackingConsent } from '../trackingConsent';\nimport { isAllowedTrackingOrigins } from '../allowedTrackingOrigins';\nimport { isWorkerEnvironment } from '../../tools/globalObject';\nimport { computeTransportConfiguration } from './transportConfiguration';\n/**\n * Default privacy level for the browser SDK.\n *\n * [Replay Privacy Options](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser/privacy_options) for further information.\n */\nexport const DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n    MASK_UNLESS_ALLOWLISTED: 'mask-unless-allowlisted',\n};\n/**\n * Trace context injection option.\n *\n * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n */\nexport const TraceContextInjection = {\n    ALL: 'all',\n    SAMPLED: 'sampled',\n};\nfunction isString(tag, tagName) {\n    if (tag !== undefined && tag !== null && typeof tag !== 'string') {\n        display.error(`${tagName} must be defined as a string`);\n        return false;\n    }\n    return true;\n}\nfunction isDatadogSite(site) {\n    if (site && typeof site === 'string' && !/(datadog|ddog|datad0g|dd0g)/.test(site)) {\n        display.error(`Site should be a valid Datadog site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`);\n        return false;\n    }\n    return true;\n}\nexport function isSampleRate(sampleRate, name) {\n    if (sampleRate !== undefined && !isPercentage(sampleRate)) {\n        display.error(`${name} Sample Rate should be a number between 0 and 100`);\n        return false;\n    }\n    return true;\n}\nexport function validateAndBuildConfiguration(initConfiguration, errorStack) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    if (initConfiguration.allowedTrackingOrigins !== undefined &&\n        !Array.isArray(initConfiguration.allowedTrackingOrigins)) {\n        display.error('Allowed Tracking Origins must be an array');\n        return;\n    }\n    if (!isDatadogSite(initConfiguration.site) ||\n        !isSampleRate(initConfiguration.sessionSampleRate, 'Session') ||\n        !isSampleRate(initConfiguration.telemetrySampleRate, 'Telemetry') ||\n        !isSampleRate(initConfiguration.telemetryConfigurationSampleRate, 'Telemetry Configuration') ||\n        !isSampleRate(initConfiguration.telemetryUsageSampleRate, 'Telemetry Usage') ||\n        !isString(initConfiguration.version, 'Version') ||\n        !isString(initConfiguration.env, 'Env') ||\n        !isString(initConfiguration.service, 'Service') ||\n        !isAllowedTrackingOrigins(initConfiguration, errorStack !== null && errorStack !== void 0 ? errorStack : '')) {\n        return;\n    }\n    if (initConfiguration.trackingConsent !== undefined &&\n        !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)) {\n        display.error('Tracking Consent should be either \"granted\" or \"not-granted\"');\n        return;\n    }\n    return {\n        beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n        sessionStoreStrategyType: isWorkerEnvironment ? undefined : selectSessionStoreStrategyType(initConfiguration),\n        sessionSampleRate: (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\n        telemetryUsageSampleRate: (_d = initConfiguration.telemetryUsageSampleRate) !== null && _d !== void 0 ? _d : 5,\n        service: (_e = initConfiguration.service) !== null && _e !== void 0 ? _e : undefined,\n        env: (_f = initConfiguration.env) !== null && _f !== void 0 ? _f : undefined,\n        version: (_g = initConfiguration.version) !== null && _g !== void 0 ? _g : undefined,\n        datacenter: (_h = initConfiguration.datacenter) !== null && _h !== void 0 ? _h : undefined,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\n        allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,\n        trackingConsent: (_j = initConfiguration.trackingConsent) !== null && _j !== void 0 ? _j : TrackingConsent.GRANTED,\n        trackAnonymousUser: (_k = initConfiguration.trackAnonymousUser) !== null && _k !== void 0 ? _k : true,\n        storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,\n        /**\n         * beacon payload max queue size implementation is 64kb\n         * ensure that we leave room for logs, rum and potential other users\n         */\n        batchBytesLimit: 16 * ONE_KIBI_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxTelemetryEventsPerPage: 15,\n        /**\n         * flush automatically, aim to be lower than ALB connection timeout\n         * to maximize connection reuse.\n         */\n        flushTimeout: (30 * ONE_SECOND),\n        /**\n         * Logs intake limit. When using the SDK in a Worker Environment, we\n         * limit the batch size to 1 to ensure it can be sent in a single event.\n         */\n        batchMessagesLimit: isWorkerEnvironment ? 1 : 50,\n        messageBytesLimit: 256 * ONE_KIBI_BYTE,\n        /**\n         * The source of the SDK, used for support plugins purposes.\n         */\n        variant: initConfiguration.variant,\n        sdkVersion: initConfiguration.sdkVersion,\n        ...computeTransportConfiguration(initConfiguration),\n    };\n}\nexport function serializeConfiguration(initConfiguration) {\n    return {\n        session_sample_rate: initConfiguration.sessionSampleRate,\n        telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n        telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,\n        use_before_send: !!initConfiguration.beforeSend,\n        use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,\n        use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n        use_proxy: !!initConfiguration.proxy,\n        silent_multiple_init: initConfiguration.silentMultipleInit,\n        track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n        track_anonymous_user: initConfiguration.trackAnonymousUser,\n        session_persistence: initConfiguration.sessionPersistence,\n        allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,\n        store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,\n        allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,\n        tracking_consent: initConfiguration.trackingConsent,\n        use_allowed_tracking_origins: Array.isArray(initConfiguration.allowedTrackingOrigins),\n        source: initConfiguration.source,\n        sdk_version: initConfiguration.sdkVersion,\n        variant: initConfiguration.variant,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { performDraw } from '@datadog/browser-core';\nconst sampleDecisionCache = new Map();\nexport function isSampled(sessionId, sampleRate) {\n    // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for\n    // customers willing to ingest all traces.\n    if (sampleRate === 100) {\n        return true;\n    }\n    if (sampleRate === 0) {\n        return false;\n    }\n    const cachedDecision = sampleDecisionCache.get(sampleRate);\n    if (cachedDecision && sessionId === cachedDecision.sessionId) {\n        return cachedDecision.decision;\n    }\n    let decision;\n    // @ts-expect-error BigInt might not be defined in every browser we support\n    if (window.BigInt) {\n        decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate);\n    }\n    else {\n        // For simplicity, we don't use consistent sampling for browser without BigInt support\n        // TODO: remove this when all browser we support have BigInt support\n        decision = performDraw(sampleRate);\n    }\n    sampleDecisionCache.set(sampleRate, { sessionId, decision });\n    return decision;\n}\n// Exported for tests\nexport function resetSampleDecisionCache() {\n    sampleDecisionCache.clear();\n}\n/**\n * Perform sampling using the Knuth factor method. This method offer consistent sampling result\n * based on the provided identifier.\n *\n * @param identifier - The identifier to use for sampling.\n * @param sampleRate - The sample rate in percentage between 0 and 100.\n */\nexport function sampleUsingKnuthFactor(identifier, sampleRate) {\n    // The formula is:\n    //\n    //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64\n    //\n    // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the\n    // modulo would be incorrect. Thus, we are using BigInts here.\n    //\n    // Implementation in other languages:\n    // * Go     https://github.com/DataDog/dd-trace-go/blob/ec6fbb1f2d517b7b8e69961052adf7136f3af773/ddtrace/tracer/sampler.go#L86-L91\n    // * Python https://github.com/DataDog/dd-trace-py/blob/0cee2f066fb6e79aa15947c1514c0f406dea47c5/ddtrace/sampling_rule.py#L197\n    // * Ruby   https://github.com/DataDog/dd-trace-rb/blob/1a6e255cdcb7e7e22235ea5955f90f6dfa91045d/lib/datadog/tracing/sampling/rate_sampler.rb#L42\n    // * C++    https://github.com/DataDog/dd-trace-cpp/blob/159629edc438ae45f2bb318eb7bd51abd05e94b5/src/datadog/trace_sampler.cpp#L58\n    // * Java   https://github.com/DataDog/dd-trace-java/blob/896dd6b380533216e0bdee59614606c8272d313e/dd-trace-core/src/main/java/datadog/trace/common/sampling/DeterministicSampler.java#L48\n    //\n    // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and\n    // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation\n    // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less\n    // BigInt arithmetic to write. In practice this does not matter, as we are using floating point\n    // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).\n    const knuthFactor = BigInt('1111111111111111111');\n    const twoPow64 = BigInt('0x10000000000000000'); // 2n ** 64n\n    const hash = (identifier * knuthFactor) % twoPow64;\n    return Number(hash) <= (sampleRate / 100) * Number(twoPow64);\n}\n//# sourceMappingURL=sampler.js.map","export function createTraceIdentifier() {\n    return createIdentifier(64);\n}\nexport function createSpanIdentifier() {\n    return createIdentifier(63);\n}\nfunction createIdentifier(bits) {\n    const buffer = crypto.getRandomValues(new Uint32Array(2));\n    if (bits === 63) {\n        // eslint-disable-next-line no-bitwise\n        buffer[buffer.length - 1] >>>= 1; // force 63-bit\n    }\n    // The `.toString` function is intentionally similar to Number and BigInt `.toString` method.\n    //\n    // JavaScript numbers can represent integers up to 48 bits, this is why we need two of them to\n    // represent a 64 bits identifier. But BigInts don't have this limitation and can represent larger\n    // integer values.\n    //\n    // In the future, when we drop browsers without BigInts support, we could use BigInts directly\n    // represent identifiers by simply returning a BigInt from this function (as all we need is a\n    // value with a `.toString` method).\n    //\n    // Examples:\n    //   const buffer = getCrypto().getRandomValues(new Uint32Array(2))\n    //   return BigInt(buffer[0]) + BigInt(buffer[1]) << 32n\n    //\n    //   // Alternative with BigUint64Array (different Browser support than plain bigints!):\n    //   return crypto.getRandomValues(new BigUint64Array(1))[0]\n    //\n    // For now, let's keep using two plain numbers as having two different implementations (one for\n    // browsers with BigInt support and one for older browsers) don't bring much value.\n    return {\n        toString(radix = 10) {\n            let high = buffer[1];\n            let low = buffer[0];\n            let str = '';\n            do {\n                const mod = (high % radix) * 4294967296 + low;\n                high = Math.floor(high / radix);\n                low = Math.floor(mod / radix);\n                str = (mod % radix).toString(radix) + str;\n            } while (high || low);\n            return str;\n        },\n    };\n}\nexport function toPaddedHexadecimalString(id) {\n    return id.toString(16).padStart(16, '0');\n}\n//# sourceMappingURL=identifier.js.map","import { objectEntries, shallowClone, getType, isMatchOption, matchList, TraceContextInjection, } from '@datadog/browser-core';\nimport { isSampled } from '../sampler/sampler';\nimport { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier';\nexport function isTracingOption(item) {\n    const expectedItem = item;\n    return (getType(expectedItem) === 'object' &&\n        isMatchOption(expectedItem.match) &&\n        Array.isArray(expectedItem.propagatorTypes));\n}\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course, it might not be the case every time, but it should limit having incomplete traces a\n * bit.\n * */\nexport function clearTracingIfNeeded(context) {\n    if (context.status === 0 && !context.isAborted) {\n        context.traceId = undefined;\n        context.spanId = undefined;\n        context.traceSampled = undefined;\n    }\n}\nexport function startTracer(configuration, sessionManager, userContext, accountContext) {\n    return {\n        clearTracingIfNeeded,\n        traceFetch: (context) => injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, (tracingHeaders) => {\n            var _a;\n            if (context.input instanceof Request && !((_a = context.init) === null || _a === void 0 ? void 0 : _a.headers)) {\n                context.input = new Request(context.input);\n                Object.keys(tracingHeaders).forEach((key) => {\n                    ;\n                    context.input.headers.append(key, tracingHeaders[key]);\n                });\n            }\n            else {\n                context.init = shallowClone(context.init);\n                const headers = [];\n                if (context.init.headers instanceof Headers) {\n                    context.init.headers.forEach((value, key) => {\n                        headers.push([key, value]);\n                    });\n                }\n                else if (Array.isArray(context.init.headers)) {\n                    context.init.headers.forEach((header) => {\n                        headers.push(header);\n                    });\n                }\n                else if (context.init.headers) {\n                    Object.keys(context.init.headers).forEach((key) => {\n                        headers.push([key, context.init.headers[key]]);\n                    });\n                }\n                context.init.headers = headers.concat(objectEntries(tracingHeaders));\n            }\n        }),\n        traceXhr: (context, xhr) => injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, (tracingHeaders) => {\n            Object.keys(tracingHeaders).forEach((name) => {\n                xhr.setRequestHeader(name, tracingHeaders[name]);\n            });\n        }),\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, inject) {\n    const session = sessionManager.findTrackedSession();\n    if (!session) {\n        return;\n    }\n    const tracingOption = configuration.allowedTracingUrls.find((tracingOption) => matchList([tracingOption.match], context.url, true));\n    if (!tracingOption) {\n        return;\n    }\n    const traceSampled = isSampled(session.id, configuration.traceSampleRate);\n    const shouldInjectHeaders = traceSampled || configuration.traceContextInjection === TraceContextInjection.ALL;\n    if (!shouldInjectHeaders) {\n        return;\n    }\n    context.traceSampled = traceSampled;\n    context.traceId = createTraceIdentifier();\n    context.spanId = createSpanIdentifier();\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, session.id, tracingOption.propagatorTypes, userContext, accountContext, configuration));\n}\n/**\n * When trace is not sampled, set priority to '0' instead of not adding the tracing headers\n * to prepare the implementation for sampling delegation.\n */\nfunction makeTracingHeaders(traceId, spanId, traceSampled, sessionId, propagatorTypes, userContext, accountContext, configuration) {\n    const tracingHeaders = {};\n    propagatorTypes.forEach((propagatorType) => {\n        switch (propagatorType) {\n            case 'datadog': {\n                Object.assign(tracingHeaders, {\n                    'x-datadog-origin': 'rum',\n                    'x-datadog-parent-id': spanId.toString(),\n                    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n                    'x-datadog-trace-id': traceId.toString(),\n                });\n                break;\n            }\n            // https://www.w3.org/TR/trace-context/\n            case 'tracecontext': {\n                Object.assign(tracingHeaders, {\n                    traceparent: `00-0000000000000000${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-0${traceSampled ? '1' : '0'}`,\n                    tracestate: `dd=s:${traceSampled ? '1' : '0'};o:rum`,\n                });\n                break;\n            }\n            // https://github.com/openzipkin/b3-propagation\n            case 'b3': {\n                Object.assign(tracingHeaders, {\n                    b3: `${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-${traceSampled ? '1' : '0'}`,\n                });\n                break;\n            }\n            case 'b3multi': {\n                Object.assign(tracingHeaders, {\n                    'X-B3-TraceId': toPaddedHexadecimalString(traceId),\n                    'X-B3-SpanId': toPaddedHexadecimalString(spanId),\n                    'X-B3-Sampled': traceSampled ? '1' : '0',\n                });\n                break;\n            }\n        }\n    });\n    if (configuration.propagateTraceBaggage) {\n        const baggageItems = {\n            'session.id': sessionId,\n        };\n        const userId = userContext.getContext().id;\n        if (typeof userId === 'string') {\n            baggageItems['user.id'] = userId;\n        }\n        const accountId = accountContext.getContext().id;\n        if (typeof accountId === 'string') {\n            baggageItems['account.id'] = accountId;\n        }\n        const baggageHeader = Object.entries(baggageItems)\n            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)\n            .join(',');\n        if (baggageHeader) {\n            tracingHeaders['baggage'] = baggageHeader;\n        }\n    }\n    return tracingHeaders;\n}\n//# sourceMappingURL=tracer.js.map","import { getType, isMatchOption, serializeConfiguration, DefaultPrivacyLevel, TraceContextInjection, display, objectHasValue, validateAndBuildConfiguration, isSampleRate, isNumber, isNonEmptyArray, } from '@datadog/browser-core';\nimport { isTracingOption } from '../tracing/tracer';\nexport const DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'datadog'];\nexport function validateAndBuildRumConfiguration(initConfiguration, errorStack) {\n    var _a, _b, _c, _d, _e, _f, _g;\n    if (initConfiguration.trackFeatureFlagsForEvents !== undefined &&\n        !Array.isArray(initConfiguration.trackFeatureFlagsForEvents)) {\n        display.warn('trackFeatureFlagsForEvents should be an array');\n    }\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (!isSampleRate(initConfiguration.sessionReplaySampleRate, 'Session Replay') ||\n        !isSampleRate(initConfiguration.traceSampleRate, 'Trace')) {\n        return;\n    }\n    if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {\n        display.error('Excluded Activity Urls should be an array');\n        return;\n    }\n    const allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);\n    if (!allowedTracingUrls) {\n        return;\n    }\n    const baseConfiguration = validateAndBuildConfiguration(initConfiguration, errorStack);\n    const allowedGraphQlUrls = validateAndBuildGraphQlOptions(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    const sessionReplaySampleRate = (_a = initConfiguration.sessionReplaySampleRate) !== null && _a !== void 0 ? _a : 0;\n    return {\n        applicationId: initConfiguration.applicationId,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate,\n        startSessionReplayRecordingManually: initConfiguration.startSessionReplayRecordingManually !== undefined\n            ? !!initConfiguration.startSessionReplayRecordingManually\n            : sessionReplaySampleRate === 0,\n        traceSampleRate: (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : 100,\n        rulePsr: isNumber(initConfiguration.traceSampleRate) ? initConfiguration.traceSampleRate / 100 : undefined,\n        allowedTracingUrls,\n        excludedActivityUrls: (_c = initConfiguration.excludedActivityUrls) !== null && _c !== void 0 ? _c : [],\n        workerUrl: initConfiguration.workerUrl,\n        compressIntakeRequests: !!initConfiguration.compressIntakeRequests,\n        trackUserInteractions: !!((_d = initConfiguration.trackUserInteractions) !== null && _d !== void 0 ? _d : true),\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: !!((_e = initConfiguration.trackResources) !== null && _e !== void 0 ? _e : true),\n        trackLongTasks: !!((_f = initConfiguration.trackLongTasks) !== null && _f !== void 0 ? _f : true),\n        trackBfcacheViews: !!initConfiguration.trackBfcacheViews,\n        trackEarlyRequests: !!initConfiguration.trackEarlyRequests,\n        subdomain: initConfiguration.subdomain,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK,\n        enablePrivacyForActionName: !!initConfiguration.enablePrivacyForActionName,\n        traceContextInjection: objectHasValue(TraceContextInjection, initConfiguration.traceContextInjection)\n            ? initConfiguration.traceContextInjection\n            : TraceContextInjection.SAMPLED,\n        plugins: initConfiguration.plugins || [],\n        trackFeatureFlagsForEvents: initConfiguration.trackFeatureFlagsForEvents || [],\n        profilingSampleRate: (_g = initConfiguration.profilingSampleRate) !== null && _g !== void 0 ? _g : 0,\n        propagateTraceBaggage: !!initConfiguration.propagateTraceBaggage,\n        allowedGraphQlUrls,\n        ...baseConfiguration,\n    };\n}\n/**\n * Validates allowedTracingUrls and converts match options to tracing options\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    if (initConfiguration.allowedTracingUrls === undefined) {\n        return [];\n    }\n    if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n        display.error('Allowed Tracing URLs should be an array');\n        return;\n    }\n    if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n        display.error('Service needs to be configured when tracing is enabled');\n        return;\n    }\n    // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n    const tracingOptions = [];\n    initConfiguration.allowedTracingUrls.forEach((option) => {\n        if (isMatchOption(option)) {\n            tracingOptions.push({ match: option, propagatorTypes: DEFAULT_PROPAGATOR_TYPES });\n        }\n        else if (isTracingOption(option)) {\n            tracingOptions.push(option);\n        }\n        else {\n            display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);\n        }\n    });\n    return tracingOptions;\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls\n */\nfunction getSelectedTracingPropagators(configuration) {\n    const usedTracingPropagators = new Set();\n    if (isNonEmptyArray(configuration.allowedTracingUrls)) {\n        configuration.allowedTracingUrls.forEach((option) => {\n            if (isMatchOption(option)) {\n                DEFAULT_PROPAGATOR_TYPES.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));\n            }\n            else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n                option.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));\n            }\n        });\n    }\n    return Array.from(usedTracingPropagators);\n}\n/**\n * Build GraphQL options from configuration\n */\nfunction validateAndBuildGraphQlOptions(initConfiguration) {\n    if (!initConfiguration.allowedGraphQlUrls) {\n        return [];\n    }\n    if (!Array.isArray(initConfiguration.allowedGraphQlUrls)) {\n        display.warn('allowedGraphQlUrls should be an array');\n        return [];\n    }\n    const graphQlOptions = [];\n    initConfiguration.allowedGraphQlUrls.forEach((option) => {\n        if (isMatchOption(option)) {\n            graphQlOptions.push({ match: option, trackPayload: false });\n        }\n        else if (option && typeof option === 'object' && 'match' in option && isMatchOption(option.match)) {\n            graphQlOptions.push({\n                match: option.match,\n                trackPayload: !!option.trackPayload,\n            });\n        }\n    });\n    return graphQlOptions;\n}\nfunction hasGraphQlPayloadTracking(allowedGraphQlUrls) {\n    return (isNonEmptyArray(allowedGraphQlUrls) &&\n        allowedGraphQlUrls.some((option) => {\n            if (typeof option === 'object' && 'trackPayload' in option) {\n                return !!option.trackPayload;\n            }\n            return false;\n        }));\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a;\n    const baseSerializedConfiguration = serializeConfiguration(configuration);\n    return {\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n        trace_sample_rate: configuration.traceSampleRate,\n        trace_context_injection: configuration.traceContextInjection,\n        propagate_trace_baggage: configuration.propagateTraceBaggage,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_urls: isNonEmptyArray(configuration.allowedTracingUrls),\n        use_allowed_graph_ql_urls: isNonEmptyArray(configuration.allowedGraphQlUrls),\n        use_track_graph_ql_payload: hasGraphQlPayloadTracking(configuration.allowedGraphQlUrls),\n        selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n        default_privacy_level: configuration.defaultPrivacyLevel,\n        enable_privacy_for_action_name: configuration.enablePrivacyForActionName,\n        use_excluded_activity_urls: isNonEmptyArray(configuration.excludedActivityUrls),\n        use_worker_url: !!configuration.workerUrl,\n        compress_intake_requests: configuration.compressIntakeRequests,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: configuration.trackUserInteractions,\n        track_resources: configuration.trackResources,\n        track_long_task: configuration.trackLongTasks,\n        track_bfcache_views: configuration.trackBfcacheViews,\n        track_early_requests: configuration.trackEarlyRequests,\n        plugins: (_a = configuration.plugins) === null || _a === void 0 ? void 0 : _a.map((plugin) => {\n            var _a;\n            return ({\n                name: plugin.name,\n                ...(_a = plugin.getConfigurationTelemetry) === null || _a === void 0 ? void 0 : _a.call(plugin),\n            });\n        }),\n        track_feature_flags_for_events: configuration.trackFeatureFlagsForEvents,\n        remote_configuration_id: configuration.remoteConfigurationId,\n        profiling_sample_rate: configuration.profilingSampleRate,\n        use_remote_configuration_proxy: !!configuration.remoteConfigurationProxy,\n        ...baseSerializedConfiguration,\n    };\n}\n//# sourceMappingURL=configuration.js.map","/**\n * Terminology inspired from https://www.rfc-editor.org/rfc/rfc9535.html\n *\n * jsonpath-query      = segment*\n * segment             = .name-shorthand / bracketed-selection\n * bracketed-selection = ['name-selector'] / [\"name-selector\"] / [index-selector]\n *\n * Useful references:\n * - https://goessner.net/articles/JsonPath/\n * - https://jsonpath.com/\n * - https://github.com/jsonpath-standard\n */\n/**\n * Extract selectors from a simple JSON path expression, return [] for an invalid path\n *\n * Supports:\n * - Dot notation: `foo.bar.baz`\n * - Bracket notation: `['foo'][\"bar\"]`\n * - Array indices: `items[0]`, `data['users'][1]`\n *\n * Examples:\n * parseJsonPath(\"['foo'].bar[12]\")\n * => ['foo', 'bar', '12']\n *\n * parseJsonPath(\"['foo\")\n * => []\n */\nexport function parseJsonPath(path) {\n    const selectors = [];\n    let previousToken = 0 /* Token.START */;\n    let currentToken;\n    const parsingContext = { quote: undefined, escapeSequence: undefined };\n    let currentSelector = '';\n    for (const char of path) {\n        // find which kind of token is this char\n        currentToken = ALLOWED_NEXT_TOKENS[previousToken].find((token) => TOKEN_PREDICATE[token](char, parsingContext));\n        if (!currentToken) {\n            return [];\n        }\n        if (parsingContext.escapeSequence !== undefined && currentToken !== 12 /* Token.ESCAPE_SEQUENCE_CHAR */) {\n            if (!isValidEscapeSequence(parsingContext.escapeSequence)) {\n                return [];\n            }\n            currentSelector += resolveEscapeSequence(parsingContext.escapeSequence);\n            parsingContext.escapeSequence = undefined;\n        }\n        if (ALLOWED_SELECTOR_TOKENS.includes(currentToken)) {\n            // buffer the char if it belongs to the selector\n            // ex: foo['bar']\n            //      ^    ^\n            currentSelector += char;\n        }\n        else if (ALLOWED_SELECTOR_DELIMITER_TOKENS.includes(currentToken) && currentSelector !== '') {\n            // close the current path part if we have reach a path part delimiter\n            // ex: foo.bar['qux']\n            //        ^   ^     ^\n            selectors.push(currentSelector);\n            currentSelector = '';\n        }\n        else if (currentToken === 12 /* Token.ESCAPE_SEQUENCE_CHAR */) {\n            parsingContext.escapeSequence = parsingContext.escapeSequence ? `${parsingContext.escapeSequence}${char}` : char;\n        }\n        else if (currentToken === 8 /* Token.QUOTE_START */) {\n            parsingContext.quote = char;\n        }\n        else if (currentToken === 9 /* Token.QUOTE_END */) {\n            parsingContext.quote = undefined;\n        }\n        previousToken = currentToken;\n    }\n    if (!ALLOWED_NEXT_TOKENS[previousToken].includes(1 /* Token.END */)) {\n        return [];\n    }\n    if (currentSelector !== '') {\n        selectors.push(currentSelector);\n    }\n    return selectors;\n}\nconst NAME_SHORTHAND_FIRST_CHAR_REGEX = /[a-zA-Z_$]/;\nconst NAME_SHORTHAND_CHAR_REGEX = /[a-zA-Z0-9_$]/;\nconst DIGIT_REGEX = /[0-9]/;\nconst UNICODE_CHAR_REGEX = /[a-fA-F0-9]/;\nconst QUOTE_CHARS = '\\'\"';\nconst TOKEN_PREDICATE = {\n    // no char should match to START or END\n    [0 /* Token.START */]: () => false,\n    [1 /* Token.END */]: () => false,\n    [2 /* Token.NAME_SHORTHAND_FIRST_CHAR */]: (char) => NAME_SHORTHAND_FIRST_CHAR_REGEX.test(char),\n    [3 /* Token.NAME_SHORTHAND_CHAR */]: (char) => NAME_SHORTHAND_CHAR_REGEX.test(char),\n    [4 /* Token.DOT */]: (char) => char === '.',\n    [5 /* Token.BRACKET_START */]: (char) => char === '[',\n    [6 /* Token.BRACKET_END */]: (char) => char === ']',\n    [7 /* Token.DIGIT */]: (char) => DIGIT_REGEX.test(char),\n    [8 /* Token.QUOTE_START */]: (char) => QUOTE_CHARS.includes(char),\n    [9 /* Token.QUOTE_END */]: (char, parsingContext) => char === parsingContext.quote,\n    [10 /* Token.NAME_SELECTOR_CHAR */]: () => true, // any char can be used in name selector\n    [11 /* Token.ESCAPE */]: (char) => char === '\\\\',\n    [12 /* Token.ESCAPE_SEQUENCE_CHAR */]: (char, parsingContext) => {\n        if (parsingContext.escapeSequence === undefined) {\n            // see https://www.rfc-editor.org/rfc/rfc9535.html#name-semantics-3\n            return `${parsingContext.quote}/\\\\bfnrtu`.includes(char);\n        }\n        else if (parsingContext.escapeSequence.startsWith('u') && parsingContext.escapeSequence.length < 5) {\n            return UNICODE_CHAR_REGEX.test(char);\n        }\n        return false;\n    },\n};\nconst ALLOWED_NEXT_TOKENS = {\n    [0 /* Token.START */]: [2 /* Token.NAME_SHORTHAND_FIRST_CHAR */, 5 /* Token.BRACKET_START */],\n    [1 /* Token.END */]: [],\n    [2 /* Token.NAME_SHORTHAND_FIRST_CHAR */]: [3 /* Token.NAME_SHORTHAND_CHAR */, 4 /* Token.DOT */, 5 /* Token.BRACKET_START */, 1 /* Token.END */],\n    [3 /* Token.NAME_SHORTHAND_CHAR */]: [3 /* Token.NAME_SHORTHAND_CHAR */, 4 /* Token.DOT */, 5 /* Token.BRACKET_START */, 1 /* Token.END */],\n    [4 /* Token.DOT */]: [2 /* Token.NAME_SHORTHAND_FIRST_CHAR */],\n    [5 /* Token.BRACKET_START */]: [8 /* Token.QUOTE_START */, 7 /* Token.DIGIT */],\n    [6 /* Token.BRACKET_END */]: [4 /* Token.DOT */, 5 /* Token.BRACKET_START */, 1 /* Token.END */],\n    [7 /* Token.DIGIT */]: [7 /* Token.DIGIT */, 6 /* Token.BRACKET_END */],\n    [8 /* Token.QUOTE_START */]: [11 /* Token.ESCAPE */, 9 /* Token.QUOTE_END */, 10 /* Token.NAME_SELECTOR_CHAR */],\n    [9 /* Token.QUOTE_END */]: [6 /* Token.BRACKET_END */],\n    [10 /* Token.NAME_SELECTOR_CHAR */]: [11 /* Token.ESCAPE */, 9 /* Token.QUOTE_END */, 10 /* Token.NAME_SELECTOR_CHAR */],\n    [11 /* Token.ESCAPE */]: [12 /* Token.ESCAPE_SEQUENCE_CHAR */],\n    [12 /* Token.ESCAPE_SEQUENCE_CHAR */]: [12 /* Token.ESCAPE_SEQUENCE_CHAR */, 11 /* Token.ESCAPE */, 9 /* Token.QUOTE_END */, 10 /* Token.NAME_SELECTOR_CHAR */],\n};\n// foo['bar\\n'][12]\n// ^^    ^ ^^   ^\nconst ALLOWED_SELECTOR_TOKENS = [\n    2 /* Token.NAME_SHORTHAND_FIRST_CHAR */,\n    3 /* Token.NAME_SHORTHAND_CHAR */,\n    7 /* Token.DIGIT */,\n    10 /* Token.NAME_SELECTOR_CHAR */,\n];\n// foo.bar['qux']\n//    ^   ^     ^\nconst ALLOWED_SELECTOR_DELIMITER_TOKENS = [4 /* Token.DOT */, 5 /* Token.BRACKET_START */, 6 /* Token.BRACKET_END */];\nfunction isValidEscapeSequence(escapeSequence) {\n    return '\"\\'/\\\\bfnrt'.includes(escapeSequence) || (escapeSequence.startsWith('u') && escapeSequence.length === 5);\n}\nconst ESCAPED_CHARS = {\n    '\"': '\"',\n    \"'\": \"'\",\n    '/': '/',\n    '\\\\': '\\\\',\n    b: '\\b',\n    f: '\\f',\n    n: '\\n',\n    r: '\\r',\n    t: '\\t',\n};\nfunction resolveEscapeSequence(escapeSequence) {\n    if (escapeSequence.startsWith('u')) {\n        // build Unicode char from code\n        return String.fromCharCode(parseInt(escapeSequence.slice(1), 16));\n    }\n    return ESCAPED_CHARS[escapeSequence];\n}\n//# sourceMappingURL=jsonPathParser.js.map","import { display, buildEndpointHost, mapValues, getCookie, addTelemetryMetrics, } from '@datadog/browser-core';\nimport { parseJsonPath } from './jsonPathParser';\nconst REMOTE_CONFIGURATION_VERSION = 'v1';\nconst SUPPORTED_FIELDS = [\n    'applicationId',\n    'service',\n    'env',\n    'version',\n    'sessionSampleRate',\n    'sessionReplaySampleRate',\n    'defaultPrivacyLevel',\n    'enablePrivacyForActionName',\n    'traceSampleRate',\n    'trackSessionAcrossSubdomains',\n    'allowedTracingUrls',\n    'allowedTrackingOrigins',\n];\nexport async function fetchAndApplyRemoteConfiguration(initConfiguration, supportedContextManagers) {\n    let rumInitConfiguration;\n    const metrics = initMetrics();\n    const fetchResult = await fetchRemoteConfiguration(initConfiguration);\n    if (!fetchResult.ok) {\n        metrics.increment('fetch', 'failure');\n        display.error(fetchResult.error);\n    }\n    else {\n        metrics.increment('fetch', 'success');\n        rumInitConfiguration = applyRemoteConfiguration(initConfiguration, fetchResult.value, supportedContextManagers, metrics);\n    }\n    // monitor-until: forever\n    addTelemetryMetrics(\"remote configuration metrics\" /* TelemetryMetrics.REMOTE_CONFIGURATION_METRIC_NAME */, { metrics: metrics.get() });\n    return rumInitConfiguration;\n}\nexport function applyRemoteConfiguration(initConfiguration, rumRemoteConfiguration, supportedContextManagers, metrics) {\n    // intents:\n    // - explicitly set each supported field to limit risk in case an attacker can create configurations\n    // - check the existence in the remote config to avoid clearing a provided init field\n    const appliedConfiguration = { ...initConfiguration };\n    SUPPORTED_FIELDS.forEach((option) => {\n        if (option in rumRemoteConfiguration) {\n            appliedConfiguration[option] = resolveConfigurationProperty(rumRemoteConfiguration[option]);\n        }\n    });\n    Object.keys(supportedContextManagers).forEach((context) => {\n        if (rumRemoteConfiguration[context] !== undefined) {\n            resolveContextProperty(supportedContextManagers[context], rumRemoteConfiguration[context]);\n        }\n    });\n    return appliedConfiguration;\n    // share context to access metrics\n    function resolveConfigurationProperty(property) {\n        if (Array.isArray(property)) {\n            return property.map(resolveConfigurationProperty);\n        }\n        if (isObject(property)) {\n            if (isSerializedOption(property)) {\n                const type = property.rcSerializedType;\n                switch (type) {\n                    case 'string':\n                        return property.value;\n                    case 'regex':\n                        return resolveRegex(property.value);\n                    case 'dynamic':\n                        return resolveDynamicOption(property);\n                    default:\n                        display.error(`Unsupported remote configuration: \"rcSerializedType\": \"${type}\"`);\n                        return;\n                }\n            }\n            return mapValues(property, resolveConfigurationProperty);\n        }\n        return property;\n    }\n    function resolveContextProperty(contextManager, contextItems) {\n        contextItems.forEach(({ key, value }) => {\n            contextManager.setContextProperty(key, resolveConfigurationProperty(value));\n        });\n    }\n    function resolveDynamicOption(property) {\n        const strategy = property.strategy;\n        let resolvedValue;\n        switch (strategy) {\n            case 'cookie':\n                resolvedValue = resolveCookieValue(property);\n                break;\n            case 'dom':\n                resolvedValue = resolveDomValue(property);\n                break;\n            case 'js':\n                resolvedValue = resolveJsValue(property);\n                break;\n            default:\n                display.error(`Unsupported remote configuration: \"strategy\": \"${strategy}\"`);\n                return;\n        }\n        const extractor = property.extractor;\n        if (extractor !== undefined && typeof resolvedValue === 'string') {\n            return extractValue(extractor, resolvedValue);\n        }\n        return resolvedValue;\n    }\n    function resolveCookieValue({ name }) {\n        const value = getCookie(name);\n        metrics.increment('cookie', value !== undefined ? 'success' : 'missing');\n        return value;\n    }\n    function resolveDomValue({ selector, attribute }) {\n        let element;\n        try {\n            element = document.querySelector(selector);\n        }\n        catch (_a) {\n            display.error(`Invalid selector in the remote configuration: '${selector}'`);\n            metrics.increment('dom', 'failure');\n            return;\n        }\n        if (!element) {\n            metrics.increment('dom', 'missing');\n            return;\n        }\n        if (isForbidden(element, attribute)) {\n            display.error(`Forbidden element selected by the remote configuration: '${selector}'`);\n            metrics.increment('dom', 'failure');\n            return;\n        }\n        const domValue = attribute !== undefined ? element.getAttribute(attribute) : element.textContent;\n        if (domValue === null) {\n            metrics.increment('dom', 'missing');\n            return;\n        }\n        metrics.increment('dom', 'success');\n        return domValue;\n    }\n    function isForbidden(element, attribute) {\n        return element.getAttribute('type') === 'password' && attribute === 'value';\n    }\n    function resolveJsValue({ path }) {\n        let current = window;\n        const pathParts = parseJsonPath(path);\n        if (pathParts.length === 0) {\n            display.error(`Invalid JSON path in the remote configuration: '${path}'`);\n            metrics.increment('js', 'failure');\n            return;\n        }\n        for (const pathPart of pathParts) {\n            if (!(pathPart in current)) {\n                metrics.increment('js', 'missing');\n                return;\n            }\n            try {\n                current = current[pathPart];\n            }\n            catch (e) {\n                display.error(`Error accessing: '${path}'`, e);\n                metrics.increment('js', 'failure');\n                return;\n            }\n        }\n        metrics.increment('js', 'success');\n        return current;\n    }\n}\nexport function initMetrics() {\n    const metrics = { fetch: {} };\n    return {\n        get: () => metrics,\n        increment: (metricName, type) => {\n            if (!metrics[metricName]) {\n                metrics[metricName] = {};\n            }\n            if (!metrics[metricName][type]) {\n                metrics[metricName][type] = 0;\n            }\n            metrics[metricName][type] = metrics[metricName][type] + 1;\n        },\n    };\n}\nfunction isObject(property) {\n    return typeof property === 'object' && property !== null;\n}\nfunction isSerializedOption(value) {\n    return 'rcSerializedType' in value;\n}\nfunction resolveRegex(pattern) {\n    try {\n        return new RegExp(pattern);\n    }\n    catch (_a) {\n        display.error(`Invalid regex in the remote configuration: '${pattern}'`);\n    }\n}\nfunction extractValue(extractor, candidate) {\n    const resolvedExtractor = resolveRegex(extractor.value);\n    if (resolvedExtractor === undefined) {\n        return;\n    }\n    const regexResult = resolvedExtractor.exec(candidate);\n    if (regexResult === null) {\n        return;\n    }\n    const [match, capture] = regexResult;\n    return capture ? capture : match;\n}\nexport async function fetchRemoteConfiguration(configuration) {\n    let response;\n    try {\n        response = await fetch(buildEndpoint(configuration));\n    }\n    catch (_a) {\n        response = undefined;\n    }\n    if (!response || !response.ok) {\n        return {\n            ok: false,\n            error: new Error('Error fetching the remote configuration.'),\n        };\n    }\n    const remoteConfiguration = await response.json();\n    if (remoteConfiguration.rum) {\n        return {\n            ok: true,\n            value: remoteConfiguration.rum,\n        };\n    }\n    return {\n        ok: false,\n        error: new Error('No remote configuration for RUM.'),\n    };\n}\nexport function buildEndpoint(configuration) {\n    if (configuration.remoteConfigurationProxy) {\n        return configuration.remoteConfigurationProxy;\n    }\n    return `https://sdk-configuration.${buildEndpointHost('rum', configuration)}/${REMOTE_CONFIGURATION_VERSION}/${encodeURIComponent(configuration.remoteConfigurationId)}.json`;\n}\n//# sourceMappingURL=remoteConfiguration.js.map","import { createBoundedBuffer, display, canUseEventBridge, displayAlreadyInitializedError, willSyntheticsInjectRum, noop, timeStampNow, clocksNow, getEventBridge, initFeatureFlags, addTelemetryConfiguration, initFetchObservable, CustomerContextKey, buildAccountContextManager, buildGlobalContextManager, buildUserContextManager, monitorError, sanitize, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration, fetchAndApplyRemoteConfiguration, serializeRumConfiguration, } from '../domain/configuration';\nimport { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection';\nimport { callPluginsMethod } from '../domain/plugins';\nexport function createPreStartStrategy({ ignoreInitIfSyntheticsWillInjectRum = true, startDeflateWorker }, trackingConsentState, customVitalsState, doStartRum) {\n    const bufferApiCalls = createBoundedBuffer();\n    // TODO next major: remove the globalContextManager, userContextManager and accountContextManager from preStartStrategy and use an empty context instead\n    const globalContext = buildGlobalContextManager();\n    bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls);\n    const userContext = buildUserContextManager();\n    bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls);\n    const accountContext = buildAccountContextManager();\n    bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls);\n    let firstStartViewCall;\n    let deflateWorker;\n    let cachedInitConfiguration;\n    let cachedConfiguration;\n    const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);\n    const emptyContext = {};\n    function tryStartRum() {\n        if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        trackingConsentStateSubscription.unsubscribe();\n        let initialViewOptions;\n        if (cachedConfiguration.trackViewsManually) {\n            if (!firstStartViewCall) {\n                return;\n            }\n            // An initial view is always created when starting RUM.\n            // When tracking views automatically, any startView call before RUM start creates an extra\n            // view.\n            // When tracking views manually, we use the ViewOptions from the first startView call as the\n            // initial view options, and we remove the actual startView call so we don't create an extra\n            // view.\n            bufferApiCalls.remove(firstStartViewCall.callback);\n            initialViewOptions = firstStartViewCall.options;\n        }\n        const startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions);\n        bufferApiCalls.drain(startRumResult);\n    }\n    function doInit(initConfiguration, errorStack) {\n        const eventBridgeAvailable = canUseEventBridge();\n        if (eventBridgeAvailable) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        // Update the exposed initConfiguration to reflect the bridge and remote configuration overrides\n        cachedInitConfiguration = initConfiguration;\n        addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n        if (cachedConfiguration) {\n            displayAlreadyInitializedError('DD_RUM', initConfiguration);\n            return;\n        }\n        const configuration = validateAndBuildRumConfiguration(initConfiguration, errorStack);\n        if (!configuration) {\n            return;\n        }\n        if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {\n            display.warn('No storage available for session. We will not send any data.');\n            return;\n        }\n        if (configuration.compressIntakeRequests && !eventBridgeAvailable && startDeflateWorker) {\n            deflateWorker = startDeflateWorker(configuration, 'Datadog RUM', \n            // Worker initialization can fail asynchronously, especially in Firefox where even CSP\n            // issues are reported asynchronously. For now, the SDK will continue its execution even if\n            // data won't be sent to Datadog. We could improve this behavior in the future.\n            noop);\n            if (!deflateWorker) {\n                // `startDeflateWorker` should have logged an error message explaining the issue\n                return;\n            }\n        }\n        cachedConfiguration = configuration;\n        // Instrument fetch to track network requests\n        // This is needed in case the consent is not granted and some customer\n        // library (Apollo Client) is storing uninstrumented fetch to be used later\n        // The subscription is needed so that the instrumentation process is completed\n        initFetchObservable().subscribe(noop);\n        trackingConsentState.tryToInit(configuration.trackingConsent);\n        tryStartRum();\n    }\n    const addDurationVital = (vital) => {\n        bufferApiCalls.add((startRumResult) => startRumResult.addDurationVital(vital));\n    };\n    const addOperationStepVital = (name, stepType, options, failureReason) => {\n        bufferApiCalls.add((startRumResult) => startRumResult.addOperationStepVital(sanitize(name), stepType, sanitize(options), sanitize(failureReason)));\n    };\n    const strategy = {\n        init(initConfiguration, publicApi, errorStack) {\n            if (!initConfiguration) {\n                display.error('Missing configuration');\n                return;\n            }\n            // Set the experimental feature flags as early as possible, so we can use them in most places\n            initFeatureFlags(initConfiguration.enableExperimentalFeatures);\n            // Expose the initial configuration regardless of initialization success.\n            cachedInitConfiguration = initConfiguration;\n            // If we are in a Synthetics test configured to automatically inject a RUM instance, we want\n            // to completely discard the customer application RUM instance by ignoring their init() call.\n            // But, we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n            // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n            if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n                return;\n            }\n            callPluginsMethod(initConfiguration.plugins, 'onInit', { initConfiguration, publicApi });\n            if (initConfiguration.remoteConfigurationId) {\n                fetchAndApplyRemoteConfiguration(initConfiguration, { user: userContext, context: globalContext })\n                    .then((initConfiguration) => {\n                    if (initConfiguration) {\n                        doInit(initConfiguration, errorStack);\n                    }\n                })\n                    .catch(monitorError);\n            }\n            else {\n                doInit(initConfiguration, errorStack);\n            }\n        },\n        get initConfiguration() {\n            return cachedInitConfiguration;\n        },\n        getInternalContext: noop,\n        stopSession: noop,\n        addTiming(name, time = timeStampNow()) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addTiming(name, time));\n        },\n        startView(options, startClocks = clocksNow()) {\n            const callback = (startRumResult) => {\n                startRumResult.startView(options, startClocks);\n            };\n            bufferApiCalls.add(callback);\n            if (!firstStartViewCall) {\n                firstStartViewCall = { options, callback };\n                tryStartRum();\n            }\n        },\n        setViewName(name) {\n            bufferApiCalls.add((startRumResult) => startRumResult.setViewName(name));\n        },\n        // View context APIs\n        setViewContext(context) {\n            bufferApiCalls.add((startRumResult) => startRumResult.setViewContext(context));\n        },\n        setViewContextProperty(key, value) {\n            bufferApiCalls.add((startRumResult) => startRumResult.setViewContextProperty(key, value));\n        },\n        getViewContext: () => emptyContext,\n        globalContext,\n        userContext,\n        accountContext,\n        addAction(action) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addAction(action));\n        },\n        addError(providedError) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addError(providedError));\n        },\n        addFeatureFlagEvaluation(key, value) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value));\n        },\n        startDurationVital(name, options) {\n            return startDurationVital(customVitalsState, name, options);\n        },\n        stopDurationVital(name, options) {\n            stopDurationVital(addDurationVital, customVitalsState, name, options);\n        },\n        addDurationVital,\n        addOperationStepVital,\n    };\n    return strategy;\n}\nfunction overrideInitConfigurationForBridge(initConfiguration) {\n    var _a, _b;\n    return {\n        ...initConfiguration,\n        applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n        clientToken: 'empty',\n        sessionSampleRate: 100,\n        defaultPrivacyLevel: (_a = initConfiguration.defaultPrivacyLevel) !== null && _a !== void 0 ? _a : (_b = getEventBridge()) === null || _b === void 0 ? void 0 : _b.getPrivacyLevel(),\n    };\n}\nfunction bufferContextCalls(preStartContextManager, name, bufferApiCalls) {\n    preStartContextManager.changeObservable.subscribe(() => {\n        const context = preStartContextManager.getContext();\n        bufferApiCalls.add((startRumResult) => startRumResult[name].setContext(context));\n    });\n}\n//# sourceMappingURL=preStartRum.js.map","import { ContextManagerMethod, addTelemetryUsage, deepClone, makePublicApi, monitor, clocksNow, callMonitored, createHandlingStack, sanitize, createIdentityEncoder, displayAlreadyInitializedError, createTrackingConsentState, timeStampToClocks, CustomerContextKey, defineContextMethod, startBufferingData, } from '@datadog/browser-core';\nimport { ActionType, VitalType } from '../rawRumEvent.types';\nimport { createCustomVitalsState } from '../domain/vital/vitalCollection';\nimport { callPluginsMethod } from '../domain/plugins';\nimport { createPreStartStrategy } from './preStartRum';\nexport function makeRumPublicApi(startRumImpl, recorderApi, profilerApi, options = {}) {\n    const trackingConsentState = createTrackingConsentState();\n    const customVitalsState = createCustomVitalsState();\n    const bufferedDataObservable = startBufferingData().observable;\n    let strategy = createPreStartStrategy(options, trackingConsentState, customVitalsState, (configuration, deflateWorker, initialViewOptions) => {\n        const createEncoder = deflateWorker && options.createDeflateEncoder\n            ? (streamId) => options.createDeflateEncoder(configuration, deflateWorker, streamId)\n            : createIdentityEncoder;\n        const startRumResult = startRumImpl(configuration, recorderApi, profilerApi, initialViewOptions, createEncoder, trackingConsentState, customVitalsState, bufferedDataObservable, options.sdkName);\n        recorderApi.onRumStart(startRumResult.lifeCycle, configuration, startRumResult.session, startRumResult.viewHistory, deflateWorker, startRumResult.telemetry);\n        profilerApi.onRumStart(startRumResult.lifeCycle, startRumResult.hooks, configuration, startRumResult.session, startRumResult.viewHistory, createEncoder);\n        strategy = createPostStartStrategy(strategy, startRumResult);\n        callPluginsMethod(configuration.plugins, 'onRumStart', {\n            strategy, // TODO: remove this in the next major release\n            addEvent: startRumResult.addEvent,\n        });\n        return startRumResult;\n    });\n    const getStrategy = () => strategy;\n    const startView = monitor((options) => {\n        const sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        strategy.startView(sanitizedOptions);\n        addTelemetryUsage({ feature: 'start-view' });\n    });\n    const rumPublicApi = makePublicApi({\n        init: (initConfiguration) => {\n            const errorStack = new Error().stack;\n            callMonitored(() => strategy.init(initConfiguration, rumPublicApi, errorStack));\n        },\n        setTrackingConsent: monitor((trackingConsent) => {\n            trackingConsentState.update(trackingConsent);\n            addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent });\n        }),\n        setViewName: monitor((name) => {\n            strategy.setViewName(name);\n            addTelemetryUsage({ feature: 'set-view-name' });\n        }),\n        setViewContext: monitor((context) => {\n            strategy.setViewContext(context);\n            addTelemetryUsage({ feature: 'set-view-context' });\n        }),\n        setViewContextProperty: monitor((key, value) => {\n            strategy.setViewContextProperty(key, value);\n            addTelemetryUsage({ feature: 'set-view-context-property' });\n        }),\n        getViewContext: monitor(() => {\n            addTelemetryUsage({ feature: 'set-view-context-property' });\n            return strategy.getViewContext();\n        }),\n        getInternalContext: monitor((startTime) => strategy.getInternalContext(startTime)),\n        getInitConfiguration: monitor(() => deepClone(strategy.initConfiguration)),\n        addAction: (name, context) => {\n            const handlingStack = createHandlingStack('action');\n            callMonitored(() => {\n                strategy.addAction({\n                    name: sanitize(name),\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                    type: ActionType.CUSTOM,\n                    handlingStack,\n                });\n                addTelemetryUsage({ feature: 'add-action' });\n            });\n        },\n        addError: (error, context) => {\n            const handlingStack = createHandlingStack('error');\n            callMonitored(() => {\n                strategy.addError({\n                    error, // Do not sanitize error here, it is needed unserialized by computeRawError()\n                    handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n                addTelemetryUsage({ feature: 'add-error' });\n            });\n        },\n        addTiming: monitor((name, time) => {\n            // TODO: next major decide to drop relative time support or update its behaviour\n            strategy.addTiming(sanitize(name), time);\n        }),\n        setGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.setContext, 'set-global-context'),\n        getGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.getContext, 'get-global-context'),\n        setGlobalContextProperty: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.setContextProperty, 'set-global-context-property'),\n        removeGlobalContextProperty: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.removeContextProperty, 'remove-global-context-property'),\n        clearGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.clearContext, 'clear-global-context'),\n        setUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContext, 'set-user'),\n        getUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.getContext, 'get-user'),\n        setUserProperty: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContextProperty, 'set-user-property'),\n        removeUserProperty: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.removeContextProperty, 'remove-user-property'),\n        clearUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.clearContext, 'clear-user'),\n        setAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContext, 'set-account'),\n        getAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.getContext, 'get-account'),\n        setAccountProperty: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContextProperty, 'set-account-property'),\n        removeAccountProperty: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.removeContextProperty, 'remove-account-property'),\n        clearAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.clearContext, 'clear-account'),\n        startView,\n        stopSession: monitor(() => {\n            strategy.stopSession();\n            addTelemetryUsage({ feature: 'stop-session' });\n        }),\n        addFeatureFlagEvaluation: monitor((key, value) => {\n            strategy.addFeatureFlagEvaluation(sanitize(key), sanitize(value));\n            addTelemetryUsage({ feature: 'add-feature-flag-evaluation' });\n        }),\n        getSessionReplayLink: monitor(() => recorderApi.getSessionReplayLink()),\n        startSessionReplayRecording: monitor((options) => {\n            recorderApi.start(options);\n            addTelemetryUsage({ feature: 'start-session-replay-recording', force: options && options.force });\n        }),\n        stopSessionReplayRecording: monitor(() => recorderApi.stop()),\n        addDurationVital: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'add-duration-vital' });\n            strategy.addDurationVital({\n                name: sanitize(name),\n                type: VitalType.DURATION,\n                startClocks: timeStampToClocks(options.startTime),\n                duration: options.duration,\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n        startDurationVital: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'start-duration-vital' });\n            return strategy.startDurationVital(sanitize(name), {\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n        stopDurationVital: monitor((nameOrRef, options) => {\n            addTelemetryUsage({ feature: 'stop-duration-vital' });\n            strategy.stopDurationVital(typeof nameOrRef === 'string' ? sanitize(nameOrRef) : nameOrRef, {\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n        startFeatureOperation: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'start' });\n            strategy.addOperationStepVital(name, 'start', options);\n        }),\n        succeedFeatureOperation: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'succeed' });\n            strategy.addOperationStepVital(name, 'end', options);\n        }),\n        failFeatureOperation: monitor((name, failureReason, options) => {\n            addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'fail' });\n            strategy.addOperationStepVital(name, 'end', options, failureReason);\n        }),\n    });\n    return rumPublicApi;\n}\nfunction createPostStartStrategy(preStartStrategy, startRumResult) {\n    return {\n        init: (initConfiguration) => {\n            displayAlreadyInitializedError('DD_RUM', initConfiguration);\n        },\n        initConfiguration: preStartStrategy.initConfiguration,\n        ...startRumResult,\n    };\n}\n//# sourceMappingURL=rumPublicApi.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    const MutationObserver = getMutationObserverConstructor();\n    return new Observable((observable) => {\n        if (!MutationObserver) {\n            return;\n        }\n        const observer = new MutationObserver(monitor((records) => observable.notify(records)));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return () => observer.disconnect();\n    });\n}\nexport function getMutationObserverConstructor() {\n    let constructor;\n    const browserWindow = window;\n    // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n    // global MutationObserver constructor with a patched version to support the context propagation.\n    // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n    // component: on some occasions, the callback is being called in an infinite loop, causing the\n    // page to freeze (even if the callback is completely empty).\n    //\n    // To work around this issue, we try to get the original MutationObserver constructor stored by\n    // Zone.js.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n        //\n        // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n        constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver');\n        if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n            // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n            // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n            // instance in its properties[4]. Let's get the original MutationObserver constructor from\n            // there.\n            //\n            // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n            const patchedInstance = new browserWindow.MutationObserver(noop);\n            const originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance');\n            constructor = originalInstance && originalInstance.constructor;\n        }\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport const LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","// eslint-disable-next-line no-restricted-syntax\nexport class AbstractLifeCycle {\n    constructor() {\n        this.callbacks = {};\n    }\n    notify(eventType, data) {\n        const eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach((callback) => callback(data));\n        }\n    }\n    subscribe(eventType, callback) {\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: () => {\n                this.callbacks[eventType] = this.callbacks[eventType].filter((other) => callback !== other);\n            },\n        };\n    }\n}\n//# sourceMappingURL=abstractLifeCycle.js.map","import { setInterval, clearInterval } from './timer';\nimport { removeItem } from './utils/arrayUtils';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nconst END_OF_TIMES = Infinity;\nexport const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\nlet cleanupHistoriesInterval = null;\nconst cleanupTasks = new Set();\nfunction cleanupHistories() {\n    cleanupTasks.forEach((task) => task());\n}\nexport function createValueHistory({ expireDelay, maxEntries, }) {\n    let entries = [];\n    if (!cleanupHistoriesInterval) {\n        cleanupHistoriesInterval = setInterval(() => cleanupHistories(), CLEAR_OLD_VALUES_INTERVAL);\n    }\n    const clearExpiredValues = () => {\n        const oldTimeThreshold = relativeNow() - expireDelay;\n        while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {\n            entries.pop();\n        }\n    };\n    cleanupTasks.add(clearExpiredValues);\n    /**\n     * Add a value to the history associated with a start time. Returns a reference to this newly\n     * added entry that can be removed or closed.\n     */\n    function add(value, startTime) {\n        const entry = {\n            value,\n            startTime,\n            endTime: END_OF_TIMES,\n            remove: () => {\n                removeItem(entries, entry);\n            },\n            close: (endTime) => {\n                entry.endTime = endTime;\n            },\n        };\n        if (maxEntries && entries.length >= maxEntries) {\n            entries.pop();\n        }\n        entries.unshift(entry);\n        return entry;\n    }\n    /**\n     * Return the latest value that was active during `startTime`, or the currently active value\n     * if no `startTime` is provided. This method assumes that entries are not overlapping.\n     *\n     * If `option.returnInactive` is true, returns the value at `startTime` (active or not).\n     */\n    function find(startTime = END_OF_TIMES, options = { returnInactive: false }) {\n        for (const entry of entries) {\n            if (entry.startTime <= startTime) {\n                if (options.returnInactive || startTime <= entry.endTime) {\n                    return entry.value;\n                }\n                break;\n            }\n        }\n    }\n    /**\n     * Helper function to close the currently active value, if any. This method assumes that entries\n     * are not overlapping.\n     */\n    function closeActive(endTime) {\n        const latestEntry = entries[0];\n        if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n            latestEntry.close(endTime);\n        }\n    }\n    /**\n     * Return all values with an active period overlapping with the duration,\n     * or all values that were active during `startTime` if no duration is provided,\n     * or all currently active values if no `startTime` is provided.\n     */\n    function findAll(startTime = END_OF_TIMES, duration = 0) {\n        const endTime = addDuration(startTime, duration);\n        return entries\n            .filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)\n            .map((entry) => entry.value);\n    }\n    /**\n     * Remove all entries from this collection.\n     */\n    function reset() {\n        entries = [];\n    }\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    function stop() {\n        cleanupTasks.delete(clearExpiredValues);\n        if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {\n            clearInterval(cleanupHistoriesInterval);\n            cleanupHistoriesInterval = null;\n        }\n    }\n    return { add, find, closeActive, findAll, reset, stop };\n}\n//# sourceMappingURL=valueHistory.js.map","import { SESSION_TIME_OUT_DELAY, createValueHistory } from '@datadog/browser-core';\nexport const VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewHistory(lifeCycle) {\n    const viewValueHistory = createValueHistory({ expireDelay: VIEW_CONTEXT_TIME_OUT_DELAY });\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, (view) => {\n        viewValueHistory.add(buildViewHistoryEntry(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, ({ endClocks }) => {\n        viewValueHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(3 /* LifeCycleEventType.BEFORE_VIEW_UPDATED */, (viewUpdate) => {\n        const currentView = viewValueHistory.find(viewUpdate.startClocks.relative);\n        if (!currentView) {\n            return;\n        }\n        if (viewUpdate.name) {\n            currentView.name = viewUpdate.name;\n        }\n        if (viewUpdate.context) {\n            currentView.context = viewUpdate.context;\n        }\n        currentView.sessionIsActive = viewUpdate.sessionIsActive;\n    });\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        viewValueHistory.reset();\n    });\n    function buildViewHistoryEntry(view) {\n        return {\n            service: view.service,\n            version: view.version,\n            context: view.context,\n            id: view.id,\n            name: view.name,\n            startClocks: view.startClocks,\n        };\n    }\n    return {\n        findView: (startTime) => viewValueHistory.find(startTime),\n        stop: () => {\n            viewValueHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=viewHistory.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nimport { shallowClone } from '../tools/utils/objectUtils';\nimport { addEventListener } from './addEventListener';\nlet xhrObservable;\nconst xhrContexts = new WeakMap();\nexport function initXhrObservable(configuration) {\n    if (!xhrObservable) {\n        xhrObservable = createXhrObservable(configuration);\n    }\n    return xhrObservable;\n}\nfunction createXhrObservable(configuration) {\n    return new Observable((observable) => {\n        const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr);\n        const { stop: stopInstrumentingSend } = instrumentMethod(XMLHttpRequest.prototype, 'send', (call) => {\n            sendXhr(call, configuration, observable);\n        }, { computeHandlingStack: true });\n        const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr);\n        return () => {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n}\nfunction openXhr({ target: xhr, parameters: [method, url] }) {\n    xhrContexts.set(xhr, {\n        state: 'open',\n        method: String(method).toUpperCase(),\n        url: normalizeUrl(String(url)),\n    });\n}\nfunction sendXhr({ target: xhr, parameters: [body], handlingStack }, configuration, observable) {\n    const context = xhrContexts.get(xhr);\n    if (!context) {\n        return;\n    }\n    const startContext = context;\n    startContext.state = 'start';\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = xhr;\n    startContext.handlingStack = handlingStack;\n    startContext.body = body;\n    let hasBeenReported = false;\n    const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {\n        if (xhr.readyState === XMLHttpRequest.DONE) {\n            // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n            // application during a future event. For example, Angular is calling .abort() on\n            // completed requests during an onreadystatechange event, so the status becomes '0'\n            // before the request is collected.\n            onEnd();\n        }\n    });\n    const onEnd = () => {\n        unsubscribeLoadEndListener();\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        const completeContext = context;\n        completeContext.state = 'complete';\n        completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n        completeContext.status = xhr.status;\n        observable.notify(shallowClone(completeContext));\n    };\n    const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd);\n    observable.notify(startContext);\n}\nfunction abortXhr({ target: xhr }) {\n    const context = xhrContexts.get(xhr);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","export const ResourceType = {\n    DOCUMENT: 'document',\n    XHR: 'xhr',\n    BEACON: 'beacon',\n    FETCH: 'fetch',\n    CSS: 'css',\n    JS: 'js',\n    IMAGE: 'image',\n    FONT: 'font',\n    MEDIA: 'media',\n    OTHER: 'other',\n};\nexport const RequestType = {\n    FETCH: ResourceType.FETCH,\n    XHR: ResourceType.XHR,\n};\n//# sourceMappingURL=resourceUtils.js.map","import { elapsed, getPathName, isValidUrl, ResourceType, toServerDuration, isIntakeUrl, isExperimentalFeatureEnabled, ExperimentalFeature, } from '@datadog/browser-core';\nexport const FAKE_INITIAL_DOCUMENT = 'initial_document';\nconst RESOURCE_TYPES = [\n    [ResourceType.DOCUMENT, (initiatorType) => FAKE_INITIAL_DOCUMENT === initiatorType],\n    [ResourceType.XHR, (initiatorType) => 'xmlhttprequest' === initiatorType],\n    [ResourceType.FETCH, (initiatorType) => 'fetch' === initiatorType],\n    [ResourceType.BEACON, (initiatorType) => 'beacon' === initiatorType],\n    [ResourceType.CSS, (_, path) => /\\.css$/i.test(path)],\n    [ResourceType.JS, (_, path) => /\\.js$/i.test(path)],\n    [\n        ResourceType.IMAGE,\n        (initiatorType, path) => ['image', 'img', 'icon'].includes(initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null,\n    ],\n    [ResourceType.FONT, (_, path) => /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],\n    [\n        ResourceType.MEDIA,\n        (initiatorType, path) => ['audio', 'video'].includes(initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null,\n    ],\n];\nexport function computeResourceEntryType(entry) {\n    const url = entry.name;\n    if (!isValidUrl(url)) {\n        return ResourceType.OTHER;\n    }\n    const path = getPathName(url);\n    for (const [type, isType] of RESOURCE_TYPES) {\n        if (isType(entry.initiatorType, path)) {\n            return type;\n        }\n    }\n    return ResourceType.OTHER;\n}\nfunction areInOrder(...numbers) {\n    for (let i = 1; i < numbers.length; i += 1) {\n        if (numbers[i - 1] > numbers[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function isResourceEntryRequestType(entry) {\n    return entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch';\n}\nexport function computeResourceEntryDuration(entry) {\n    const { duration, startTime, responseEnd } = entry;\n    // Safari duration is always 0 on timings blocked by cross origin policies.\n    if (duration === 0 && startTime < responseEnd) {\n        return elapsed(startTime, responseEnd);\n    }\n    return duration;\n}\nexport function computeResourceEntryDetails(entry) {\n    if (!hasValidResourceEntryTimings(entry)) {\n        return undefined;\n    }\n    const { startTime, fetchStart, workerStart, redirectStart, redirectEnd, domainLookupStart, domainLookupEnd, connectStart, secureConnectionStart, connectEnd, requestStart, responseStart, responseEnd, } = entry;\n    const details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a worker processing time is recorded\n    if (0 < workerStart && workerStart < fetchStart) {\n        details.worker = formatTiming(startTime, workerStart, fetchStart);\n    }\n    // Make sure a connection occurred\n    if (fetchStart < connectEnd) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (fetchStart < domainLookupEnd) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    // Make sure a redirection occurred\n    if (startTime < redirectEnd) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\n/**\n * Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM\n * Resource events with negative durations anyway.\n * Since Chromium 128, more entries have unexpected negative durations, see\n * https://issues.chromium.org/issues/363031537\n */\nexport function hasValidResourceEntryDuration(entry) {\n    return entry.duration >= 0;\n}\nexport function hasValidResourceEntryTimings(entry) {\n    // Ensure timings are in the right order. On top of filtering out potential invalid\n    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n    // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n    // it.\n    const areCommonTimingsInOrder = areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd);\n    const areRedirectionTimingsInOrder = hasRedirection(entry)\n        ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart)\n        : true;\n    return areCommonTimingsInOrder && areRedirectionTimingsInOrder;\n}\nfunction hasRedirection(entry) {\n    return entry.redirectEnd > entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    if (origin <= start && start <= end) {\n        return {\n            duration: toServerDuration(elapsed(start, end)),\n            start: toServerDuration(elapsed(origin, start)),\n        };\n    }\n}\n/**\n * The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,\n * meaning the protocol is unknown, and we shouldn't report it.\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources\n */\nexport function computeResourceEntryProtocol(entry) {\n    return entry.nextHopProtocol === '' ? undefined : entry.nextHopProtocol;\n}\n/**\n * Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),\n * undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).\n * see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType\n */\nexport function computeResourceEntryDeliveryType(entry) {\n    return entry.deliveryType === '' ? 'other' : entry.deliveryType;\n}\nexport function computeResourceEntrySize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        const { encodedBodySize, decodedBodySize, transferSize } = entry;\n        return {\n            size: decodedBodySize,\n            encoded_body_size: encodedBodySize,\n            decoded_body_size: decodedBodySize,\n            transfer_size: transferSize,\n        };\n    }\n    return {\n        size: undefined,\n        encoded_body_size: undefined,\n        decoded_body_size: undefined,\n        transfer_size: undefined,\n    };\n}\nexport function isAllowedRequestUrl(url) {\n    return url && (!isIntakeUrl(url) || isExperimentalFeatureEnabled(ExperimentalFeature.TRACK_INTAKE_REQUESTS));\n}\nconst DATA_URL_REGEX = /data:(.+)?(;base64)?,/g;\nexport const MAX_RESOURCE_VALUE_CHAR_LENGTH = 24000;\nexport function sanitizeIfLongDataUrl(url, lengthLimit = MAX_RESOURCE_VALUE_CHAR_LENGTH) {\n    if (url.length <= lengthLimit || !url.startsWith('data:')) {\n        return url;\n    }\n    // truncate url first to a random length to prevent match error when the url is too long\n    const dataUrlMatchArray = url.substring(0, 100).match(DATA_URL_REGEX);\n    if (!dataUrlMatchArray) {\n        return url;\n    }\n    return `${dataUrlMatchArray[0]}[...]`;\n}\n//# sourceMappingURL=resourceUtils.js.map","import { RequestType, initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nlet nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager, userContext, accountContext) {\n    const tracer = startTracer(configuration, sessionManager, userContext, accountContext);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    const subscription = initXhrObservable(configuration).subscribe((rawContext) => {\n        const context = rawContext;\n        if (!isAllowedRequestUrl(context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceXhr(context, context.xhr);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    traceSampled: context.traceSampled,\n                    type: RequestType.XHR,\n                    url: context.url,\n                    xhr: context.xhr,\n                    isAborted: context.isAborted,\n                    handlingStack: context.handlingStack,\n                    body: context.body,\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nexport function trackFetch(lifeCycle, tracer) {\n    const subscription = initFetchObservable().subscribe((rawContext) => {\n        const context = rawContext;\n        if (!isAllowedRequestUrl(context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, (duration) => {\n                    var _a;\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration,\n                        method: context.method,\n                        requestIndex: context.requestIndex,\n                        responseType: context.responseType,\n                        spanId: context.spanId,\n                        startClocks: context.startClocks,\n                        status: context.status,\n                        traceId: context.traceId,\n                        traceSampled: context.traceSampled,\n                        type: RequestType.FETCH,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                        isAborted: context.isAborted,\n                        handlingStack: context.handlingStack,\n                        body: (_a = context.init) === null || _a === void 0 ? void 0 : _a.body,\n                    });\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nfunction getNextRequestIndex() {\n    const result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\nfunction waitForResponseToComplete(context, callback) {\n    const clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, () => {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","import { monitor } from './monitor';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n    const reader = stream.getReader();\n    const chunks = [];\n    let readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor((result) => {\n            if (result.done) {\n                onDone();\n                return;\n            }\n            if (options.collectStreamBody) {\n                chunks.push(result.value);\n            }\n            readBytesCount += result.value.length;\n            if (readBytesCount > options.bytesLimit) {\n                onDone();\n            }\n            else {\n                readMore();\n            }\n        }), monitor((error) => callback(error)));\n    }\n    function onDone() {\n        reader.cancel().catch(\n        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n        // as an unhandled rejection\n        noop);\n        let bytes;\n        let limitExceeded;\n        if (options.collectStreamBody) {\n            let completeBuffer;\n            if (chunks.length === 1) {\n                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n                // use it directly.\n                completeBuffer = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer = new Uint8Array(readBytesCount);\n                let offset = 0;\n                chunks.forEach((chunk) => {\n                    completeBuffer.set(chunk, offset);\n                    offset += chunk.length;\n                });\n            }\n            bytes = completeBuffer.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer.length > options.bytesLimit;\n        }\n        callback(undefined, bytes, limitExceeded);\n    }\n}\n//# sourceMappingURL=readBytesFromStream.js.map","import { isNumber } from '@datadog/browser-core';\nexport function discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=discardNegativeDuration.js.map","import { noop } from '@datadog/browser-core';\nimport { RumEventType } from '../rawRumEvent.types';\nexport function trackEventCounts({ lifeCycle, isChildEvent, onChange: callback = noop, }) {\n    const eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    const subscription = lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (event) => {\n        var _a;\n        if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event)) {\n            return;\n        }\n        switch (event.type) {\n            case RumEventType.ERROR:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case RumEventType.ACTION:\n                eventCounts.actionCount += 1;\n                if (event.action.frustration) {\n                    eventCounts.frustrationCount += event.action.frustration.type.length;\n                }\n                callback();\n                break;\n            case RumEventType.LONG_TASK:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case RumEventType.RESOURCE:\n                if (!((_a = event._dd) === null || _a === void 0 ? void 0 : _a.discarded)) {\n                    eventCounts.resourceCount += 1;\n                    callback();\n                }\n                break;\n        }\n    });\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n        eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { addEventListeners, dateNow, relativeNow } from '@datadog/browser-core';\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nexport function retrieveFirstInputTiming(configuration, callback) {\n    const startTimeStamp = dateNow();\n    let timingSent = false;\n    const { stop: removeEventListeners } = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"mousedown\" /* DOM_EVENT.MOUSE_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */], (evt) => {\n        // Only count cancelable events, which should trigger behavior important to the user.\n        if (!evt.cancelable) {\n            return;\n        }\n        // This timing will be used to compute the \"first Input delay\", which is the delta between\n        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n        // (e.g. performance.now()).\n        const timing = {\n            entryType: 'first-input',\n            processingStart: relativeNow(),\n            processingEnd: relativeNow(),\n            startTime: evt.timeStamp,\n            duration: 0, // arbitrary value to avoid nullable duration and simplify INP logic\n            name: '',\n            cancelable: false,\n            target: null,\n            toJSON: () => ({}),\n        };\n        if (evt.type === \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(configuration, timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true });\n    return { stop: removeEventListeners };\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(configuration, timing) {\n        addEventListeners(configuration, window, [\"pointerup\" /* DOM_EVENT.POINTER_UP */, \"pointercancel\" /* DOM_EVENT.POINTER_CANCEL */], (event) => {\n            if (event.type === \"pointerup\" /* DOM_EVENT.POINTER_UP */) {\n                sendTiming(timing);\n            }\n        }, { once: true });\n    }\n    function sendTiming(timing) {\n        if (!timingSent) {\n            timingSent = true;\n            removeEventListeners();\n            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n            // the time between now and when the page was loaded.\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n            const delay = timing.processingStart - timing.startTime;\n            if (delay >= 0 && delay < dateNow() - startTimeStamp) {\n                callback(timing);\n            }\n        }\n    }\n}\n//# sourceMappingURL=firstInputPolyfill.js.map","import { addEventListener, Observable, setTimeout, clearTimeout, monitor } from '@datadog/browser-core';\nimport { hasValidResourceEntryDuration, isAllowedRequestUrl } from '../domain/resource/resourceUtils';\nimport { retrieveFirstInputTiming } from './firstInputPolyfill';\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected performance entry\n// eslint-disable-next-line no-restricted-syntax\nexport var RumPerformanceEntryType;\n(function (RumPerformanceEntryType) {\n    RumPerformanceEntryType[\"EVENT\"] = \"event\";\n    RumPerformanceEntryType[\"FIRST_INPUT\"] = \"first-input\";\n    RumPerformanceEntryType[\"LARGEST_CONTENTFUL_PAINT\"] = \"largest-contentful-paint\";\n    RumPerformanceEntryType[\"LAYOUT_SHIFT\"] = \"layout-shift\";\n    RumPerformanceEntryType[\"LONG_TASK\"] = \"longtask\";\n    RumPerformanceEntryType[\"LONG_ANIMATION_FRAME\"] = \"long-animation-frame\";\n    RumPerformanceEntryType[\"NAVIGATION\"] = \"navigation\";\n    RumPerformanceEntryType[\"PAINT\"] = \"paint\";\n    RumPerformanceEntryType[\"RESOURCE\"] = \"resource\";\n    RumPerformanceEntryType[\"VISIBILITY_STATE\"] = \"visibility-state\";\n})(RumPerformanceEntryType || (RumPerformanceEntryType = {}));\nexport function createPerformanceObservable(configuration, options) {\n    return new Observable((observable) => {\n        if (!window.PerformanceObserver) {\n            return;\n        }\n        const handlePerformanceEntries = (entries) => {\n            const rumPerformanceEntries = filterRumPerformanceEntries(entries);\n            if (rumPerformanceEntries.length > 0) {\n                observable.notify(rumPerformanceEntries);\n            }\n        };\n        let timeoutId;\n        let isObserverInitializing = true;\n        const observer = new PerformanceObserver(monitor((entries) => {\n            // In Safari the performance observer callback is synchronous.\n            // Because the buffered performance entry list can be quite large we delay the computation to prevent the SDK from blocking the main thread on init\n            if (isObserverInitializing) {\n                timeoutId = setTimeout(() => handlePerformanceEntries(entries.getEntries()));\n            }\n            else {\n                handlePerformanceEntries(entries.getEntries());\n            }\n        }));\n        try {\n            observer.observe(options);\n        }\n        catch (_a) {\n            // Some old browser versions (<= chrome 74 ) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to getEntriesByType and PerformanceObserver with entryTypes\n            // TODO: remove this fallback in the next major version\n            const fallbackSupportedEntryTypes = [\n                RumPerformanceEntryType.RESOURCE,\n                RumPerformanceEntryType.NAVIGATION,\n                RumPerformanceEntryType.LONG_TASK,\n                RumPerformanceEntryType.PAINT,\n            ];\n            if (fallbackSupportedEntryTypes.includes(options.type)) {\n                if (options.buffered) {\n                    timeoutId = setTimeout(() => handlePerformanceEntries(performance.getEntriesByType(options.type)));\n                }\n                try {\n                    observer.observe({ entryTypes: [options.type] });\n                }\n                catch (_b) {\n                    // Old versions of Safari are throwing \"entryTypes contained only unsupported types\"\n                    // errors when observing only unsupported entry types.\n                    //\n                    // We could use `supportPerformanceTimingEvent` to make sure we don't invoke\n                    // `observer.observe` with an unsupported entry type, but Safari 11 and 12 don't support\n                    // `Performance.supportedEntryTypes`, so doing so would lose support for these versions\n                    // even if they do support the entry type.\n                    return;\n                }\n            }\n        }\n        isObserverInitializing = false;\n        manageResourceTimingBufferFull(configuration);\n        let stopFirstInputTiming;\n        if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT) &&\n            options.type === RumPerformanceEntryType.FIRST_INPUT) {\n            ;\n            ({ stop: stopFirstInputTiming } = retrieveFirstInputTiming(configuration, (timing) => {\n                handlePerformanceEntries([timing]);\n            }));\n        }\n        return () => {\n            observer.disconnect();\n            if (stopFirstInputTiming) {\n                stopFirstInputTiming();\n            }\n            clearTimeout(timeoutId);\n        };\n    });\n}\nlet resourceTimingBufferFullListener;\nfunction manageResourceTimingBufferFull(configuration) {\n    if (!resourceTimingBufferFullListener && supportPerformanceObject() && 'addEventListener' in performance) {\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n        resourceTimingBufferFullListener = addEventListener(configuration, performance, 'resourcetimingbufferfull', () => {\n            performance.clearResourceTimings();\n        });\n    }\n    return () => {\n        resourceTimingBufferFullListener === null || resourceTimingBufferFullListener === void 0 ? void 0 : resourceTimingBufferFullListener.stop();\n    };\n}\nfunction supportPerformanceObject() {\n    return window.performance !== undefined && 'getEntries' in performance;\n}\nexport function supportPerformanceTimingEvent(entryType) {\n    return (window.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes !== undefined &&\n        PerformanceObserver.supportedEntryTypes.includes(entryType));\n}\nfunction filterRumPerformanceEntries(entries) {\n    return entries.filter((entry) => !isForbiddenResource(entry));\n}\nfunction isForbiddenResource(entry) {\n    return (entry.entryType === RumPerformanceEntryType.RESOURCE &&\n        (!isAllowedRequestUrl(entry.name) || !hasValidResourceEntryDuration(entry)));\n}\n//# sourceMappingURL=performanceObservable.js.map","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    const shadowRoot = node;\n    return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);\n}\nexport function hasChildNodes(node) {\n    return node.childNodes.length > 0 || isNodeShadowHost(node);\n}\nexport function forEachChildNodes(node, callback) {\n    let child = node.firstChild;\n    while (child) {\n        callback(child);\n        child = child.nextSibling;\n    }\n    if (isNodeShadowHost(node)) {\n        callback(node.shadowRoot);\n    }\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../browser/performanceObservable';\nimport { isElementNode } from '../browser/htmlDomUtils';\n// Delay to wait for a page activity to validate the tracking process\nexport const PAGE_ACTIVITY_VALIDATION_DELAY = 100;\n// Delay to wait after a page activity to end the tracking process\nexport const PAGE_ACTIVITY_END_DELAY = 100;\nexport const EXCLUDED_MUTATIONS_ATTRIBUTE = 'data-dd-excluded-activity-mutations';\n/**\n * Wait for the page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, pageActivityEndCallback, maxDuration) {\n    const pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    let pageActivityEndTimeoutId;\n    let hasCompleted = false;\n    const validationTimeoutId = setTimeout(monitor(() => complete({ hadActivity: false })), PAGE_ACTIVITY_VALIDATION_DELAY);\n    const maxDurationTimeoutId = maxDuration !== undefined\n        ? setTimeout(monitor(() => complete({ hadActivity: true, end: timeStampNow() })), maxDuration)\n        : undefined;\n    const pageActivitySubscription = pageActivityObservable.subscribe(({ isBusy }) => {\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        const lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = setTimeout(monitor(() => complete({ hadActivity: true, end: lastChangeTime })), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    const stop = () => {\n        hasCompleted = true;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        pageActivityEndCallback(event);\n    }\n    return { stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    return new Observable((observable) => {\n        const subscriptions = [];\n        let firstRequestIndex;\n        let pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe((mutations) => {\n            if (!mutations.every(isExcludedMutation)) {\n                notifyPageActivity();\n            }\n        }), windowOpenObservable.subscribe(notifyPageActivity), createPerformanceObservable(configuration, { type: RumPerformanceEntryType.RESOURCE }).subscribe((entries) => {\n            if (entries.some((entry) => !isExcludedUrl(configuration, entry.name))) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(7 /* LifeCycleEventType.REQUEST_STARTED */, (startEvent) => {\n            if (isExcludedUrl(configuration, startEvent.url)) {\n                return;\n            }\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            pendingRequestsCount += 1;\n            notifyPageActivity();\n        }), lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, (request) => {\n            if (isExcludedUrl(configuration, request.url) ||\n                firstRequestIndex === undefined ||\n                // If the request started before the tracking start, ignore it\n                request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            pendingRequestsCount -= 1;\n            notifyPageActivity();\n        }));\n        return () => {\n            subscriptions.forEach((s) => s.unsubscribe());\n        };\n        function notifyPageActivity() {\n            observable.notify({ isBusy: pendingRequestsCount > 0 });\n        }\n    });\n}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction isExcludedMutation(mutation) {\n    const targetElement = mutation.type === 'characterData' ? mutation.target.parentElement : mutation.target;\n    return Boolean(targetElement &&\n        isElementNode(targetElement) &&\n        targetElement.matches(`[${EXCLUDED_MUTATIONS_ATTRIBUTE}], [${EXCLUDED_MUTATIONS_ATTRIBUTE}] *`));\n}\n//# sourceMappingURL=waitPageActivityEnd.js.map","/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nexport const DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name';\nexport const ACTION_NAME_PLACEHOLDER = 'Masked Element';\nexport const ACTION_NAME_MASK = 'xxx';\n//# sourceMappingURL=actionNameConstants.js.map","import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/actionNameConstants';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport const STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nconst GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nconst UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    if (!targetElement.isConnected) {\n        // We cannot compute a selector for a detached element, as we don't have access to all of its\n        // parents, and we cannot determine if it's unique in the document.\n        return;\n    }\n    let targetElementSelector;\n    let currentElement = targetElement;\n    while (currentElement && currentElement.nodeName !== 'HTML') {\n        const globallyUniqueSelector = findSelector(currentElement, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        const uniqueSelectorAmongChildren = findSelector(currentElement, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector);\n        currentElement = currentElement.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return `#${CSS.escape(element.id)}`;\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    const classList = element.classList;\n    for (let i = 0; i < classList.length; i += 1) {\n        const className = classList[i];\n        if (isGeneratedValue(className)) {\n            continue;\n        }\n        return `${CSS.escape(element.tagName)}.${CSS.escape(className)}`;\n    }\n}\nfunction getTagNameSelector(element) {\n    return CSS.escape(element.tagName);\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        const selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (const attributeName of STABLE_ATTRIBUTES) {\n        const selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return `${CSS.escape(element.tagName)}[${attributeName}=\"${CSS.escape(element.getAttribute(attributeName))}\"]`;\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    let sibling = element.parentElement.firstElementChild;\n    let elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return `${CSS.escape(element.tagName)}:nth-of-type(${elementIndex})`;\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (const selectorGetter of selectorGetters) {\n        const elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        if (predicate(element, elementSelector, childSelector)) {\n            return combineSelector(elementSelector, childSelector);\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, elementSelector, childSelector) {\n    return element.ownerDocument.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > CHILD_SELECTOR\" returns a single element.\n *\n * @param currentElement - the element being considered while iterating over the target\n * element ancestors.\n * @param currentElementSelector - a selector that matches the current element. That\n * selector is not a composed selector (i.e. it might be a single tag name, class name...).\n * @param childSelector - child selector is a selector that targets a descendant\n * of the current element. When undefined, the current element is the target element.\n *\n * # Scope selector usage\n *\n * When composed together, the final selector will be joined with `>` operators to make sure we\n * target direct descendants at each level. In this function, we'll use `querySelector` to check if\n * a selector matches descendants of the current element. But by default, the query selector match\n * elements at any level. Example:\n *\n * ```html\n * <main>\n *   <div>\n *     <span></span>\n *   </div>\n *   <marquee>\n *     <div>\n *       <span></span>\n *     </div>\n *   </marquee>\n * </main>\n * ```\n *\n * `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the\n * selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`\n * operator (`MAIN > DIV > SPAN`).\n *\n * To avoid this, we can use the `:scope` selector to make sure the selector starts from the current\n * sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).\n *\n * [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope\n *\n * # Performance considerations\n *\n * We compute selectors in performance-critical operations (ex: during a click), so we need to make\n * sure the function is as fast as possible. We observed that naively using `querySelectorAll` to\n * check if the selector matches more than 1 element is quite expensive, so we want to avoid it.\n *\n * Because we are iterating the DOM upward and we use that function at every level, we know the\n * child selector is already unique among the current element children, so we don't need to check\n * for the current element subtree.\n *\n * Instead, we can focus on the current element siblings. If we find a single element matching the\n * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`\n * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.\n */\nexport function isSelectorUniqueAmongSiblings(currentElement, currentElementSelector, childSelector) {\n    let isSiblingMatching;\n    if (childSelector === undefined) {\n        // If the child selector is undefined (meaning `currentElement` is the target element, not one\n        // of its ancestor), we need to use `matches` to check if the sibling is matching the selector,\n        // as `querySelector` only returns a descendant of the element.\n        isSiblingMatching = (sibling) => sibling.matches(currentElementSelector);\n    }\n    else {\n        const scopedSelector = combineSelector(`${currentElementSelector}:scope`, childSelector);\n        isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null;\n    }\n    const parent = currentElement.parentElement;\n    let sibling = parent.firstElementChild;\n    while (sibling) {\n        if (sibling !== currentElement && isSiblingMatching(sibling)) {\n            return false;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return true;\n}\nfunction combineSelector(parent, child) {\n    return child ? `${parent}>${child}` : parent;\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport const NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n    MASK_UNLESS_ALLOWLISTED: DefaultPrivacyLevel.MASK_UNLESS_ALLOWLISTED,\n};\nexport const PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport const PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport const PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport const PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport const PRIVACY_ATTR_VALUE_MASK_UNLESS_ALLOWLISTED = 'mask-unless-allowlisted';\nexport const PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport const PRIVACY_CLASS_PREFIX = 'dd-privacy-';\n// Private Replacement Templates\nexport const CENSORED_STRING_MARK = '***';\nexport const CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport const FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\nexport const TEXT_MASKING_CHAR = 'x';\nexport function getPrivacySelector(privacyLevel) {\n    return `[${PRIVACY_ATTR_NAME}=\"${privacyLevel}\"], .${PRIVACY_CLASS_PREFIX}${privacyLevel}`;\n}\n//# sourceMappingURL=privacyConstants.js.map","import { isElementNode, getParentNode, isTextNode } from '../browser/htmlDomUtils';\nimport { NodePrivacyLevel, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, getPrivacySelector, TEXT_MASKING_CHAR, } from './privacyConstants';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel, cache) {\n    if (cache && cache.has(node)) {\n        return cache.get(node);\n    }\n    const parentNode = getParentNode(node);\n    const parentNodePrivacyLevel = parentNode\n        ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel, cache)\n        : defaultPrivacyLevel;\n    const selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    const nodePrivacyLevel = reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n    if (cache) {\n        cache.set(node, nodePrivacyLevel);\n    }\n    return nodePrivacyLevel;\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElementNode(node)) {\n        return;\n    }\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        const inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        const autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year/new-password/current-password]\n        if (autocomplete && (autocomplete.startsWith('cc-') || autocomplete.endsWith('-password'))) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (node.matches(getPrivacySelector(NodePrivacyLevel.HIDDEN))) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK))) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED))) {\n        return NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED;\n    }\n    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK_USER_INPUT))) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (node.matches(getPrivacySelector(NodePrivacyLevel.ALLOW))) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED:\n            if (isTextNode(node)) {\n                // Always return true if our parent is a form element, like MASK_USER_INPUT.\n                // Otherwise, decide whether to mask based on the allowlist.\n                return isFormElement(node.parentNode) ? true : !isAllowlisted(node.textContent || '');\n            }\n            // Always return true if we're a form element, like MASK_USER_INPUT.\n            // Otherwise, return false; MASK_UNLESS_ALLOWLISTED only directly masks text nodes.\n            return isFormElement(node);\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    const element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nconst censorText = (text) => text.replace(/\\S/g, TEXT_MASKING_CHAR);\nexport function getTextContent(textNode, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    const parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    let textContent = textNode.textContent || '';\n    const shouldIgnoreWhiteSpace = parentTagName === 'HEAD';\n    if (shouldIgnoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    const nodePrivacyLevel = parentNodePrivacyLevel;\n    const isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel)) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else if (nodePrivacyLevel === NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED) {\n            textContent = maskDisallowedTextContent(textContent);\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        const relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        const nameAttribute = getLowerCaseAttribute('name');\n        const relAttribute = getLowerCaseAttribute('rel');\n        const propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\nexport function isAllowlisted(text) {\n    var _a;\n    if (!text || !text.trim()) {\n        return true;\n    }\n    // We are using toLocaleLowerCase when adding to the allowlist to avoid case sensitivity\n    // so we need to do the same here\n    return ((_a = window.$DD_ALLOW) === null || _a === void 0 ? void 0 : _a.has(text.toLocaleLowerCase())) || false;\n}\nexport function maskDisallowedTextContent(text, fixedMask) {\n    if (isAllowlisted(text)) {\n        return text;\n    }\n    return fixedMask || censorText(text);\n}\n//# sourceMappingURL=privacy.js.map","import { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nexport const MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport const MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    const bufferedClicks = [];\n    let status = 0 /* ClickChainStatus.WaitingForMoreClicks */;\n    let maxDurationBetweenClicksTimeoutId;\n    appendClick(firstClick);\n    function appendClick(click) {\n        click.stopObservable.subscribe(tryFinalize);\n        bufferedClicks.push(click);\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        maxDurationBetweenClicksTimeoutId = setTimeout(dontAcceptMoreClick, MAX_DURATION_BETWEEN_CLICKS);\n    }\n    function tryFinalize() {\n        if (status === 1 /* ClickChainStatus.WaitingForClicksToStop */ && bufferedClicks.every((click) => click.isStopped())) {\n            status = 2 /* ClickChainStatus.Finalized */;\n            onFinalize(bufferedClicks);\n        }\n    }\n    function dontAcceptMoreClick() {\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        if (status === 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n            status = 1 /* ClickChainStatus.WaitingForClicksToStop */;\n            tryFinalize();\n        }\n    }\n    return {\n        tryAppend: (click) => {\n            if (status !== 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n                return false;\n            }\n            if (bufferedClicks.length > 0 &&\n                !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)) {\n                dontAcceptMoreClick();\n                return false;\n            }\n            appendClick(click);\n            return true;\n        },\n        stop: () => {\n            dontAcceptMoreClick();\n        },\n    };\n}\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first, second) {\n    return (first.target === second.target &&\n        mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n        first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS);\n}\nfunction mouseEventDistance(origin, other) {\n    return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2));\n}\n//# sourceMappingURL=clickChain.js.map","import { ExperimentalFeature, isExperimentalFeatureEnabled, safeTruncate } from '@datadog/browser-core';\nimport { getPrivacySelector, NodePrivacyLevel } from '../privacyConstants';\nimport { getNodePrivacyLevel, shouldMaskNode } from '../privacy';\nimport { isElementNode } from '../../browser/htmlDomUtils';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, ACTION_NAME_PLACEHOLDER, } from './actionNameConstants';\nexport function getActionNameFromElement(element, rumConfiguration, nodePrivacyLevel = NodePrivacyLevel.ALLOW) {\n    const { actionNameAttribute: userProgrammaticAttribute } = rumConfiguration;\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, if privacy is set to mask, return a placeholder for the undefined.\n    // * if privacy is not set to mask, use strategies that are known to return good results.\n    //   Those strategies will be used on the element and a few parents, but it's likely that they won't succeed at all.\n    // * if no name is found this way, use strategies returning less accurate names as a fallback.\n    //   Those are much likely to succeed.\n    const defaultActionName = getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute));\n    if (defaultActionName) {\n        return { name: defaultActionName, nameSource: \"custom_attribute\" /* ActionNameSource.CUSTOM_ATTRIBUTE */ };\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n        return { name: ACTION_NAME_PLACEHOLDER, nameSource: \"mask_placeholder\" /* ActionNameSource.MASK_PLACEHOLDER */ };\n    }\n    return (getActionNameFromElementForStrategies(element, priorityStrategies, rumConfiguration) ||\n        getActionNameFromElementForStrategies(element, fallbackStrategies, rumConfiguration) || {\n        name: '',\n        nameSource: \"blank\" /* ActionNameSource.BLANK */,\n    });\n}\nfunction getActionNameFromElementProgrammatically(targetElement, programmaticAttribute) {\n    // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n    // without limit. It is up to the user to declare a relevant naming strategy.\n    const elementWithAttribute = targetElement.closest(`[${programmaticAttribute}]`);\n    if (!elementWithAttribute) {\n        return;\n    }\n    const name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nconst priorityStrategies = [\n    // associated LABEL text\n    (element, rumConfiguration) => {\n        if ('labels' in element && element.labels && element.labels.length > 0) {\n            return getActionNameFromTextualContent(element.labels[0], rumConfiguration);\n        }\n    },\n    // INPUT button (and associated) value\n    (element) => {\n        if (element.nodeName === 'INPUT') {\n            const input = element;\n            const type = input.getAttribute('type');\n            if (type === 'button' || type === 'submit' || type === 'reset') {\n                return { name: input.value, nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */ };\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    (element, rumConfiguration) => {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getActionNameFromTextualContent(element, rumConfiguration);\n        }\n    },\n    (element) => getActionNameFromStandardAttribute(element, 'aria-label'),\n    // associated element text designated by the aria-labelledby attribute\n    (element, rumConfiguration) => {\n        const labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return {\n                name: labelledByAttribute\n                    .split(/\\s+/)\n                    .map((id) => getElementById(element, id))\n                    .filter((label) => Boolean(label))\n                    .map((element) => getTextualContent(element, rumConfiguration))\n                    .join(' '),\n                nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n            };\n        }\n    },\n    (element) => getActionNameFromStandardAttribute(element, 'alt'),\n    (element) => getActionNameFromStandardAttribute(element, 'name'),\n    (element) => getActionNameFromStandardAttribute(element, 'title'),\n    (element) => getActionNameFromStandardAttribute(element, 'placeholder'),\n    // SELECT first OPTION text\n    (element, rumConfiguration) => {\n        if ('options' in element && element.options.length > 0) {\n            return getActionNameFromTextualContent(element.options[0], rumConfiguration);\n        }\n    },\n];\nconst fallbackStrategies = [\n    (element, rumConfiguration) => getActionNameFromTextualContent(element, rumConfiguration),\n];\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nconst MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, strategies, rumConfiguration) {\n    let element = targetElement;\n    let recursionCounter = 0;\n    while (recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n        element &&\n        element.nodeName !== 'BODY' &&\n        element.nodeName !== 'HTML' &&\n        element.nodeName !== 'HEAD') {\n        for (const strategy of strategies) {\n            const actionName = strategy(element, rumConfiguration);\n            if (actionName) {\n                const { name, nameSource } = actionName;\n                const trimmedName = name && name.trim();\n                if (trimmedName) {\n                    return { name: truncate(normalizeWhitespace(trimmedName)), nameSource };\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? `${safeTruncate(s, 100)} [...]` : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getActionNameFromStandardAttribute(element, attribute) {\n    return {\n        name: element.getAttribute(attribute) || '',\n        nameSource: \"standard_attribute\" /* ActionNameSource.STANDARD_ATTRIBUTE */,\n    };\n}\nfunction getActionNameFromTextualContent(element, rumConfiguration) {\n    return {\n        name: getTextualContent(element, rumConfiguration) || '',\n        nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n    };\n}\nfunction getTextualContent(element, rumConfiguration) {\n    if (element.isContentEditable) {\n        return;\n    }\n    const { enablePrivacyForActionName, actionNameAttribute: userProgrammaticAttribute, defaultPrivacyLevel, } = rumConfiguration;\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.USE_TREE_WALKER_FOR_ACTION_NAME)) {\n        return getTextualContentWithTreeWalker(element, userProgrammaticAttribute, enablePrivacyForActionName, defaultPrivacyLevel);\n    }\n    if ('innerText' in element) {\n        let text = element.innerText;\n        const removeTextFromElements = (query) => {\n            const list = element.querySelectorAll(query);\n            for (let index = 0; index < list.length; index += 1) {\n                const element = list[index];\n                if ('innerText' in element) {\n                    const textToReplace = element.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text = text.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(`[${DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE}]`);\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(`[${userProgrammaticAttribute}]`);\n        }\n        if (enablePrivacyForActionName) {\n            // remove the text of elements with privacy override\n            removeTextFromElements(`${getPrivacySelector(NodePrivacyLevel.HIDDEN)}, ${getPrivacySelector(NodePrivacyLevel.MASK)}`);\n        }\n        return text;\n    }\n    return element.textContent;\n}\nfunction getTextualContentWithTreeWalker(element, userProgrammaticAttribute, privacyEnabledActionName, defaultPrivacyLevel) {\n    const nodePrivacyLevelCache = new Map();\n    const walker = document.createTreeWalker(element, \n    // eslint-disable-next-line no-bitwise\n    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, rejectInvisibleOrMaskedElementsFilter);\n    let text = '';\n    while (walker.nextNode()) {\n        const node = walker.currentNode;\n        if (isElementNode(node)) {\n            if (\n            // Following InnerText rendering spec https://html.spec.whatwg.org/multipage/dom.html#rendered-text-collection-steps\n            node.nodeName === 'BR' ||\n                node.nodeName === 'P' ||\n                ['block', 'flex', 'grid', 'list-item', 'table', 'table-caption'].includes(getComputedStyle(node).display)) {\n                text += ' ';\n            }\n            continue; // skip element nodes\n        }\n        text += node.textContent || '';\n    }\n    return text.replace(/\\s+/g, ' ').trim();\n    function rejectInvisibleOrMaskedElementsFilter(node) {\n        const nodeSelfPrivacyLevel = getNodePrivacyLevel(node, defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (privacyEnabledActionName && nodeSelfPrivacyLevel && shouldMaskNode(node, nodeSelfPrivacyLevel)) {\n            return NodeFilter.FILTER_REJECT;\n        }\n        if (isElementNode(node)) {\n            if (node.hasAttribute(DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n                (userProgrammaticAttribute && node.hasAttribute(userProgrammaticAttribute))) {\n                return NodeFilter.FILTER_REJECT;\n            }\n            const style = getComputedStyle(node);\n            if (style.visibility !== 'visible' ||\n                style.display === 'none' ||\n                (style.contentVisibility && style.contentVisibility !== 'visible')\n            // contentVisibility is not supported in all browsers, so we need to check it\n            ) {\n                return NodeFilter.FILTER_REJECT;\n            }\n        }\n        return NodeFilter.FILTER_ACCEPT;\n    }\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { addEventListener } from '@datadog/browser-core';\nexport function listenActionEvents(configuration, { onPointerDown, onPointerUp }) {\n    let selectionEmptyAtPointerDown;\n    let userActivity = {\n        selection: false,\n        input: false,\n        scroll: false,\n    };\n    let clickContext;\n    const listeners = [\n        addEventListener(configuration, window, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, (event) => {\n            if (isValidPointerEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: false,\n                    scroll: false,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"selectionchange\" /* DOM_EVENT.SELECTION_CHANGE */, () => {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, () => {\n            userActivity.scroll = true;\n        }, { capture: true, passive: true }),\n        addEventListener(configuration, window, \"pointerup\" /* DOM_EVENT.POINTER_UP */, (event) => {\n            if (isValidPointerEvent(event) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                const localUserActivity = userActivity;\n                onPointerUp(clickContext, event, () => localUserActivity);\n                clickContext = undefined;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"input\" /* DOM_EVENT.INPUT */, () => {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: () => {\n            listeners.forEach((listener) => listener.stop());\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    const selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidPointerEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        event.isPrimary !== false);\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { ONE_SECOND } from '@datadog/browser-core';\nimport { FrustrationType } from '../../rawRumEvent.types';\nconst MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(FrustrationType.RAGE_CLICK);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(FrustrationType.DEAD_CLICK);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(FrustrationType.ERROR_CLICK);\n        }\n        return { isRage: true };\n    }\n    const hasSelectionChanged = clicks.some((click) => click.getUserActivity().selection);\n    clicks.forEach((click) => {\n        if (click.hasError) {\n            click.addFrustration(FrustrationType.ERROR_CLICK);\n        }\n        if (isDead(click) &&\n            // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n            !hasSelectionChanged) {\n            click.addFrustration(FrustrationType.DEAD_CLICK);\n        }\n    });\n    return { isRage: false };\n}\nexport function isRage(clicks) {\n    if (clicks.some((click) => click.getUserActivity().selection || click.getUserActivity().scroll)) {\n        return false;\n    }\n    for (let i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n        if (clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n            ONE_SECOND) {\n            return true;\n        }\n    }\n    return false;\n}\nconst DEAD_CLICK_EXCLUDE_SELECTOR = \n// inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n// inputs (using a negative selector is shorter here)\n'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n    'textarea,' +\n    'select,' +\n    // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n    '[contenteditable],' +\n    '[contenteditable] *,' +\n    // canvas, as there is no good way to detect activity occurring on them\n    'canvas,' +\n    // links that are interactive (have an href attribute) or any of their descendants, as they can\n    // open a new tab or navigate to a hash without triggering a meaningful event\n    'a[href],' +\n    'a[href] *';\nexport function isDead(click) {\n    if (click.hasPageActivity || click.getUserActivity().input || click.getUserActivity().scroll) {\n        return false;\n    }\n    let target = click.event.target;\n    if (target.tagName === 'LABEL' && target.hasAttribute('for')) {\n        target = document.getElementById(target.getAttribute('for'));\n    }\n    return !target || !target.matches(DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { elapsed, ONE_SECOND, relativeNow } from '@datadog/browser-core';\n// Maximum duration for click actions\nexport const CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport const interactionSelectorCache = new Map();\nexport function getInteractionSelector(relativeTimestamp) {\n    const selector = interactionSelectorCache.get(relativeTimestamp);\n    interactionSelectorCache.delete(relativeTimestamp);\n    return selector;\n}\nexport function updateInteractionSelector(relativeTimestamp, selector) {\n    interactionSelectorCache.set(relativeTimestamp, selector);\n    interactionSelectorCache.forEach((_, relativeTimestamp) => {\n        if (elapsed(relativeTimestamp, relativeNow()) > CLICK_ACTION_MAX_DURATION) {\n            interactionSelectorCache.delete(relativeTimestamp);\n        }\n    });\n}\n//# sourceMappingURL=interactionSelectorCache.js.map","import { timeStampNow, Observable, getRelativeTime, ONE_MINUTE, generateUUID, clocksNow, elapsed, createValueHistory, PageExitReason, } from '@datadog/browser-core';\nimport { ActionType } from '../../rawRumEvent.types';\nimport { trackEventCounts } from '../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../waitPageActivityEnd';\nimport { getSelectorFromElement } from '../getSelectorFromElement';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { NodePrivacyLevel } from '../privacyConstants';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\nimport { CLICK_ACTION_MAX_DURATION, updateInteractionSelector } from './interactionSelectorCache';\nexport const ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    const history = createValueHistory({ expireDelay: ACTION_CONTEXT_TIME_OUT_DELAY });\n    const stopObservable = new Observable();\n    let currentClickChain;\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        history.reset();\n    });\n    lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, (event) => {\n        if (event.reason === PageExitReason.UNLOADING) {\n            stopClickChain();\n        }\n    });\n    const { stop: stopActionEventsListener } = listenActionEvents(configuration, {\n        onPointerDown: (pointerDownEvent) => processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable),\n        onPointerUp: ({ clickActionBase, hadActivityOnPointerDown }, startEvent, getUserActivity) => {\n            startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    });\n    const actionContexts = {\n        findActionId: (startTime) => history.findAll(startTime),\n    };\n    return {\n        stop: () => {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            const rageClick = click.clone();\n            currentClickChain = createClickChain(click, (clicks) => {\n                finalizeClicks(clicks, rageClick);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable) {\n    let nodePrivacyLevel;\n    if (configuration.enablePrivacyForActionName) {\n        nodePrivacyLevel = getNodePrivacyLevel(pointerDownEvent.target, configuration.defaultPrivacyLevel);\n    }\n    else {\n        nodePrivacyLevel = NodePrivacyLevel.ALLOW;\n    }\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return undefined;\n    }\n    const clickActionBase = computeClickActionBase(pointerDownEvent, nodePrivacyLevel, configuration);\n    let hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (pageActivityEndEvent) => {\n        hadActivityOnPointerDown = pageActivityEndEvent.hadActivity;\n    }, \n    // We don't care about the activity duration, we just want to know whether an activity did happen\n    // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n    PAGE_ACTIVITY_VALIDATION_DELAY);\n    return { clickActionBase, hadActivityOnPointerDown: () => hadActivityOnPointerDown };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var _a;\n    const click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    appendClickToClickChain(click);\n    const selector = (_a = clickActionBase === null || clickActionBase === void 0 ? void 0 : clickActionBase.target) === null || _a === void 0 ? void 0 : _a.selector;\n    if (selector) {\n        updateInteractionSelector(startEvent.timeStamp, selector);\n    }\n    const { stop: stopWaitPageActivityEnd } = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (pageActivityEndEvent) => {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n            // If the clock is looking weird, just discard the click\n            click.discard();\n        }\n        else {\n            if (pageActivityEndEvent.hadActivity) {\n                click.stop(pageActivityEndEvent.end);\n            }\n            else if (hadActivityOnPointerDown()) {\n                click.stop(\n                // using the click start as activity end, so the click will have some activity but its\n                // duration will be 0 (as the activity started before the click start)\n                click.startClocks.timeStamp);\n            }\n            else {\n                click.stop();\n            }\n        }\n    }, CLICK_ACTION_MAX_DURATION);\n    const viewEndedSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, ({ endClocks }) => {\n        click.stop(endClocks.timeStamp);\n    });\n    const stopSubscription = stopObservable.subscribe(() => {\n        click.stop();\n    });\n    click.stopObservable.subscribe(() => {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, nodePrivacyLevel, configuration) {\n    const rect = event.target.getBoundingClientRect();\n    const selector = getSelectorFromElement(event.target, configuration.actionNameAttribute);\n    if (selector) {\n        updateInteractionSelector(event.timeStamp, selector);\n    }\n    const { name, nameSource } = getActionNameFromElement(event.target, configuration, nodePrivacyLevel);\n    return {\n        type: ActionType.CLICK,\n        target: {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector,\n        },\n        position: {\n            // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n            x: Math.round(event.clientX - rect.left),\n            y: Math.round(event.clientY - rect.top),\n        },\n        name,\n        nameSource,\n    };\n}\nfunction newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent) {\n    const id = generateUUID();\n    const startClocks = clocksNow();\n    const historyEntry = history.add(id, startClocks.relative);\n    const eventCountsSubscription = trackEventCounts({\n        lifeCycle,\n        isChildEvent: (event) => event.action !== undefined &&\n            (Array.isArray(event.action.id) ? event.action.id.includes(id) : event.action.id === id),\n    });\n    let status = 0 /* ClickStatus.ONGOING */;\n    let activityEndTime;\n    const frustrationTypes = [];\n    const stopObservable = new Observable();\n    function stop(newActivityEndTime) {\n        if (status !== 0 /* ClickStatus.ONGOING */) {\n            return;\n        }\n        activityEndTime = newActivityEndTime;\n        status = 1 /* ClickStatus.STOPPED */;\n        if (activityEndTime) {\n            historyEntry.close(getRelativeTime(activityEndTime));\n        }\n        else {\n            historyEntry.remove();\n        }\n        eventCountsSubscription.stop();\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop,\n        stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity,\n        addFrustration: (frustrationType) => {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks,\n        isStopped: () => status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */,\n        clone: () => newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent),\n        validate: (domEvents) => {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            const { resourceCount, errorCount, longTaskCount } = eventCountsSubscription.eventCounts;\n            const clickAction = {\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks,\n                id,\n                frustrationTypes,\n                counts: {\n                    resourceCount,\n                    errorCount,\n                    longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n                ...clickActionBase,\n            };\n            lifeCycle.notify(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n        discard: () => {\n            stop();\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    const { isRage } = computeFrustration(clicks, rageClick);\n    if (isRage) {\n        clicks.forEach((click) => click.discard());\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map((click) => click.event));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach((click) => click.validate());\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, combine, toServerDuration, generateUUID, SKIPPED } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { ActionType, RumEventType } from '../../rawRumEvent.types';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, hooks, domMutationObservable, windowOpenObservable, configuration) {\n    const { unsubscribe: unsubscribeAutoAction } = lifeCycle.subscribe(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, (action) => {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action));\n    });\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        if (eventType !== RumEventType.ERROR &&\n            eventType !== RumEventType.RESOURCE &&\n            eventType !== RumEventType.LONG_TASK) {\n            return SKIPPED;\n        }\n        const actionId = actionContexts.findActionId(startTime);\n        if (!actionId) {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            action: { id: actionId },\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, ({ startTime }) => ({\n        action: { id: actionContexts.findActionId(startTime) },\n    }));\n    let actionContexts = { findActionId: noop };\n    let stop = noop;\n    if (configuration.trackUserInteractions) {\n        ;\n        ({ actionContexts, stop } = trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration));\n    }\n    return {\n        addAction: (action) => {\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action));\n        },\n        actionContexts,\n        stop: () => {\n            unsubscribeAutoAction();\n            stop();\n        },\n    };\n}\nfunction processAction(action) {\n    const autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                id: action.id,\n                loading_time: discardNegativeDuration(toServerDuration(action.duration)),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\n                    name_source: action.nameSource,\n                },\n            },\n        }\n        : {\n            context: action.context,\n        };\n    const actionEvent = combine({\n        action: { id: generateUUID(), target: { name: action.name }, type: action.type },\n        date: action.startClocks.timeStamp,\n        type: RumEventType.ACTION,\n    }, autoActionProperties);\n    const duration = isAutoAction(action) ? action.duration : undefined;\n    const domainContext = isAutoAction(action)\n        ? { events: action.events }\n        : { handlingStack: action.handlingStack };\n    return {\n        rawRumEvent: actionEvent,\n        duration,\n        startTime: action.startClocks.relative,\n        domainContext,\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== ActionType.CUSTOM;\n}\n//# sourceMappingURL=actionCollection.js.map","import { isError, computeRawError } from '../error/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { ConsoleApiName, globalConsole } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { ErrorSource } from '../error/error.types';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { createHandlingStack, formatErrorMessage } from '../../tools/stackTrace/handlingStack';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nlet consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    const consoleObservables = apis.map((api) => {\n        if (!consoleObservablesByApi[api]) {\n            consoleObservablesByApi[api] = createConsoleObservable(api); // we are sure that the observable created for this api will yield the expected ConsoleLog type\n        }\n        return consoleObservablesByApi[api];\n    });\n    return mergeObservables(...consoleObservables);\n}\nexport function resetConsoleObservable() {\n    consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n    return new Observable((observable) => {\n        const originalConsoleApi = globalConsole[api];\n        globalConsole[api] = (...params) => {\n            originalConsoleApi.apply(console, params);\n            const handlingStack = createHandlingStack('console error');\n            callMonitored(() => {\n                observable.notify(buildConsoleLog(params, api, handlingStack));\n            });\n        };\n        return () => {\n            globalConsole[api] = originalConsoleApi;\n        };\n    });\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    const message = params.map((param) => formatConsoleParameters(param)).join(' ');\n    if (api === ConsoleApiName.error) {\n        const firstErrorParam = params.find(isError);\n        const rawError = computeRawError({\n            originalError: firstErrorParam,\n            handlingStack,\n            startClocks: clocksNow(),\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n            // if no good stack is computed from the error, let's not use the fallback stack message\n            // advising the user to use an instance of Error, as console.error is commonly used without an\n            // Error instance.\n            useFallbackStack: false,\n        });\n        // Use the full log message as the error message instead of just the error instance message.\n        rawError.message = message;\n        return {\n            api,\n            message,\n            handlingStack,\n            error: rawError,\n        };\n    }\n    return {\n        api,\n        message,\n        error: undefined,\n        handlingStack,\n    };\n}\nfunction formatConsoleParameters(param) {\n    if (typeof param === 'string') {\n        return sanitize(param);\n    }\n    if (isError(param)) {\n        return formatErrorMessage(computeStackTrace(param));\n    }\n    return jsonStringify(sanitize(param), undefined, 2);\n}\n//# sourceMappingURL=consoleObservable.js.map","import { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { addEventListener } from '../../browser/addEventListener';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nimport { ErrorSource } from '../error/error.types';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nexport const RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(configuration, apis) {\n    const observables = [];\n    if (apis.includes(RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable(configuration));\n    }\n    const reportTypes = apis.filter((api) => api !== RawReportType.cspViolation);\n    if (reportTypes.length) {\n        observables.push(createReportObservable(reportTypes));\n    }\n    return mergeObservables(...observables);\n}\nfunction createReportObservable(reportTypes) {\n    return new Observable((observable) => {\n        if (!window.ReportingObserver) {\n            return;\n        }\n        const handleReports = monitor((reports, _) => reports.forEach((report) => observable.notify(buildRawReportErrorFromReport(report))));\n        const observer = new window.ReportingObserver(handleReports, {\n            types: reportTypes,\n            buffered: true,\n        });\n        observer.observe();\n        return () => {\n            observer.disconnect();\n        };\n    });\n}\nfunction createCspViolationReportObservable(configuration) {\n    return new Observable((observable) => {\n        const { stop } = addEventListener(configuration, document, \"securitypolicyviolation\" /* DOM_EVENT.SECURITY_POLICY_VIOLATION */, (event) => {\n            observable.notify(buildRawReportErrorFromCspViolation(event));\n        });\n        return stop;\n    });\n}\nfunction buildRawReportErrorFromReport(report) {\n    const { type, body } = report;\n    return buildRawReportError({\n        type: body.id,\n        message: `${type}: ${body.message}`,\n        originalError: report,\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    });\n}\nfunction buildRawReportErrorFromCspViolation(event) {\n    const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`;\n    return buildRawReportError({\n        type: event.effectiveDirective,\n        message: `${RawReportType.cspViolation}: ${message}`,\n        originalError: event,\n        csp: {\n            disposition: event.disposition,\n        },\n        stack: buildStack(event.effectiveDirective, event.originalPolicy\n            ? `${message} of the policy \"${safeTruncate(event.originalPolicy, 100, '...')}\"`\n            : 'no policy', event.sourceFile, event.lineNumber, event.columnNumber),\n    });\n}\nfunction buildRawReportError(partial) {\n    return {\n        startClocks: clocksNow(),\n        source: ErrorSource.REPORT,\n        handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n        ...partial,\n    };\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n    return sourceFile\n        ? toStackTraceString({\n            name,\n            message,\n            stack: [\n                {\n                    func: '?',\n                    url: sourceFile,\n                    line: lineNumber !== null && lineNumber !== void 0 ? lineNumber : undefined,\n                    column: columnNumber !== null && columnNumber !== void 0 ? columnNumber : undefined,\n                },\n            ],\n        })\n        : undefined;\n}\n//# sourceMappingURL=reportObservable.js.map","import { Observable, ErrorSource, generateUUID, computeRawError, combine, } from '@datadog/browser-core';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, configuration, bufferedDataObservable) {\n    const errorObservable = new Observable();\n    bufferedDataObservable.subscribe((bufferedData) => {\n        if (bufferedData.type === 0 /* BufferedDataType.RUNTIME_ERROR */) {\n            errorObservable.notify(bufferedData.error);\n        }\n    });\n    trackConsoleError(errorObservable);\n    trackReportError(configuration, errorObservable);\n    errorObservable.subscribe((error) => lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error }));\n    return doStartErrorCollection(lifeCycle);\n}\nexport function doStartErrorCollection(lifeCycle) {\n    lifeCycle.subscribe(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, ({ error }) => {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processError(error));\n    });\n    return {\n        addError: ({ error, handlingStack, componentStack, startClocks, context }) => {\n            const rawError = computeRawError({\n                originalError: error,\n                handlingStack,\n                componentStack,\n                startClocks,\n                nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n                source: ErrorSource.CUSTOM,\n                handling: \"handled\" /* ErrorHandling.HANDLED */,\n            });\n            rawError.context = combine(rawError.context, context);\n            lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: rawError });\n        },\n    };\n}\nfunction processError(error) {\n    const rawRumEvent = {\n        date: error.startClocks.timeStamp,\n        error: {\n            id: generateUUID(),\n            message: error.message,\n            source: error.source,\n            stack: error.stack,\n            handling_stack: error.handlingStack,\n            component_stack: error.componentStack,\n            type: error.type,\n            handling: error.handling,\n            causes: error.causes,\n            source_type: 'browser',\n            fingerprint: error.fingerprint,\n            csp: error.csp,\n        },\n        type: RumEventType.ERROR,\n        context: error.context,\n    };\n    const domainContext = {\n        error: error.originalError,\n        handlingStack: error.handlingStack,\n    };\n    return {\n        rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext,\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { initConsoleObservable, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    const subscription = initConsoleObservable([ConsoleApiName.error]).subscribe((consoleLog) => errorObservable.notify(consoleLog.error));\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(configuration, errorObservable) {\n    const subscription = initReportObservable(configuration, [\n        RawReportType.cspViolation,\n        RawReportType.intervention,\n    ]).subscribe((rawError) => errorObservable.notify(rawError));\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { ONE_SECOND } from './utils/timeUtils';\nimport { requestIdleCallback } from './requestIdleCallback';\n/**\n * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long\n * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose\n * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt\n * performance.\n */\nconst IDLE_CALLBACK_TIMEOUT = ONE_SECOND;\n/**\n * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is\n * reached. We should not run tasks for too long as it will hurt performance, but we should still\n * run some tasks to avoid postponing them forever.\n *\n * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.\n */\nexport const MAX_EXECUTION_TIME_ON_TIMEOUT = 30;\nexport function createTaskQueue() {\n    const pendingTasks = [];\n    function run(deadline) {\n        let executionTimeRemaining;\n        if (deadline.didTimeout) {\n            const start = performance.now();\n            executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start);\n        }\n        else {\n            executionTimeRemaining = deadline.timeRemaining.bind(deadline);\n        }\n        while (executionTimeRemaining() > 0 && pendingTasks.length) {\n            pendingTasks.shift()();\n        }\n        if (pendingTasks.length) {\n            scheduleNextRun();\n        }\n    }\n    function scheduleNextRun() {\n        requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT });\n    }\n    return {\n        push(task) {\n            if (pendingTasks.push(task) === 1) {\n                scheduleNextRun();\n            }\n        },\n        stop() {\n            pendingTasks.length = 0;\n        },\n    };\n}\n//# sourceMappingURL=taskQueue.js.map","import { addDuration } from '@datadog/browser-core';\nimport { hasValidResourceEntryDuration, hasValidResourceEntryTimings } from './resourceUtils';\nconst alreadyMatchedEntries = new WeakSet();\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - filter out timing that were already matched to a request\n * - then, if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestResourceEntry(request) {\n    if (!performance || !('getEntriesByName' in performance)) {\n        return;\n    }\n    const sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    const candidates = sameNameEntries\n        .filter((entry) => !alreadyMatchedEntries.has(entry))\n        .filter((entry) => hasValidResourceEntryDuration(entry) && hasValidResourceEntryTimings(entry))\n        .filter((entry) => isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration })));\n    if (candidates.length === 1) {\n        alreadyMatchedEntries.add(candidates[0]);\n        return candidates[0].toJSON();\n    }\n    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    const errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestResourceEntry.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\nexport const INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    const data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);\n    if (!data || data.traceTime <= dateNow() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n        return undefined;\n    }\n    return data.traceId;\n}\nexport function getDocumentTraceDataFromMeta(document) {\n    const traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    const traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    const comment = findTraceComment(document);\n    if (!comment) {\n        return undefined;\n    }\n    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));\n}\nexport function createDocumentTraceData(traceId, rawTraceTime) {\n    const traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId,\n        traceTime,\n    };\n}\nexport function findTraceComment(document) {\n    // 1. Try to find the comment as a direct child of the document\n    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n    // value is not an array or string (here, a NodeList).\n    for (let i = 0; i < document.childNodes.length; i += 1) {\n        const comment = getTraceCommentFromNode(document.childNodes[i]);\n        if (comment) {\n            return comment;\n        }\n    }\n    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n    // reverse order, stopping if we come across a non-text node.\n    if (document.body) {\n        for (let i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            const node = document.body.childNodes[i];\n            const comment = getTraceCommentFromNode(node);\n            if (comment) {\n                return comment;\n            }\n            if (!isTextNode(node)) {\n                break;\n            }\n        }\n    }\n}\nfunction getTraceCommentFromNode(node) {\n    if (node && isCommentNode(node)) {\n        const match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { getRelativeTime, isNumber } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent } from './performanceObservable';\nexport function getNavigationEntry() {\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n        const navigationEntry = performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION)[0];\n        if (navigationEntry) {\n            return navigationEntry;\n        }\n    }\n    const timings = computeTimingsFromDeprecatedPerformanceTiming();\n    const entry = {\n        entryType: RumPerformanceEntryType.NAVIGATION,\n        initiatorType: 'navigation',\n        name: window.location.href,\n        startTime: 0,\n        duration: timings.loadEventEnd,\n        decodedBodySize: 0,\n        encodedBodySize: 0,\n        transferSize: 0,\n        workerStart: 0,\n        toJSON: () => ({ ...entry, toJSON: undefined }),\n        ...timings,\n    };\n    return entry;\n}\nexport function computeTimingsFromDeprecatedPerformanceTiming() {\n    const result = {};\n    const timing = performance.timing;\n    for (const key in timing) {\n        if (isNumber(timing[key])) {\n            const numberKey = key;\n            const timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=performanceUtils.js.map","import { runOnReadyState } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceObservable';\nimport { getDocumentTraceId } from '../tracing/getDocumentTraceId';\nimport { getNavigationEntry } from '../../browser/performanceUtils';\nimport { FAKE_INITIAL_DOCUMENT } from './resourceUtils';\nexport function retrieveInitialDocumentResourceTiming(configuration, callback, getNavigationEntryImpl = getNavigationEntry) {\n    runOnReadyState(configuration, 'interactive', () => {\n        const navigationEntry = getNavigationEntryImpl();\n        const entry = Object.assign(navigationEntry.toJSON(), {\n            entryType: RumPerformanceEntryType.RESOURCE,\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            // The ResourceTiming duration entry should be `responseEnd - startTime`. With\n            // NavigationTiming entries, `startTime` is always 0, so set it to `responseEnd`.\n            duration: navigationEntry.responseEnd,\n            traceId: getDocumentTraceId(document),\n            toJSON: () => ({ ...entry, toJSON: undefined }),\n        });\n        callback(entry);\n    });\n}\n//# sourceMappingURL=retrieveInitialDocumentResourceTiming.js.map","import { addTelemetryDebug } from '@datadog/browser-core';\n// Maximum number of requests to keep in the registry. Requests should be removed quite quickly in\n// general, this is just a safety limit to avoid memory leaks in case of a bug.\nexport const MAX_REQUESTS = 1000;\nexport function createRequestRegistry(lifeCycle) {\n    const requests = new Set();\n    const subscription = lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, (request) => {\n        requests.add(request);\n        if (requests.size > MAX_REQUESTS) {\n            // monitor-until: 2026-01-01, after early request collection GA\n            addTelemetryDebug('Too many requests');\n            requests.delete(requests.values().next().value);\n        }\n    });\n    return {\n        getMatchingRequest(entry) {\n            // Returns the closest request object that happened before the entry\n            let minTimeDifference = Infinity;\n            let closestRequest;\n            for (const request of requests) {\n                const timeDifference = entry.startTime - request.startClocks.relative;\n                if (0 <= timeDifference && timeDifference < minTimeDifference && request.url === entry.name) {\n                    minTimeDifference = Math.abs(timeDifference);\n                    closestRequest = request;\n                }\n            }\n            if (closestRequest) {\n                requests.delete(closestRequest);\n            }\n            return closestRequest;\n        },\n        stop() {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=requestRegistry.js.map","import { matchList, ONE_KIBI_BYTE, safeTruncate } from '@datadog/browser-core';\n/**\n * arbitrary value, byte precision not needed\n */\nconst GRAPHQL_PAYLOAD_LIMIT = 32 * ONE_KIBI_BYTE;\nexport function findGraphQlConfiguration(url, configuration) {\n    return configuration.allowedGraphQlUrls.find((graphQlOption) => matchList([graphQlOption.match], url));\n}\nexport function extractGraphQlMetadata(requestBody, trackPayload = false) {\n    if (!requestBody || typeof requestBody !== 'string') {\n        return;\n    }\n    let graphqlBody;\n    try {\n        graphqlBody = JSON.parse(requestBody);\n    }\n    catch (_a) {\n        // Not valid JSON\n        return;\n    }\n    if (!graphqlBody || !graphqlBody.query) {\n        return;\n    }\n    const query = graphqlBody.query.trim();\n    const operationType = getOperationType(query);\n    const operationName = graphqlBody.operationName;\n    if (!operationType) {\n        return;\n    }\n    let variables;\n    if (graphqlBody.variables) {\n        variables = JSON.stringify(graphqlBody.variables);\n    }\n    return {\n        operationType,\n        operationName,\n        variables,\n        payload: trackPayload ? safeTruncate(query, GRAPHQL_PAYLOAD_LIMIT, '...') : undefined,\n    };\n}\nfunction getOperationType(query) {\n    var _a;\n    return (_a = query.match(/^\\s*(query|mutation|subscription)\\b/i)) === null || _a === void 0 ? void 0 : _a[1];\n}\n//# sourceMappingURL=graphql.js.map","import { combine, generateUUID, RequestType, ResourceType, toServerDuration, relativeToClocks, createTaskQueue, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, createPerformanceObservable } from '../../browser/performanceObservable';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { createSpanIdentifier } from '../tracing/identifier';\nimport { matchRequestResourceEntry } from './matchRequestResourceEntry';\nimport { computeResourceEntryDetails, computeResourceEntryDuration, computeResourceEntryType, computeResourceEntrySize, computeResourceEntryProtocol, computeResourceEntryDeliveryType, isResourceEntryRequestType, sanitizeIfLongDataUrl, } from './resourceUtils';\nimport { retrieveInitialDocumentResourceTiming } from './retrieveInitialDocumentResourceTiming';\nimport { createRequestRegistry } from './requestRegistry';\nimport { findGraphQlConfiguration, extractGraphQlMetadata } from './graphql';\nexport function startResourceCollection(lifeCycle, configuration, pageStateHistory, taskQueue = createTaskQueue(), retrieveInitialDocumentResourceTimingImpl = retrieveInitialDocumentResourceTiming) {\n    let requestRegistry;\n    const isEarlyRequestCollectionEnabled = configuration.trackEarlyRequests;\n    if (isEarlyRequestCollectionEnabled) {\n        requestRegistry = createRequestRegistry(lifeCycle);\n    }\n    else {\n        lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, (request) => {\n            handleResource(() => processRequest(request, configuration, pageStateHistory));\n        });\n    }\n    const performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.RESOURCE,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            if (isEarlyRequestCollectionEnabled || !isResourceEntryRequestType(entry)) {\n                handleResource(() => processResourceEntry(entry, configuration, pageStateHistory, requestRegistry));\n            }\n        }\n    });\n    retrieveInitialDocumentResourceTimingImpl(configuration, (timing) => {\n        handleResource(() => processResourceEntry(timing, configuration, pageStateHistory, requestRegistry));\n    });\n    function handleResource(computeRawEvent) {\n        taskQueue.push(() => {\n            const rawEvent = computeRawEvent();\n            if (rawEvent) {\n                lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, rawEvent);\n            }\n        });\n    }\n    return {\n        stop: () => {\n            taskQueue.stop();\n            performanceResourceSubscription.unsubscribe();\n        },\n    };\n}\nfunction processRequest(request, configuration, pageStateHistory) {\n    const matchingTiming = matchRequestResourceEntry(request);\n    return assembleResource(matchingTiming, request, pageStateHistory, configuration);\n}\nfunction processResourceEntry(entry, configuration, pageStateHistory, requestRegistry) {\n    const matchingRequest = isResourceEntryRequestType(entry) && requestRegistry ? requestRegistry.getMatchingRequest(entry) : undefined;\n    return assembleResource(entry, matchingRequest, pageStateHistory, configuration);\n}\n// TODO: In the future, the `entry` parameter should be required, making things simpler.\nfunction assembleResource(entry, request, pageStateHistory, configuration) {\n    if (!entry && !request) {\n        return;\n    }\n    const tracingInfo = request\n        ? computeRequestTracingInfo(request, configuration)\n        : computeResourceEntryTracingInfo(entry, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    const startClocks = entry ? relativeToClocks(entry.startTime) : request.startClocks;\n    const duration = entry\n        ? computeResourceEntryDuration(entry)\n        : computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    const graphql = request && computeGraphQlMetaData(request, configuration);\n    const resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            duration: toServerDuration(duration),\n            // TODO: in the future when `entry` is required, we can probably only rely on `computeResourceEntryType`\n            type: request\n                ? request.type === RequestType.XHR\n                    ? ResourceType.XHR\n                    : ResourceType.FETCH\n                : computeResourceEntryType(entry),\n            method: request ? request.method : undefined,\n            status_code: request ? request.status : discardZeroStatus(entry.responseStatus),\n            url: request ? sanitizeIfLongDataUrl(request.url) : entry.name,\n            protocol: entry && computeResourceEntryProtocol(entry),\n            delivery_type: entry && computeResourceEntryDeliveryType(entry),\n            graphql,\n        },\n        type: RumEventType.RESOURCE,\n        _dd: {\n            discarded: !configuration.trackResources,\n        },\n    }, tracingInfo, entry && computeResourceEntryMetrics(entry));\n    return {\n        startTime: startClocks.relative,\n        duration,\n        rawRumEvent: resourceEvent,\n        domainContext: getResourceDomainContext(entry, request),\n    };\n}\nfunction computeGraphQlMetaData(request, configuration) {\n    const graphQlConfig = findGraphQlConfiguration(request.url, configuration);\n    if (!graphQlConfig) {\n        return;\n    }\n    return extractGraphQlMetadata(request.body, graphQlConfig.trackPayload);\n}\nfunction getResourceDomainContext(entry, request) {\n    if (request) {\n        const baseDomainContext = {\n            performanceEntry: entry,\n            isAborted: request.isAborted,\n            handlingStack: request.handlingStack,\n        };\n        if (request.type === RequestType.XHR) {\n            return {\n                xhr: request.xhr,\n                ...baseDomainContext,\n            };\n        }\n        return {\n            requestInput: request.input,\n            requestInit: request.init,\n            response: request.response,\n            error: request.error,\n            ...baseDomainContext,\n        };\n    }\n    return {\n        // Currently, at least one of `entry` or `request` must be defined when calling this function.\n        // So `entry` is guaranteed to be defined here. In the future, when `entry` is required, we can\n        // remove the `!` assertion.\n        performanceEntry: entry,\n    };\n}\nfunction computeResourceEntryMetrics(entry) {\n    const { renderBlockingStatus } = entry;\n    return {\n        resource: {\n            render_blocking_status: renderBlockingStatus,\n            ...computeResourceEntrySize(entry),\n            ...computeResourceEntryDetails(entry),\n        },\n    };\n}\nfunction computeRequestTracingInfo(request, configuration) {\n    const hasBeenTraced = request.traceSampled && request.traceId && request.spanId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            span_id: request.spanId.toString(),\n            trace_id: request.traceId.toString(),\n            rule_psr: configuration.rulePsr,\n        },\n    };\n}\nfunction computeResourceEntryTracingInfo(entry, configuration) {\n    const hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            span_id: createSpanIdentifier().toString(),\n            rule_psr: configuration.rulePsr,\n        },\n    };\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, startClocks.relative, duration)\n        ? duration\n        : undefined;\n}\n/**\n * The status is 0 for cross-origin resources without CORS headers, so the status is meaningless, and we shouldn't report it\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus#cross-origin_response_status_codes\n */\nfunction discardZeroStatus(statusCode) {\n    return statusCode === 0 ? undefined : statusCode;\n}\n//# sourceMappingURL=resourceCollection.js.map","export function getTimeZone() {\n    try {\n        const intl = new Intl.DateTimeFormat();\n        return intl.resolvedOptions().timeZone;\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\n//# sourceMappingURL=timezone.js.map","import { ONE_MINUTE, elapsed, relativeNow } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable';\n// Discard FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackFirstContentfulPaint(configuration, firstHidden, callback) {\n    const performanceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.PAINT,\n        buffered: true,\n    }).subscribe((entries) => {\n        const fcpEntry = entries.find((entry) => entry.name === 'first-contentful-paint' &&\n            entry.startTime < firstHidden.timeStamp &&\n            entry.startTime < FCP_MAXIMUM_DELAY);\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    });\n    return {\n        stop: performanceSubscription.unsubscribe,\n    };\n}\n/**\n * Measure the First Contentful Paint after a BFCache restoration.\n * The DOM is restored synchronously, so we approximate the FCP with the first frame\n * rendered just after the pageshow event, using two nested requestAnimationFrame calls.\n */\nexport function trackRestoredFirstContentfulPaint(viewStartRelative, callback) {\n    requestAnimationFrame(() => {\n        requestAnimationFrame(() => {\n            callback(elapsed(viewStartRelative, relativeNow()));\n        });\n    });\n}\n//# sourceMappingURL=trackFirstContentfulPaint.js.map","import { setTimeout, relativeNow, runOnReadyState, clearTimeout } from '@datadog/browser-core';\nimport { getNavigationEntry } from '../../../browser/performanceUtils';\nexport function trackNavigationTimings(configuration, callback, getNavigationEntryImpl = getNavigationEntry) {\n    return waitAfterLoadEvent(configuration, () => {\n        const entry = getNavigationEntryImpl();\n        if (!isIncompleteNavigation(entry)) {\n            callback(processNavigationEntry(entry));\n        }\n    });\n}\nfunction processNavigationEntry(entry) {\n    return {\n        domComplete: entry.domComplete,\n        domContentLoaded: entry.domContentLoadedEventEnd,\n        domInteractive: entry.domInteractive,\n        loadEvent: entry.loadEventEnd,\n        // In some cases the value reported is negative or is larger\n        // 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        firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\n    };\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.loadEventEnd <= 0;\n}\nfunction waitAfterLoadEvent(configuration, callback) {\n    let timeoutId;\n    const { stop: stopOnReadyState } = runOnReadyState(configuration, 'complete', () => {\n        // Invoke the callback a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        timeoutId = setTimeout(() => callback());\n    });\n    return {\n        stop: () => {\n            stopOnReadyState();\n            clearTimeout(timeoutId);\n        },\n    };\n}\n//# sourceMappingURL=trackNavigationTimings.js.map","import { ONE_MINUTE, addEventListeners, findLast } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts\n */\nexport function trackLargestContentfulPaint(configuration, firstHidden, eventTarget, callback) {\n    // Ignore entries that come after the first user interaction. According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    let firstInteractionTimestamp = Infinity;\n    const { stop: stopEventListener } = addEventListeners(configuration, eventTarget, [\"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */], (event) => {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true });\n    let biggestLcpSize = 0;\n    const performanceLcpSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n        buffered: true,\n    }).subscribe((entries) => {\n        const lcpEntry = findLast(entries, (entry) => entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n            entry.startTime < firstInteractionTimestamp &&\n            entry.startTime < firstHidden.timeStamp &&\n            entry.startTime < LCP_MAXIMUM_DELAY &&\n            // Ensure to get the LCP entry with the biggest size, see\n            // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655\n            entry.size > biggestLcpSize);\n        if (lcpEntry) {\n            let lcpTargetSelector;\n            if (lcpEntry.element) {\n                lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);\n            }\n            callback({\n                value: lcpEntry.startTime,\n                targetSelector: lcpTargetSelector,\n                resourceUrl: computeLcpEntryUrl(lcpEntry),\n            });\n            biggestLcpSize = lcpEntry.size;\n        }\n    });\n    return {\n        stop: () => {\n            stopEventListener();\n            performanceLcpSubscription.unsubscribe();\n        },\n    };\n}\n// The property url report an empty string if the value is not available, we shouldn't report it in this case.\nfunction computeLcpEntryUrl(entry) {\n    return entry.url === '' ? undefined : entry.url;\n}\n//# sourceMappingURL=trackLargestContentfulPaint.js.map","import { addEventListeners, noop } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../../browser/performanceObservable';\nexport function trackFirstHidden(configuration, viewStart, eventTarget = window) {\n    if (document.visibilityState === 'hidden') {\n        return { timeStamp: 0, stop: noop };\n    }\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.VISIBILITY_STATE)) {\n        const firstHiddenEntry = performance\n            .getEntriesByType(RumPerformanceEntryType.VISIBILITY_STATE)\n            .filter((entry) => entry.name === 'hidden')\n            .find((entry) => entry.startTime >= viewStart.relative);\n        if (firstHiddenEntry) {\n            return { timeStamp: firstHiddenEntry.startTime, stop: noop };\n        }\n    }\n    let timeStamp = Infinity;\n    const { stop } = addEventListeners(configuration, eventTarget, [\"pagehide\" /* DOM_EVENT.PAGE_HIDE */, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */], (event) => {\n        if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ || document.visibilityState === 'hidden') {\n            timeStamp = event.timeStamp;\n            stop();\n        }\n    }, { capture: true });\n    return {\n        get timeStamp() {\n            return timeStamp;\n        },\n        stop,\n    };\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { trackFirstContentfulPaint } from './trackFirstContentfulPaint';\nimport { trackFirstInput } from './trackFirstInput';\nimport { trackNavigationTimings } from './trackNavigationTimings';\nimport { trackLargestContentfulPaint } from './trackLargestContentfulPaint';\nimport { trackFirstHidden } from './trackFirstHidden';\nexport function trackInitialViewMetrics(configuration, viewStart, setLoadEvent, scheduleViewUpdate) {\n    const initialViewMetrics = {};\n    const { stop: stopNavigationTracking } = trackNavigationTimings(configuration, (navigationTimings) => {\n        setLoadEvent(navigationTimings.loadEvent);\n        initialViewMetrics.navigationTimings = navigationTimings;\n        scheduleViewUpdate();\n    });\n    const firstHidden = trackFirstHidden(configuration, viewStart);\n    const { stop: stopFCPTracking } = trackFirstContentfulPaint(configuration, firstHidden, (firstContentfulPaint) => {\n        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;\n        scheduleViewUpdate();\n    });\n    const { stop: stopLCPTracking } = trackLargestContentfulPaint(configuration, firstHidden, window, (largestContentfulPaint) => {\n        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;\n        scheduleViewUpdate();\n    });\n    const { stop: stopFIDTracking } = trackFirstInput(configuration, firstHidden, (firstInput) => {\n        initialViewMetrics.firstInput = firstInput;\n        scheduleViewUpdate();\n    });\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n        firstHidden.stop();\n    }\n    return {\n        stop,\n        initialViewMetrics,\n    };\n}\n//# sourceMappingURL=trackInitialViewMetrics.js.map","import { elapsed } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInput(configuration, firstHidden, callback) {\n    const performanceFirstInputSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.FIRST_INPUT,\n        buffered: true,\n    }).subscribe((entries) => {\n        const firstInputEntry = entries.find((entry) => entry.startTime < firstHidden.timeStamp);\n        if (firstInputEntry) {\n            const firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            let firstInputTargetSelector;\n            if (firstInputEntry.target && isElementNode(firstInputEntry.target)) {\n                firstInputTargetSelector = getSelectorFromElement(firstInputEntry.target, configuration.actionNameAttribute);\n            }\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                delay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                time: firstInputEntry.startTime,\n                targetSelector: firstInputTargetSelector,\n            });\n        }\n    });\n    return {\n        stop: () => {\n            performanceFirstInputSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFirstInput.js.map","/**\n * Calculates the area of a rectangle given its width and height\n */\nconst calculateArea = (width, height) => width * height;\n/**\n * Calculates the intersection area between two rectangles\n */\nconst calculateIntersectionArea = (rect1, rect2) => {\n    const left = Math.max(rect1.left, rect2.left);\n    const top = Math.max(rect1.top, rect2.top);\n    const right = Math.min(rect1.right, rect2.right);\n    const bottom = Math.min(rect1.bottom, rect2.bottom);\n    if (left >= right || top >= bottom) {\n        return 0;\n    }\n    return calculateArea(right - left, bottom - top);\n};\n/**\n * Calculates the total impacted area of a layout shift source\n * This is the sum of the previous and current areas minus their intersection\n */\nexport const getClsAttributionImpactedArea = (source) => {\n    const previousArea = calculateArea(source.previousRect.width, source.previousRect.height);\n    const currentArea = calculateArea(source.currentRect.width, source.currentRect.height);\n    const intersectionArea = calculateIntersectionArea(source.previousRect, source.currentRect);\n    return previousArea + currentArea - intersectionArea;\n};\n//# sourceMappingURL=getClsAttributionImpactedArea.js.map","import { round, ONE_SECOND, noop, elapsed } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType, createPerformanceObservable, } from '../../../browser/performanceObservable';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\nimport { getClsAttributionImpactedArea } from './getClsAttributionImpactedArea';\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nexport function trackCumulativeLayoutShift(configuration, viewStart, callback) {\n    if (!isLayoutShiftSupported()) {\n        return {\n            stop: noop,\n        };\n    }\n    let maxClsValue = 0;\n    let biggestShift;\n    // if no layout shift happen the value should be reported as 0\n    callback({\n        value: 0,\n    });\n    const slidingWindow = slidingSessionWindow();\n    const performanceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LAYOUT_SHIFT,\n        buffered: true,\n    }).subscribe((entries) => {\n        var _a;\n        for (const entry of entries) {\n            if (entry.hadRecentInput || entry.startTime < viewStart) {\n                continue;\n            }\n            const { cumulatedValue, isMaxValue } = slidingWindow.update(entry);\n            if (isMaxValue) {\n                const attribution = getTopImpactedElement(entry.sources);\n                biggestShift = {\n                    target: (attribution === null || attribution === void 0 ? void 0 : attribution.node) ? new WeakRef(attribution.node) : undefined,\n                    time: elapsed(viewStart, entry.startTime),\n                    previousRect: attribution === null || attribution === void 0 ? void 0 : attribution.previousRect,\n                    currentRect: attribution === null || attribution === void 0 ? void 0 : attribution.currentRect,\n                    devicePixelRatio: window.devicePixelRatio,\n                };\n            }\n            if (cumulatedValue > maxClsValue) {\n                maxClsValue = cumulatedValue;\n                const target = (_a = biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.target) === null || _a === void 0 ? void 0 : _a.deref();\n                callback({\n                    value: round(maxClsValue, 4),\n                    targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),\n                    time: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.time,\n                    previousRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.previousRect) ? asRumRect(biggestShift.previousRect) : undefined,\n                    currentRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.currentRect) ? asRumRect(biggestShift.currentRect) : undefined,\n                    devicePixelRatio: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.devicePixelRatio,\n                });\n            }\n        }\n    });\n    return {\n        stop: () => {\n            performanceSubscription.unsubscribe();\n        },\n    };\n}\nfunction getTopImpactedElement(sources) {\n    let topImpactedSource;\n    for (const source of sources) {\n        if (source.node && isElementNode(source.node)) {\n            const currentImpactedArea = getClsAttributionImpactedArea(source);\n            if (!topImpactedSource || getClsAttributionImpactedArea(topImpactedSource) < currentImpactedArea) {\n                topImpactedSource = source;\n            }\n        }\n    }\n    return topImpactedSource;\n}\nfunction asRumRect({ x, y, width, height }) {\n    return { x, y, width, height };\n}\nexport const MAX_WINDOW_DURATION = 5 * ONE_SECOND;\nconst MAX_UPDATE_GAP = ONE_SECOND;\nfunction slidingSessionWindow() {\n    let cumulatedValue = 0;\n    let startTime;\n    let endTime;\n    let maxValue = 0;\n    return {\n        update: (entry) => {\n            const shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= MAX_UPDATE_GAP ||\n                entry.startTime - startTime >= MAX_WINDOW_DURATION;\n            let isMaxValue;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                maxValue = cumulatedValue = entry.value;\n                isMaxValue = true;\n            }\n            else {\n                cumulatedValue += entry.value;\n                endTime = entry.startTime;\n                isMaxValue = entry.value > maxValue;\n                if (isMaxValue) {\n                    maxValue = entry.value;\n                }\n            }\n            return {\n                cumulatedValue,\n                isMaxValue,\n            };\n        },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window;\n}\n//# sourceMappingURL=trackCumulativeLayoutShift.js.map","/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\nimport { monitor } from '@datadog/browser-core';\nlet observer;\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\nexport function initInteractionCountPolyfill() {\n    if ('interactionCount' in performance || observer) {\n        return;\n    }\n    observer = new window.PerformanceObserver(monitor((entries) => {\n        entries.getEntries().forEach((e) => {\n            const entry = e;\n            if (entry.interactionId) {\n                minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);\n                maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);\n                interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;\n            }\n        });\n    }));\n    observer.observe({ type: 'event', buffered: true, durationThreshold: 0 });\n}\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport const getInteractionCount = () => observer ? interactionCountEstimate : window.performance.interactionCount || 0;\n//# sourceMappingURL=interactionCountPolyfill.js.map","import { elapsed, noop, ONE_MINUTE } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType, supportPerformanceTimingEvent, } from '../../../browser/performanceObservable';\nimport { ViewLoadingType } from '../../../rawRumEvent.types';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { getInteractionSelector } from '../../action/interactionSelectorCache';\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill';\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nconst MAX_INTERACTION_ENTRIES = 10;\n// Arbitrary value to cap INP outliers\nexport const MAX_INP_VALUE = (1 * ONE_MINUTE);\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(configuration, viewStart, viewLoadingType) {\n    if (!isInteractionToNextPaintSupported()) {\n        return {\n            getInteractionToNextPaint: () => undefined,\n            setViewEnd: noop,\n            stop: noop,\n        };\n    }\n    const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);\n    let viewEnd = Infinity;\n    const longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    let interactionToNextPaint = -1;\n    let interactionToNextPaintTargetSelector;\n    let interactionToNextPaintStartTime;\n    function handleEntries(entries) {\n        for (const entry of entries) {\n            if (entry.interactionId &&\n                // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).\n                entry.startTime >= viewStart &&\n                entry.startTime <= viewEnd) {\n                longestInteractions.process(entry);\n            }\n        }\n        const newInteraction = longestInteractions.estimateP98Interaction();\n        if (newInteraction && newInteraction.duration !== interactionToNextPaint) {\n            interactionToNextPaint = newInteraction.duration;\n            interactionToNextPaintStartTime = elapsed(viewStart, newInteraction.startTime);\n            interactionToNextPaintTargetSelector = getInteractionSelector(newInteraction.startTime);\n            if (!interactionToNextPaintTargetSelector && newInteraction.target && isElementNode(newInteraction.target)) {\n                interactionToNextPaintTargetSelector = getSelectorFromElement(newInteraction.target, configuration.actionNameAttribute);\n            }\n        }\n    }\n    const firstInputSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.FIRST_INPUT,\n        buffered: true,\n    }).subscribe(handleEntries);\n    const eventSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.EVENT,\n        // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n        // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L202-L210\n        durationThreshold: 40,\n        buffered: true,\n    }).subscribe(handleEntries);\n    return {\n        getInteractionToNextPaint: () => {\n            // If no INP duration where captured because of the performanceObserver 40ms threshold\n            // but the view interaction count > 0 then report 0\n            if (interactionToNextPaint >= 0) {\n                return {\n                    value: Math.min(interactionToNextPaint, MAX_INP_VALUE),\n                    targetSelector: interactionToNextPaintTargetSelector,\n                    time: interactionToNextPaintStartTime,\n                };\n            }\n            else if (getViewInteractionCount()) {\n                return {\n                    value: 0,\n                };\n            }\n        },\n        setViewEnd: (viewEndTime) => {\n            viewEnd = viewEndTime;\n            stopViewInteractionCount();\n        },\n        stop: () => {\n            eventSubscription.unsubscribe();\n            firstInputSubscription.unsubscribe();\n        },\n    };\n}\nfunction trackLongestInteractions(getViewInteractionCount) {\n    const longestInteractions = [];\n    function sortAndTrimLongestInteractions() {\n        longestInteractions.sort((a, b) => b.duration - a.duration).splice(MAX_INTERACTION_ENTRIES);\n    }\n    return {\n        /**\n         * Process the performance entry:\n         * - if its duration is long enough, add the performance entry to the list of worst interactions\n         * - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions\n         */\n        process(entry) {\n            const interactionIndex = longestInteractions.findIndex((interaction) => entry.interactionId === interaction.interactionId);\n            const minLongestInteraction = longestInteractions[longestInteractions.length - 1];\n            if (interactionIndex !== -1) {\n                if (entry.duration > longestInteractions[interactionIndex].duration) {\n                    longestInteractions[interactionIndex] = entry;\n                    sortAndTrimLongestInteractions();\n                }\n            }\n            else if (longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n                entry.duration > minLongestInteraction.duration) {\n                longestInteractions.push(entry);\n                sortAndTrimLongestInteractions();\n            }\n        },\n        /**\n         * Compute the p98 longest interaction.\n         * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n         */\n        estimateP98Interaction() {\n            const interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));\n            return longestInteractions[interactionIndex];\n        },\n    };\n}\nexport function trackViewInteractionCount(viewLoadingType) {\n    initInteractionCountPolyfill();\n    const previousInteractionCount = viewLoadingType === ViewLoadingType.INITIAL_LOAD ? 0 : getInteractionCount();\n    let state = { stopped: false };\n    function computeViewInteractionCount() {\n        return getInteractionCount() - previousInteractionCount;\n    }\n    return {\n        getViewInteractionCount: () => {\n            if (state.stopped) {\n                return state.interactionCount;\n            }\n            return computeViewInteractionCount();\n        },\n        stopViewInteractionCount: () => {\n            state = { stopped: true, interactionCount: computeViewInteractionCount() };\n        },\n    };\n}\nexport function isInteractionToNextPaintSupported() {\n    return (supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n        window.PerformanceEventTiming &&\n        'interactionId' in PerformanceEventTiming.prototype);\n}\n//# sourceMappingURL=trackInteractionToNextPaint.js.map","export function getScrollX() {\n    let scrollX;\n    const visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    let scrollY;\n    const visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=scroll.js.map","import { Observable, throttle, addEventListener } from '@datadog/browser-core';\nlet viewportObservable;\nexport function initViewportObservable(configuration) {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable(configuration);\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable(configuration) {\n    return new Observable((observable) => {\n        const { throttled: updateDimension } = throttle(() => {\n            observable.notify(getViewportDimension());\n        }, 200);\n        return addEventListener(configuration, window, \"resize\" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true })\n            .stop;\n    });\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    const visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { Observable, ONE_SECOND, elapsed, relativeNow, throttle, addEventListener, monitor, } from '@datadog/browser-core';\nimport { getScrollY } from '../../../browser/scroll';\nimport { getViewportDimension } from '../../../browser/viewportObservable';\n/** Arbitrary scroll throttle duration */\nexport const THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackScrollMetrics(configuration, viewStart, callback, scrollValues = createScrollValuesObservable(configuration)) {\n    let maxScrollDepth = 0;\n    let maxScrollHeight = 0;\n    let maxScrollHeightTime = 0;\n    const subscription = scrollValues.subscribe(({ scrollDepth, scrollTop, scrollHeight }) => {\n        let shouldUpdate = false;\n        if (scrollDepth > maxScrollDepth) {\n            maxScrollDepth = scrollDepth;\n            shouldUpdate = true;\n        }\n        if (scrollHeight > maxScrollHeight) {\n            maxScrollHeight = scrollHeight;\n            const now = relativeNow();\n            maxScrollHeightTime = elapsed(viewStart.relative, now);\n            shouldUpdate = true;\n        }\n        if (shouldUpdate) {\n            callback({\n                maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n                maxDepthScrollTop: scrollTop,\n                maxScrollHeight,\n                maxScrollHeightTime,\n            });\n        }\n    });\n    return {\n        stop: () => subscription.unsubscribe(),\n    };\n}\nexport function computeScrollValues() {\n    const scrollTop = getScrollY();\n    const { height } = getViewportDimension();\n    const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);\n    const scrollDepth = Math.round(height + scrollTop);\n    return {\n        scrollHeight,\n        scrollDepth,\n        scrollTop,\n    };\n}\nexport function createScrollValuesObservable(configuration, throttleDuration = THROTTLE_SCROLL_DURATION) {\n    return new Observable((observable) => {\n        function notify() {\n            observable.notify(computeScrollValues());\n        }\n        if (window.ResizeObserver) {\n            const throttledNotify = throttle(notify, throttleDuration, {\n                leading: false,\n                trailing: true,\n            });\n            const observerTarget = document.scrollingElement || document.documentElement;\n            const resizeObserver = new ResizeObserver(monitor(throttledNotify.throttled));\n            if (observerTarget) {\n                resizeObserver.observe(observerTarget);\n            }\n            const eventListener = addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, throttledNotify.throttled, {\n                passive: true,\n            });\n            return () => {\n                throttledNotify.cancel();\n                resizeObserver.disconnect();\n                eventListener.stop();\n            };\n        }\n    });\n}\n//# sourceMappingURL=trackScrollMetrics.js.map","import { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift';\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint';\nimport { trackLoadingTime } from './trackLoadingTime';\nimport { trackScrollMetrics } from './trackScrollMetrics';\nexport function trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    const commonViewMetrics = {};\n    const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {\n        commonViewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    });\n    const { stop: stopScrollMetricsTracking } = trackScrollMetrics(configuration, viewStart, (newScrollMetrics) => {\n        commonViewMetrics.scroll = newScrollMetrics;\n    });\n    const { stop: stopCLSTracking } = trackCumulativeLayoutShift(configuration, viewStart.relative, (cumulativeLayoutShift) => {\n        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n        scheduleViewUpdate();\n    });\n    const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd, } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType);\n    return {\n        stop: () => {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        stopINPTracking,\n        setLoadEvent,\n        setViewEnd,\n        getCommonViewMetrics: () => {\n            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();\n            return commonViewMetrics;\n        },\n    };\n}\n//# sourceMappingURL=trackCommonViewMetrics.js.map","import { elapsed } from '@datadog/browser-core';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { ViewLoadingType } from '../../../rawRumEvent.types';\nimport { trackFirstHidden } from './trackFirstHidden';\n/**\n * For non-initial views (such as route changes or BFCache restores), the regular load event does not fire\n * In these cases, trackLoadingTime can only emit a loadingTime  if waitPageActivityEnd detects some post-restore activity.\n * If nothing happens after the view starts,no candidate is recorded and loadingTime stays undefined.\n */\nexport function trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadType, viewStart, callback) {\n    let isWaitingForLoadEvent = loadType === ViewLoadingType.INITIAL_LOAD;\n    let isWaitingForActivityLoadingTime = true;\n    const loadingTimeCandidates = [];\n    const firstHidden = trackFirstHidden(configuration, viewStart);\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            const loadingTime = Math.max(...loadingTimeCandidates);\n            // firstHidden is a relative time from time origin, so we use the relative start time of the view to compare with the loading time\n            if (loadingTime < firstHidden.timeStamp - viewStart.relative) {\n                callback(loadingTime);\n            }\n        }\n    }\n    const { stop } = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (event) => {\n        if (isWaitingForActivityLoadingTime) {\n            isWaitingForActivityLoadingTime = false;\n            if (event.hadActivity) {\n                loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));\n            }\n            invokeCallbackIfAllCandidatesAreReceived();\n        }\n    });\n    return {\n        stop: () => {\n            stop();\n            firstHidden.stop();\n        },\n        setLoadEvent: (loadEvent) => {\n            if (isWaitingForLoadEvent) {\n                isWaitingForLoadEvent = false;\n                loadingTimeCandidates.push(loadEvent);\n                invokeCallbackIfAllCandidatesAreReceived();\n            }\n        },\n    };\n}\n//# sourceMappingURL=trackLoadingTime.js.map","import { trackRestoredFirstContentfulPaint } from './trackFirstContentfulPaint';\n/**\n * BFCache keeps a full in-memory snapshot of the DOM. When the page is restored, nothing needs to be fetched, so the whole\n * viewport repaints in a single frame. Consequently, LCP almost always equals FCP.\n * (See: https://github.com/GoogleChrome/web-vitals/pull/87)\n */\nexport function trackBfcacheMetrics(viewStart, metrics, scheduleViewUpdate) {\n    trackRestoredFirstContentfulPaint(viewStart.relative, (paintTime) => {\n        metrics.firstContentfulPaint = paintTime;\n        metrics.largestContentfulPaint = { value: paintTime };\n        scheduleViewUpdate();\n    });\n}\n//# sourceMappingURL=trackBfcacheMetrics.js.map","import { noop, PageExitReason, shallowClone, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, relativeToClocks, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, setTimeout, Observable, createContextManager, } from '@datadog/browser-core';\nimport { ViewLoadingType } from '../../rawRumEvent.types';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nimport { trackInitialViewMetrics } from './viewMetrics/trackInitialViewMetrics';\nimport { trackCommonViewMetrics } from './viewMetrics/trackCommonViewMetrics';\nimport { onBFCacheRestore } from './bfCacheSupport';\nimport { trackBfcacheMetrics } from './viewMetrics/trackBfcacheMetrics';\nexport const THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport const SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\n// Some events or metrics can be captured after the end of the view. To avoid missing those;\n// an arbitrary delay is added for stopping their tracking after the view ends.\n//\n// Ideally, we would not stop and keep tracking events or metrics until the end of the session.\n// But this might have a small performance impact if there are many many views.\n// So let's have a fairly short delay improving the situation in most cases and avoid impacting performances too much.\nexport const KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, windowOpenObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    const activeViews = new Set();\n    let currentView = startNewView(ViewLoadingType.INITIAL_LOAD, clocksOrigin(), initialViewOptions);\n    let stopOnBFCacheRestore;\n    startViewLifeCycle();\n    let locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n        if (configuration.trackBfcacheViews) {\n            stopOnBFCacheRestore = onBFCacheRestore(configuration, (pageshowEvent) => {\n                currentView.end();\n                const startClocks = relativeToClocks(pageshowEvent.timeStamp);\n                currentView = startNewView(ViewLoadingType.BF_CACHE, startClocks, undefined);\n            });\n        }\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        const newlyCreatedView = newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, location, loadingType, startClocks, viewOptions);\n        activeViews.add(newlyCreatedView);\n        newlyCreatedView.stopObservable.subscribe(() => {\n            activeViews.delete(newlyCreatedView);\n        });\n        return newlyCreatedView;\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n            // Renew view on session renewal\n            currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, undefined, {\n                name: currentView.name,\n                service: currentView.service,\n                version: currentView.version,\n                context: currentView.contextManager.getContext(),\n            });\n        });\n        lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_EXPIRED */, () => {\n            currentView.end({ sessionIsActive: false });\n        });\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(({ oldLocation, newLocation }) => {\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView = startNewView(ViewLoadingType.ROUTE_CHANGE);\n            }\n        });\n    }\n    return {\n        addTiming: (name, time = timeStampNow()) => {\n            currentView.addTiming(name, time);\n        },\n        startView: (options, startClocks) => {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, startClocks, options);\n        },\n        setViewContext: (context) => {\n            currentView.contextManager.setContext(context);\n        },\n        setViewContextProperty: (key, value) => {\n            currentView.contextManager.setContextProperty(key, value);\n        },\n        setViewName: (name) => {\n            currentView.setViewName(name);\n        },\n        getViewContext: () => currentView.contextManager.getContext(),\n        stop: () => {\n            if (locationChangeSubscription) {\n                locationChangeSubscription.unsubscribe();\n            }\n            if (stopOnBFCacheRestore) {\n                stopOnBFCacheRestore();\n            }\n            currentView.end();\n            activeViews.forEach((view) => view.stop());\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, initialLocation, loadingType, startClocks = clocksNow(), viewOptions) {\n    // Setup initial values\n    const id = generateUUID();\n    const stopObservable = new Observable();\n    const customTimings = {};\n    let documentVersion = 0;\n    let endClocks;\n    const location = shallowClone(initialLocation);\n    const contextManager = createContextManager();\n    let sessionIsActive = true;\n    let name = viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.name;\n    const service = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.service) || configuration.service;\n    const version = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.version) || configuration.version;\n    const context = viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.context;\n    if (context) {\n        contextManager.setContext(context);\n    }\n    const viewCreatedEvent = {\n        id,\n        name,\n        startClocks,\n        service,\n        version,\n        context,\n    };\n    lifeCycle.notify(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, viewCreatedEvent);\n    lifeCycle.notify(2 /* LifeCycleEventType.VIEW_CREATED */, viewCreatedEvent);\n    // Update the view every time the measures are changing\n    const { throttled, cancel: cancelScheduleViewUpdate } = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    });\n    const { setLoadEvent, setViewEnd, stop: stopCommonViewMetricsTracking, stopINPTracking, getCommonViewMetrics, } = trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, startClocks);\n    const { stop: stopInitialViewMetricsTracking, initialViewMetrics } = loadingType === ViewLoadingType.INITIAL_LOAD\n        ? trackInitialViewMetrics(configuration, startClocks, setLoadEvent, scheduleViewUpdate)\n        : { stop: noop, initialViewMetrics: {} };\n    // Start BFCache-specific metrics when restoring from BFCache\n    if (loadingType === ViewLoadingType.BF_CACHE) {\n        trackBfcacheMetrics(startClocks, initialViewMetrics, scheduleViewUpdate);\n    }\n    const { stop: stopEventCountsTracking, eventCounts } = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate);\n    // Session keep alive\n    const keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    const pageMayExitSubscription = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, (pageMayExitEvent) => {\n        if (pageMayExitEvent.reason === PageExitReason.UNLOADING) {\n            triggerViewUpdate();\n        }\n    });\n    // Initial view update\n    triggerViewUpdate();\n    // View context update should always be throttled\n    contextManager.changeObservable.subscribe(scheduleViewUpdate);\n    function triggerBeforeViewUpdate() {\n        lifeCycle.notify(3 /* LifeCycleEventType.BEFORE_VIEW_UPDATED */, {\n            id,\n            name,\n            context: contextManager.getContext(),\n            startClocks,\n            sessionIsActive,\n        });\n    }\n    function scheduleViewUpdate() {\n        triggerBeforeViewUpdate();\n        throttled();\n    }\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        triggerBeforeViewUpdate();\n        documentVersion += 1;\n        const currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(4 /* LifeCycleEventType.VIEW_UPDATED */, {\n            customTimings,\n            documentVersion,\n            id,\n            name,\n            service,\n            version,\n            context: contextManager.getContext(),\n            loadingType,\n            location,\n            startClocks,\n            commonViewMetrics: getCommonViewMetrics(),\n            initialViewMetrics,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive,\n            eventCounts,\n        });\n    }\n    return {\n        get name() {\n            return name;\n        },\n        service,\n        version,\n        contextManager,\n        stopObservable,\n        end(options = {}) {\n            var _a, _b;\n            if (endClocks) {\n                // view already ended\n                return;\n            }\n            endClocks = (_a = options.endClocks) !== null && _a !== void 0 ? _a : clocksNow();\n            sessionIsActive = (_b = options.sessionIsActive) !== null && _b !== void 0 ? _b : true;\n            lifeCycle.notify(5 /* LifeCycleEventType.VIEW_ENDED */, { endClocks });\n            lifeCycle.notify(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, { endClocks });\n            clearInterval(keepAliveIntervalId);\n            setViewEnd(endClocks.relative);\n            stopCommonViewMetricsTracking();\n            pageMayExitSubscription.unsubscribe();\n            triggerViewUpdate();\n            setTimeout(() => {\n                this.stop();\n            }, KEEP_TRACKING_AFTER_VIEW_DELAY);\n        },\n        stop() {\n            stopInitialViewMetricsTracking();\n            stopEventCountsTracking();\n            stopINPTracking();\n            stopObservable.notify();\n        },\n        addTiming(name, time) {\n            if (endClocks) {\n                return;\n            }\n            const relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\n        },\n        setViewName(updatedName) {\n            name = updatedName;\n            triggerViewUpdate();\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    const sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(`Invalid timing name: ${name}, sanitized to: ${sanitized}`);\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    const correspondingId = hash.substring(1);\n    // check if the correspondingId is empty because on Firefox an empty string passed to getElementById() prints a consol warning\n    return correspondingId !== '' && !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    const index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { trackEventCounts } from '../trackEventCounts';\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    const { stop, eventCounts } = trackEventCounts({\n        lifeCycle,\n        isChildEvent: (event) => event.view.id === viewId,\n        onChange,\n    });\n    return {\n        stop,\n        eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { addEventListener } from '@datadog/browser-core';\nexport function onBFCacheRestore(configuration, callback) {\n    const { stop } = addEventListener(configuration, window, \"pageshow\" /* DOM_EVENT.PAGE_SHOW */, (event) => {\n        if (event.persisted) {\n            callback(event);\n        }\n    }, { capture: true });\n    return stop;\n}\n//# sourceMappingURL=bfCacheSupport.js.map","import { getTimeZone, DISCARDED, isEmptyObject, mapValues, toServerDuration } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, hooks, configuration, location, domMutationObservable, pageOpenObservable, locationChangeObservable, recorderApi, viewHistory, initialViewOptions) {\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_UPDATED */, (view) => lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, recorderApi)));\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        const view = viewHistory.findView(startTime);\n        if (!view) {\n            return DISCARDED;\n        }\n        return {\n            type: eventType,\n            service: view.service,\n            version: view.version,\n            context: view.context,\n            view: {\n                id: view.id,\n                name: view.name,\n            },\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, ({ startTime }) => {\n        var _a;\n        return ({\n            view: {\n                id: (_a = viewHistory.findView(startTime)) === null || _a === void 0 ? void 0 : _a.id,\n            },\n        });\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, pageOpenObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, configuration, recorderApi) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;\n    const replayStats = recorderApi.getReplayStats(view.id);\n    const clsDevicePixelRatio = (_b = (_a = view.commonViewMetrics) === null || _a === void 0 ? void 0 : _a.cumulativeLayoutShift) === null || _b === void 0 ? void 0 : _b.devicePixelRatio;\n    const viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            cls: clsDevicePixelRatio\n                ? {\n                    device_pixel_ratio: clsDevicePixelRatio,\n                }\n                : undefined,\n            configuration: {\n                start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n            },\n        },\n        date: view.startClocks.timeStamp,\n        type: RumEventType.VIEW,\n        view: {\n            action: {\n                count: view.eventCounts.actionCount,\n            },\n            frustration: {\n                count: view.eventCounts.frustrationCount,\n            },\n            cumulative_layout_shift: (_c = view.commonViewMetrics.cumulativeLayoutShift) === null || _c === void 0 ? void 0 : _c.value,\n            cumulative_layout_shift_time: toServerDuration((_d = view.commonViewMetrics.cumulativeLayoutShift) === null || _d === void 0 ? void 0 : _d.time),\n            cumulative_layout_shift_target_selector: (_e = view.commonViewMetrics.cumulativeLayoutShift) === null || _e === void 0 ? void 0 : _e.targetSelector,\n            first_byte: toServerDuration((_f = view.initialViewMetrics.navigationTimings) === null || _f === void 0 ? void 0 : _f.firstByte),\n            dom_complete: toServerDuration((_g = view.initialViewMetrics.navigationTimings) === null || _g === void 0 ? void 0 : _g.domComplete),\n            dom_content_loaded: toServerDuration((_h = view.initialViewMetrics.navigationTimings) === null || _h === void 0 ? void 0 : _h.domContentLoaded),\n            dom_interactive: toServerDuration((_j = view.initialViewMetrics.navigationTimings) === null || _j === void 0 ? void 0 : _j.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),\n            first_input_delay: toServerDuration((_k = view.initialViewMetrics.firstInput) === null || _k === void 0 ? void 0 : _k.delay),\n            first_input_time: toServerDuration((_l = view.initialViewMetrics.firstInput) === null || _l === void 0 ? void 0 : _l.time),\n            first_input_target_selector: (_m = view.initialViewMetrics.firstInput) === null || _m === void 0 ? void 0 : _m.targetSelector,\n            interaction_to_next_paint: toServerDuration((_o = view.commonViewMetrics.interactionToNextPaint) === null || _o === void 0 ? void 0 : _o.value),\n            interaction_to_next_paint_time: toServerDuration((_p = view.commonViewMetrics.interactionToNextPaint) === null || _p === void 0 ? void 0 : _p.time),\n            interaction_to_next_paint_target_selector: (_q = view.commonViewMetrics.interactionToNextPaint) === null || _q === void 0 ? void 0 : _q.targetSelector,\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration((_r = view.initialViewMetrics.largestContentfulPaint) === null || _r === void 0 ? void 0 : _r.value),\n            largest_contentful_paint_target_selector: (_s = view.initialViewMetrics.largestContentfulPaint) === null || _s === void 0 ? void 0 : _s.targetSelector,\n            load_event: toServerDuration((_t = view.initialViewMetrics.navigationTimings) === null || _t === void 0 ? void 0 : _t.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.commonViewMetrics.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            performance: computeViewPerformanceData(view.commonViewMetrics, view.initialViewMetrics),\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n        },\n        display: view.commonViewMetrics.scroll\n            ? {\n                scroll: {\n                    max_depth: view.commonViewMetrics.scroll.maxDepth,\n                    max_depth_scroll_top: view.commonViewMetrics.scroll.maxDepthScrollTop,\n                    max_scroll_height: view.commonViewMetrics.scroll.maxScrollHeight,\n                    max_scroll_height_time: toServerDuration(view.commonViewMetrics.scroll.maxScrollHeightTime),\n                },\n            }\n            : undefined,\n        privacy: {\n            replay_level: configuration.defaultPrivacyLevel,\n        },\n        device: {\n            locale: navigator.language,\n            locales: navigator.languages,\n            time_zone: getTimeZone(),\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        duration: view.duration,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\nfunction computeViewPerformanceData({ cumulativeLayoutShift, interactionToNextPaint }, { firstContentfulPaint, firstInput, largestContentfulPaint }) {\n    return {\n        cls: cumulativeLayoutShift && {\n            score: cumulativeLayoutShift.value,\n            timestamp: toServerDuration(cumulativeLayoutShift.time),\n            target_selector: cumulativeLayoutShift.targetSelector,\n            previous_rect: cumulativeLayoutShift.previousRect,\n            current_rect: cumulativeLayoutShift.currentRect,\n        },\n        fcp: firstContentfulPaint && { timestamp: toServerDuration(firstContentfulPaint) },\n        fid: firstInput && {\n            duration: toServerDuration(firstInput.delay),\n            timestamp: toServerDuration(firstInput.time),\n            target_selector: firstInput.targetSelector,\n        },\n        inp: interactionToNextPaint && {\n            duration: toServerDuration(interactionToNextPaint.value),\n            timestamp: toServerDuration(interactionToNextPaint.time),\n            target_selector: interactionToNextPaint.targetSelector,\n        },\n        lcp: largestContentfulPaint && {\n            timestamp: toServerDuration(largestContentfulPaint.value),\n            target_selector: largestContentfulPaint.targetSelector,\n            resource_url: largestContentfulPaint.resourceUrl,\n        },\n    };\n}\n//# sourceMappingURL=viewCollection.js.map","import { Observable } from '../../tools/observable';\nimport { createValueHistory } from '../../tools/valueHistory';\nimport { clocksOrigin, dateNow, ONE_MINUTE, relativeNow } from '../../tools/utils/timeUtils';\nimport { addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { clearInterval, setInterval } from '../../tools/timer';\nimport { addTelemetryDebug } from '../telemetry';\nimport { isSyntheticsTest } from '../synthetics/syntheticsWorkerValues';\nimport { getCurrentSite } from '../../browser/cookie';\nimport { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures';\nimport { findLast } from '../../tools/utils/polyfills';\nimport { monitorError } from '../../tools/monitor';\nimport { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nimport { toSessionState } from './sessionState';\nimport { retrieveSessionCookie } from './storeStrategies/sessionInCookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nexport const VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nconst SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nlet stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeTrackingType, trackingConsentState) {\n    const renewObservable = new Observable();\n    const expireObservable = new Observable();\n    // TODO - Improve configuration type and remove assertion\n    const sessionStore = startSessionStore(configuration.sessionStoreStrategyType, configuration, productKey, computeTrackingType);\n    stopCallbacks.push(() => sessionStore.stop());\n    const sessionContextHistory = createValueHistory({\n        expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,\n    });\n    stopCallbacks.push(() => sessionContextHistory.stop());\n    sessionStore.renewObservable.subscribe(() => {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n        renewObservable.notify();\n    });\n    sessionStore.expireObservable.subscribe(() => {\n        expireObservable.notify();\n        sessionContextHistory.closeActive(relativeNow());\n    });\n    // We expand/renew session unconditionally as tracking consent is always granted when the session\n    // manager is started.\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.SHORT_SESSION_INVESTIGATION)) {\n        const session = sessionStore.getSession();\n        if (session) {\n            detectSessionIdChange(configuration, session);\n        }\n    }\n    trackingConsentState.observable.subscribe(() => {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n        else {\n            sessionStore.expire();\n        }\n    });\n    trackActivity(configuration, () => {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n    });\n    trackVisibility(configuration, () => sessionStore.expandSession());\n    trackResume(configuration, () => sessionStore.restartSession());\n    function buildSessionContext() {\n        const session = sessionStore.getSession();\n        if (!session) {\n            reportUnexpectedSessionState().catch(() => void 0); // Ignore errors\n            return {\n                id: 'invalid',\n                trackingType: SESSION_NOT_TRACKED,\n                isReplayForced: false,\n                anonymousId: undefined,\n            };\n        }\n        return {\n            id: session.id,\n            trackingType: session[productKey],\n            isReplayForced: !!session.forcedReplay,\n            anonymousId: session.anonymousId,\n        };\n    }\n    return {\n        findSession: (startTime, options) => sessionContextHistory.find(startTime, options),\n        renewObservable,\n        expireObservable,\n        sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,\n        expire: sessionStore.expire,\n        updateSessionState: sessionStore.updateSessionState,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach((e) => e());\n    stopCallbacks = [];\n}\nfunction trackActivity(configuration, expandOrRenewSession) {\n    const { stop } = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"scroll\" /* DOM_EVENT.SCROLL */], expandOrRenewSession, { capture: true, passive: true });\n    stopCallbacks.push(stop);\n}\nfunction trackVisibility(configuration, expandSession) {\n    const expandSessionWhenVisible = () => {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    };\n    const { stop } = addEventListener(configuration, document, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, expandSessionWhenVisible);\n    stopCallbacks.push(stop);\n    const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n    stopCallbacks.push(() => {\n        clearInterval(visibilityCheckInterval);\n    });\n}\nfunction trackResume(configuration, cb) {\n    const { stop } = addEventListener(configuration, window, \"resume\" /* DOM_EVENT.RESUME */, cb, { capture: true });\n    stopCallbacks.push(stop);\n}\nasync function reportUnexpectedSessionState() {\n    const rawSession = retrieveSessionCookie();\n    // monitor-until: forever, could be handy to troubleshoot issues until session manager rework\n    addTelemetryDebug('Unexpected session state', {\n        session: rawSession,\n        isSyntheticsTest: isSyntheticsTest(),\n        createdTimestamp: rawSession === null || rawSession === void 0 ? void 0 : rawSession.created,\n        expireTimestamp: rawSession === null || rawSession === void 0 ? void 0 : rawSession.expire,\n        cookie: await getSessionCookies(),\n        currentDomain: `${window.location.protocol}//${window.location.hostname}`,\n    });\n}\nfunction detectSessionIdChange(configuration, initialSessionState) {\n    if (!window.cookieStore || !initialSessionState.created) {\n        return;\n    }\n    const sessionCreatedTime = Number(initialSessionState.created);\n    const sdkInitTime = dateNow();\n    const { stop } = addEventListener(configuration, cookieStore, \"change\" /* DOM_EVENT.CHANGE */, listener);\n    stopCallbacks.push(stop);\n    function listener(event) {\n        const changed = findLast(event.changed, (change) => change.name === SESSION_STORE_KEY);\n        if (!changed) {\n            return;\n        }\n        const sessionAge = dateNow() - sessionCreatedTime;\n        if (sessionAge > 14 * ONE_MINUTE) {\n            // The session might have expired just because it's too old or lack activity\n            stop();\n        }\n        else {\n            const newSessionState = toSessionState(changed.value);\n            if (newSessionState.id && newSessionState.id !== initialSessionState.id) {\n                stop();\n                const time = dateNow() - sdkInitTime;\n                getSessionCookies()\n                    .then((cookie) => {\n                    // monitor-until: 2025-12-01, after RUM-10845 investigation done\n                    addTelemetryDebug('Session cookie changed', {\n                        time,\n                        session_age: sessionAge,\n                        old: initialSessionState,\n                        new: newSessionState,\n                        cookie,\n                    });\n                })\n                    .catch(monitorError);\n            }\n        }\n    }\n}\nasync function getSessionCookies() {\n    let sessionCookies;\n    if ('cookieStore' in window) {\n        sessionCookies = await window.cookieStore.getAll(SESSION_STORE_KEY);\n    }\n    else {\n        sessionCookies = document.cookie.split(/\\s*;\\s*/).filter((cookie) => cookie.startsWith(SESSION_STORE_KEY));\n    }\n    return {\n        count: sessionCookies.length,\n        domain: getCurrentSite() || 'undefined',\n        ...sessionCookies,\n    };\n}\n//# sourceMappingURL=sessionManager.js.map","import { Observable, SESSION_NOT_TRACKED, bridgeSupports, noop, performDraw, startSessionManager, } from '@datadog/browser-core';\nexport const RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle, trackingConsentState) {\n    const sessionManager = startSessionManager(configuration, RUM_SESSION_KEY, (rawTrackingType) => computeTrackingType(configuration, rawTrackingType), trackingConsentState);\n    sessionManager.expireObservable.subscribe(() => {\n        lifeCycle.notify(9 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(() => {\n        lifeCycle.notify(10 /* LifeCycleEventType.SESSION_RENEWED */);\n    });\n    sessionManager.sessionStateUpdateObservable.subscribe(({ previousState, newState }) => {\n        if (!previousState.forcedReplay && newState.forcedReplay) {\n            const sessionEntity = sessionManager.findSession();\n            if (sessionEntity) {\n                sessionEntity.isReplayForced = true;\n            }\n        }\n    });\n    return {\n        findTrackedSession: (startTime) => {\n            const session = sessionManager.findSession(startTime);\n            if (!session || session.trackingType === \"0\" /* RumTrackingType.NOT_TRACKED */) {\n                return;\n            }\n            return {\n                id: session.id,\n                sessionReplay: session.trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */\n                    ? 1 /* SessionReplayState.SAMPLED */\n                    : session.isReplayForced\n                        ? 2 /* SessionReplayState.FORCED */\n                        : 0 /* SessionReplayState.OFF */,\n                anonymousId: session.anonymousId,\n            };\n        },\n        expire: sessionManager.expire,\n        expireObservable: sessionManager.expireObservable,\n        setForcedReplay: () => sessionManager.updateSessionState({ forcedReplay: '1' }),\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    const session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        sessionReplay: bridgeSupports(\"records\" /* BridgeCapability.RECORDS */) ? 1 /* SessionReplayState.SAMPLED */ : 0 /* SessionReplayState.OFF */,\n    };\n    return {\n        findTrackedSession: () => session,\n        expire: noop,\n        expireObservable: new Observable(),\n        setForcedReplay: noop,\n    };\n}\nfunction computeTrackingType(configuration, rawTrackingType) {\n    if (hasValidRumSession(rawTrackingType)) {\n        return rawTrackingType;\n    }\n    if (!performDraw(configuration.sessionSampleRate)) {\n        return \"0\" /* RumTrackingType.NOT_TRACKED */;\n    }\n    if (!performDraw(configuration.sessionReplaySampleRate)) {\n        return \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    return \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* RumTrackingType.NOT_TRACKED */ ||\n        trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||\n        trackingType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, createValueHistory, DISCARDED } from '@datadog/browser-core';\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\nexport const URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, hooks, locationChangeObservable, location) {\n    const urlContextHistory = createValueHistory({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY });\n    let previousViewUrl;\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, ({ startClocks }) => {\n        const viewUrl = location.href;\n        urlContextHistory.add(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, ({ endClocks }) => {\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    const locationChangeSubscription = locationChangeObservable.subscribe(({ newLocation }) => {\n        const current = urlContextHistory.find();\n        if (current) {\n            const changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext({ url, referrer }) {\n        return {\n            url,\n            referrer,\n        };\n    }\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        const urlContext = urlContextHistory.find(startTime);\n        if (!urlContext) {\n            return DISCARDED;\n        }\n        return {\n            type: eventType,\n            view: {\n                url: urlContext.url,\n                referrer: urlContext.referrer,\n            },\n        };\n    });\n    return {\n        findUrl: (startTime) => urlContextHistory.find(startTime),\n        stop: () => {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { addEventListener, instrumentMethod, Observable, shallowClone } from '@datadog/browser-core';\nexport function createLocationChangeObservable(configuration, location) {\n    let currentLocation = shallowClone(location);\n    return new Observable((observable) => {\n        const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange);\n        const { stop: stopHashTracking } = trackHash(configuration, onLocationChange);\n        function onLocationChange() {\n            if (currentLocation.href === location.href) {\n                return;\n            }\n            const newLocation = shallowClone(location);\n            observable.notify({\n                newLocation,\n                oldLocation: currentLocation,\n            });\n            currentLocation = newLocation;\n        }\n        return () => {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n}\nfunction trackHistory(configuration, onHistoryChange) {\n    const { stop: stopInstrumentingPushState } = instrumentMethod(getHistoryInstrumentationTarget('pushState'), 'pushState', ({ onPostCall }) => {\n        onPostCall(onHistoryChange);\n    });\n    const { stop: stopInstrumentingReplaceState } = instrumentMethod(getHistoryInstrumentationTarget('replaceState'), 'replaceState', ({ onPostCall }) => {\n        onPostCall(onHistoryChange);\n    });\n    const { stop: removeListener } = addEventListener(configuration, window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange);\n    return {\n        stop: () => {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(configuration, onHashChange) {\n    return addEventListener(configuration, window, \"hashchange\" /* DOM_EVENT.HASH_CHANGE */, onHashChange);\n}\nfunction getHistoryInstrumentationTarget(methodName) {\n    // Ideally we should always instument the method on the prototype, however some frameworks (e.g [Next.js](https://github.com/vercel/next.js/blob/d3f5532065f3e3bb84fb54bd2dfd1a16d0f03a21/packages/next/src/client/components/app-router.tsx#L429))\n    // are wrapping the instance method. In that case we should also wrap the instance method.\n    return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype;\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { SESSION_TIME_OUT_DELAY, SKIPPED, createValueHistory, isEmptyObject } from '@datadog/browser-core';\nimport { RumEventType } from '../../rawRumEvent.types';\nexport const FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport const BYTES_COMPUTATION_THROTTLING_DELAY = 200;\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(lifeCycle, hooks, configuration) {\n    const featureFlagContexts = createValueHistory({\n        expireDelay: FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY,\n    });\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, ({ startClocks }) => {\n        featureFlagContexts.add({}, startClocks.relative);\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, ({ endClocks }) => {\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        const trackFeatureFlagsForEvents = configuration.trackFeatureFlagsForEvents.concat([\n            RumEventType.VIEW,\n            RumEventType.ERROR,\n        ]);\n        if (!trackFeatureFlagsForEvents.includes(eventType)) {\n            return SKIPPED;\n        }\n        const featureFlagContext = featureFlagContexts.find(startTime);\n        if (!featureFlagContext || isEmptyObject(featureFlagContext)) {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            feature_flags: featureFlagContext,\n        };\n    });\n    return {\n        addFeatureFlagEvaluation: (key, value) => {\n            const currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n            }\n        },\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { ONE_SECOND, addTelemetryMetrics, setInterval } from '@datadog/browser-core';\nexport const MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nlet currentPeriodMeasures;\nlet batchHasRumEvent;\nexport function startCustomerDataTelemetry(telemetry, lifeCycle, batchFlushObservable) {\n    if (!telemetry.metricsEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    batchHasRumEvent = false;\n    // We measure the data of every view updates even if there could only be one per batch due to the upsert\n    // It means that contexts bytes count sums can be higher than it really is\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, () => {\n        batchHasRumEvent = true;\n    });\n    batchFlushObservable.subscribe(({ bytesCount, messagesCount }) => {\n        // Don't measure batch that only contains telemetry events to avoid batch sending loop\n        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n        if (!batchHasRumEvent) {\n            return;\n        }\n        batchHasRumEvent = false;\n        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);\n    });\n    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    // monitor-until: forever\n    addTelemetryMetrics(\"Customer data measures\" /* TelemetryMetrics.CUSTOMER_DATA_METRIC_NAME */, currentPeriodMeasures);\n    initCurrentPeriodMeasures();\n}\nfunction createMeasure() {\n    return { min: Infinity, max: 0, sum: 0 };\n}\nfunction updateMeasure(measure, value) {\n    measure.sum += value;\n    measure.min = Math.min(measure.min, value);\n    measure.max = Math.max(measure.max, value);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { SKIPPED, elapsed, createValueHistory, SESSION_TIME_OUT_DELAY, toServerDuration, addEventListeners, relativeNow, } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../browser/performanceObservable';\nimport { RumEventType } from '../../rawRumEvent.types';\n// Arbitrary value to cap number of element for memory consumption in the browser\nexport const MAX_PAGE_STATE_ENTRIES = 4000;\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport const MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500;\nexport const PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startPageStateHistory(hooks, configuration, maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE) {\n    const pageStateEntryHistory = createValueHistory({\n        expireDelay: PAGE_STATE_CONTEXT_TIME_OUT_DELAY,\n        maxEntries: MAX_PAGE_STATE_ENTRIES,\n    });\n    let currentPageState;\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.VISIBILITY_STATE)) {\n        const visibilityEntries = performance.getEntriesByType(RumPerformanceEntryType.VISIBILITY_STATE);\n        visibilityEntries.forEach((entry) => {\n            const state = entry.name === 'hidden' ? \"hidden\" /* PageState.HIDDEN */ : \"active\" /* PageState.ACTIVE */;\n            addPageState(state, entry.startTime);\n        });\n    }\n    addPageState(getPageState(), relativeNow());\n    const { stop: stopEventListeners } = addEventListeners(configuration, window, [\n        \"pageshow\" /* DOM_EVENT.PAGE_SHOW */,\n        \"focus\" /* DOM_EVENT.FOCUS */,\n        \"blur\" /* DOM_EVENT.BLUR */,\n        \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */,\n        \"resume\" /* DOM_EVENT.RESUME */,\n        \"freeze\" /* DOM_EVENT.FREEZE */,\n        \"pagehide\" /* DOM_EVENT.PAGE_HIDE */,\n    ], (event) => {\n        addPageState(computePageState(event), event.timeStamp);\n    }, { capture: true });\n    function addPageState(nextPageState, startTime = relativeNow()) {\n        if (nextPageState === currentPageState) {\n            return;\n        }\n        currentPageState = nextPageState;\n        pageStateEntryHistory.closeActive(startTime);\n        pageStateEntryHistory.add({ state: currentPageState, startTime }, startTime);\n    }\n    function wasInPageStateDuringPeriod(state, startTime, duration) {\n        return pageStateEntryHistory.findAll(startTime, duration).some((pageState) => pageState.state === state);\n    }\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, duration = 0, eventType }) => {\n        if (eventType === RumEventType.VIEW) {\n            const pageStates = pageStateEntryHistory.findAll(startTime, duration);\n            return {\n                type: eventType,\n                _dd: { page_states: processPageStates(pageStates, startTime, maxPageStateEntriesSelectable) },\n            };\n        }\n        if (eventType === RumEventType.ACTION || eventType === RumEventType.ERROR) {\n            return {\n                type: eventType,\n                view: { in_foreground: wasInPageStateDuringPeriod(\"active\" /* PageState.ACTIVE */, startTime, 0) },\n            };\n        }\n        return SKIPPED;\n    });\n    return {\n        wasInPageStateDuringPeriod,\n        addPageState,\n        stop: () => {\n            stopEventListeners();\n            pageStateEntryHistory.stop();\n        },\n    };\n}\nfunction processPageStates(pageStateEntries, eventStartTime, maxPageStateEntriesSelectable) {\n    if (pageStateEntries.length === 0) {\n        return;\n    }\n    return pageStateEntries\n        .slice(-maxPageStateEntriesSelectable)\n        .reverse()\n        .map(({ state, startTime }) => ({\n        state,\n        start: toServerDuration(elapsed(eventStartTime, startTime)),\n    }));\n}\nfunction computePageState(event) {\n    if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */) {\n        return event.persisted ? \"frozen\" /* PageState.FROZEN */ : \"terminated\" /* PageState.TERMINATED */;\n    }\n    return getPageState();\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* PageState.HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* PageState.ACTIVE */;\n    }\n    return \"passive\" /* PageState.PASSIVE */;\n}\n//# sourceMappingURL=pageStateHistory.js.map","import { setInterval, clearInterval, Observable, addEventListener, ONE_SECOND, findCommaSeparatedValue, } from '@datadog/browser-core';\nexport function createCookieObservable(configuration, cookieName) {\n    const detectCookieChangeStrategy = window.cookieStore\n        ? listenToCookieStoreChange(configuration)\n        : watchCookieFallback;\n    return new Observable((observable) => detectCookieChangeStrategy(cookieName, (event) => observable.notify(event)));\n}\nfunction listenToCookieStoreChange(configuration) {\n    return (cookieName, callback) => {\n        const listener = addEventListener(configuration, window.cookieStore, \"change\" /* DOM_EVENT.CHANGE */, (event) => {\n            // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.\n            // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226\n            const changeEvent = event.changed.find((event) => event.name === cookieName) ||\n                event.deleted.find((event) => event.name === cookieName);\n            if (changeEvent) {\n                callback(changeEvent.value);\n            }\n        });\n        return listener.stop;\n    };\n}\nexport const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND;\nfunction watchCookieFallback(cookieName, callback) {\n    const previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n    const watchCookieIntervalId = setInterval(() => {\n        const cookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n        if (cookieValue !== previousCookieValue) {\n            callback(cookieValue);\n        }\n    }, WATCH_COOKIE_INTERVAL_DELAY);\n    return () => {\n        clearInterval(watchCookieIntervalId);\n    };\n}\n//# sourceMappingURL=cookieObservable.js.map","import { getInitCookie, SKIPPED } from '@datadog/browser-core';\nimport { createCookieObservable } from '../../browser/cookieObservable';\nexport const CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id';\nexport function startCiVisibilityContext(configuration, hooks, cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME)) {\n    var _a;\n    let testExecutionId = getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || ((_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId'));\n    const cookieObservableSubscription = cookieObservable.subscribe((value) => {\n        testExecutionId = value;\n    });\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        if (typeof testExecutionId !== 'string') {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            session: {\n                type: \"ci_test\" /* SessionType.CI_TEST */,\n            },\n            ci_test: {\n                test_execution_id: testExecutionId,\n            },\n        };\n    });\n    return {\n        stop: () => {\n            cookieObservableSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=ciVisibilityContext.js.map","import { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    let eventCount = 0;\n    let allowNextEvent = false;\n    return {\n        isLimitReached() {\n            if (eventCount === 0) {\n                setTimeout(() => {\n                    eventCount = 0;\n                }, ONE_MINUTE);\n            }\n            eventCount += 1;\n            if (eventCount <= limit || allowNextEvent) {\n                allowNextEvent = false;\n                return false;\n            }\n            if (eventCount === limit + 1) {\n                allowNextEvent = true;\n                try {\n                    onLimitReached({\n                        message: `Reached max number of ${eventType}s by minute: ${limit}`,\n                        source: ErrorSource.AGENT,\n                        startClocks: clocksNow(),\n                    });\n                }\n                finally {\n                    allowNextEvent = false;\n                }\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=createEventRateLimiter.js.map","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core';\n/**\n * Allows declaring and enforcing modifications to specific fields of an object.\n * Only supports modifying properties of an object (even if nested in an array).\n * Does not support array manipulation (adding/removing items).\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    const clone = deepClone(object);\n    const result = modifier(clone);\n    objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => \n    // Traverse both object and clone simultaneously up to the path and apply the modification from the clone to the original object when the type is valid\n    setValueAtPath(object, clone, fieldPath.split(/\\.|(?=\\[\\])/), fieldType));\n    return result;\n}\nfunction setValueAtPath(object, clone, pathSegments, fieldType) {\n    const [field, ...restPathSegments] = pathSegments;\n    if (field === '[]') {\n        if (Array.isArray(object) && Array.isArray(clone)) {\n            object.forEach((item, i) => setValueAtPath(item, clone[i], restPathSegments, fieldType));\n        }\n        return;\n    }\n    if (!isValidObject(object) || !isValidObject(clone)) {\n        return;\n    }\n    if (restPathSegments.length > 0) {\n        return setValueAtPath(object[field], clone[field], restPathSegments, fieldType);\n    }\n    setNestedValue(object, field, clone[field], fieldType);\n}\nfunction setNestedValue(object, field, value, fieldType) {\n    const newType = getType(value);\n    if (newType === fieldType) {\n        object[field] = sanitize(value);\n    }\n    else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n        object[field] = {};\n    }\n}\nfunction isValidObject(object) {\n    return getType(object) === 'object';\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, display, createEventRateLimiter, DISCARDED, buildTags, } from '@datadog/browser-core';\nimport { RumEventType } from '../rawRumEvent.types';\nimport { limitModification } from './limitModification';\nconst VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.name': 'string',\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nconst USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nconst ROOT_MODIFIABLE_FIELD_PATHS = {\n    service: 'string',\n    version: 'string',\n};\nlet modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, hooks, reportError) {\n    modifiableFieldPathsByEvent = {\n        [RumEventType.VIEW]: {\n            'view.performance.lcp.resource_url': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [RumEventType.ERROR]: {\n            'error.message': 'string',\n            'error.stack': 'string',\n            'error.resource.url': 'string',\n            'error.fingerprint': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [RumEventType.RESOURCE]: {\n            'resource.url': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [RumEventType.ACTION]: {\n            'action.target.name': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [RumEventType.LONG_TASK]: {\n            'long_task.scripts[].source_url': 'string',\n            'long_task.scripts[].invoker': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [RumEventType.VITAL]: {\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n    };\n    const eventRateLimiters = {\n        [RumEventType.ERROR]: createEventRateLimiter(RumEventType.ERROR, configuration.eventRateLimiterThreshold, reportError),\n        [RumEventType.ACTION]: createEventRateLimiter(RumEventType.ACTION, configuration.eventRateLimiterThreshold, reportError),\n        [RumEventType.VITAL]: createEventRateLimiter(RumEventType.VITAL, configuration.eventRateLimiterThreshold, reportError),\n    };\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ startTime, duration, rawRumEvent, domainContext }) => {\n        const defaultRumEventAttributes = hooks.triggerHook(0 /* HookNames.Assemble */, {\n            eventType: rawRumEvent.type,\n            startTime,\n            duration,\n        });\n        if (defaultRumEventAttributes === DISCARDED) {\n            return;\n        }\n        const serverRumEvent = combine(defaultRumEventAttributes, rawRumEvent, {\n            ddtags: buildTags(configuration).join(','),\n        });\n        if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n            if (isEmptyObject(serverRumEvent.context)) {\n                delete serverRumEvent.context;\n            }\n            lifeCycle.notify(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, serverRumEvent);\n        }\n    });\n}\nfunction shouldSend(event, beforeSend, domainContext, eventRateLimiters) {\n    var _a;\n    if (beforeSend) {\n        const result = limitModification(event, modifiableFieldPathsByEvent[event.type], (event) => beforeSend(event, domainContext));\n        if (result === false && event.type !== RumEventType.VIEW) {\n            return false;\n        }\n        if (result === false) {\n            display.warn(\"Can't dismiss view events using beforeSend!\");\n        }\n    }\n    const rateLimitReached = (_a = eventRateLimiters[event.type]) === null || _a === void 0 ? void 0 : _a.isLimitReached();\n    return !rateLimitReached;\n}\n//# sourceMappingURL=assembly.js.map","import { abstractHooks } from '@datadog/browser-core';\nexport const createHooks = (abstractHooks);\n//# sourceMappingURL=hooks.js.map","import { RumEventType } from '../../rawRumEvent.types';\nconst allowedEventTypes = [\n    RumEventType.ACTION,\n    RumEventType.ERROR,\n    RumEventType.LONG_TASK,\n    RumEventType.RESOURCE,\n    RumEventType.VITAL,\n];\nexport function startEventCollection(lifeCycle) {\n    return {\n        addEvent: (startTime, event, domainContext, duration) => {\n            if (!allowedEventTypes.includes(event.type)) {\n                return;\n            }\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                startTime,\n                rawRumEvent: event,\n                domainContext,\n                duration,\n            });\n        },\n    };\n}\n//# sourceMappingURL=eventCollection.js.map","import { sendToExtension, createPageMayExitObservable, startTelemetry, canUseEventBridge, addTelemetryDebug, startAccountContext, startGlobalContext, startUserContext, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { createWindowOpenObservable } from '../browser/windowOpenObservable';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewHistory } from '../domain/contexts/viewHistory';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/action/actionCollection';\nimport { startErrorCollection } from '../domain/error/errorCollection';\nimport { startResourceCollection } from '../domain/resource/resourceCollection';\nimport { startViewCollection } from '../domain/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { startDisplayContext } from '../domain/contexts/displayContext';\nimport { startVitalCollection } from '../domain/vital/vitalCollection';\nimport { startCiVisibilityContext } from '../domain/contexts/ciVisibilityContext';\nimport { startLongAnimationFrameCollection } from '../domain/longAnimationFrame/longAnimationFrameCollection';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent } from '../browser/performanceObservable';\nimport { startLongTaskCollection } from '../domain/longTask/longTaskCollection';\nimport { startSyntheticsContext } from '../domain/contexts/syntheticsContext';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startSessionContext } from '../domain/contexts/sessionContext';\nimport { startConnectivityContext } from '../domain/contexts/connectivityContext';\nimport { startDefaultContext } from '../domain/contexts/defaultContext';\nimport { startTrackingConsentContext } from '../domain/contexts/trackingConsentContext';\nimport { createHooks } from '../domain/hooks';\nimport { startEventCollection } from '../domain/event/eventCollection';\nimport { startInitialViewMetricsTelemetry } from '../domain/view/viewMetrics/startInitialViewMetricsTelemetry';\nexport function startRum(configuration, recorderApi, profilerApi, initialViewOptions, createEncoder, \n// `startRum` and its subcomponents assume tracking consent is granted initially and starts\n// collecting logs unconditionally. As such, `startRum` should be called with a\n// `trackingConsentState` set to \"granted\".\ntrackingConsentState, customVitalsState, bufferedDataObservable, sdkName) {\n    const cleanupTasks = [];\n    const lifeCycle = new LifeCycle();\n    const hooks = createHooks();\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (event) => sendToExtension('rum', event));\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        // monitor-until: forever, to keep an eye on the errors reported to customers\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const pageMayExitObservable = createPageMayExitObservable(configuration);\n    const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n        lifeCycle.notify(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, event);\n    });\n    cleanupTasks.push(() => pageMayExitSubscription.unsubscribe());\n    const telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration, hooks, reportError, pageMayExitObservable, createEncoder);\n    cleanupTasks.push(telemetry.stop);\n    const session = !canUseEventBridge()\n        ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n        : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        const batch = startRumBatch(configuration, lifeCycle, reportError, pageMayExitObservable, session.expireObservable, createEncoder);\n        cleanupTasks.push(() => batch.stop());\n        startCustomerDataTelemetry(telemetry, lifeCycle, batch.flushController.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    const domMutationObservable = createDOMMutationObservable();\n    const locationChangeObservable = createLocationChangeObservable(configuration, location);\n    const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable();\n    cleanupTasks.push(stopWindowOpen);\n    startDefaultContext(hooks, configuration, sdkName);\n    const pageStateHistory = startPageStateHistory(hooks, configuration);\n    const viewHistory = startViewHistory(lifeCycle);\n    cleanupTasks.push(() => viewHistory.stop());\n    const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location);\n    cleanupTasks.push(() => urlContexts.stop());\n    const featureFlagContexts = startFeatureFlagContexts(lifeCycle, hooks, configuration);\n    startSessionContext(hooks, session, recorderApi, viewHistory);\n    startConnectivityContext(hooks);\n    startTrackingConsentContext(hooks, trackingConsentState);\n    const globalContext = startGlobalContext(hooks, configuration, 'rum', true);\n    const userContext = startUserContext(hooks, configuration, session, 'rum');\n    const accountContext = startAccountContext(hooks, configuration, 'rum');\n    const { actionContexts, addAction, addEvent, stop: stopRumEventCollection, } = startRumEventCollection(lifeCycle, hooks, configuration, pageStateHistory, domMutationObservable, windowOpenObservable, reportError);\n    cleanupTasks.push(stopRumEventCollection);\n    const { addTiming, startView, setViewName, setViewContext, setViewContextProperty, getViewContext, stop: stopViewCollection, } = startViewCollection(lifeCycle, hooks, configuration, location, domMutationObservable, windowOpenObservable, locationChangeObservable, recorderApi, viewHistory, initialViewOptions);\n    cleanupTasks.push(stopViewCollection);\n    const { stop: stopInitialViewMetricsTelemetry } = startInitialViewMetricsTelemetry(lifeCycle, telemetry);\n    cleanupTasks.push(stopInitialViewMetricsTelemetry);\n    const { stop: stopResourceCollection } = startResourceCollection(lifeCycle, configuration, pageStateHistory);\n    cleanupTasks.push(stopResourceCollection);\n    if (configuration.trackLongTasks) {\n        if (supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME)) {\n            const { stop: stopLongAnimationFrameCollection } = startLongAnimationFrameCollection(lifeCycle, configuration);\n            cleanupTasks.push(stopLongAnimationFrameCollection);\n        }\n        else {\n            startLongTaskCollection(lifeCycle, configuration);\n        }\n    }\n    const { addError } = startErrorCollection(lifeCycle, configuration, bufferedDataObservable);\n    bufferedDataObservable.unbuffer();\n    startRequestCollection(lifeCycle, configuration, session, userContext, accountContext);\n    const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState);\n    const internalContext = startInternalContext(configuration.applicationId, session, viewHistory, actionContexts, urlContexts);\n    // Add Clean-up tasks for Profiler API.\n    cleanupTasks.push(() => profilerApi.stop());\n    return {\n        addAction,\n        addEvent,\n        addError,\n        addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView,\n        setViewContext,\n        setViewContextProperty,\n        getViewContext,\n        setViewName,\n        lifeCycle,\n        viewHistory,\n        session,\n        stopSession: () => session.expire(),\n        getInternalContext: internalContext.get,\n        startDurationVital: vitalCollection.startDurationVital,\n        stopDurationVital: vitalCollection.stopDurationVital,\n        addDurationVital: vitalCollection.addDurationVital,\n        addOperationStepVital: vitalCollection.addOperationStepVital,\n        globalContext,\n        userContext,\n        accountContext,\n        telemetry,\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n        hooks,\n    };\n}\nexport function startRumEventCollection(lifeCycle, hooks, configuration, pageStateHistory, domMutationObservable, windowOpenObservable, reportError) {\n    const actionCollection = startActionCollection(lifeCycle, hooks, domMutationObservable, windowOpenObservable, configuration);\n    const eventCollection = startEventCollection(lifeCycle);\n    const displayContext = startDisplayContext(hooks, configuration);\n    const ciVisibilityContext = startCiVisibilityContext(configuration, hooks);\n    startSyntheticsContext(hooks);\n    startRumAssembly(configuration, lifeCycle, hooks, reportError);\n    return {\n        pageStateHistory,\n        addAction: actionCollection.addAction,\n        addEvent: eventCollection.addEvent,\n        actionContexts: actionCollection.actionContexts,\n        stop: () => {\n            actionCollection.stop();\n            ciVisibilityContext.stop();\n            displayContext.stop();\n            pageStateHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    const bridge = getEventBridge();\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { createBatch, createFlushController, createHttpRequest } from '@datadog/browser-core';\nimport { RumEventType } from '../rawRumEvent.types';\nexport function startRumBatch(configuration, lifeCycle, reportError, pageMayExitObservable, sessionExpireObservable, createEncoder) {\n    const endpoints = [configuration.rumEndpointBuilder];\n    if (configuration.replica) {\n        endpoints.push(configuration.replica.rumEndpointBuilder);\n    }\n    const batch = createBatch({\n        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),\n        request: createHttpRequest(endpoints, configuration.batchBytesLimit, reportError),\n        flushController: createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageMayExitObservable,\n            sessionExpireObservable,\n        }),\n        messageBytesLimit: configuration.messageBytesLimit,\n    });\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {\n        if (serverRumEvent.type === RumEventType.VIEW) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    return batch;\n}\n//# sourceMappingURL=startRumBatch.js.map","import { instrumentMethod, Observable } from '@datadog/browser-core';\nexport function createWindowOpenObservable() {\n    const observable = new Observable();\n    const { stop } = instrumentMethod(window, 'open', () => observable.notify());\n    return { observable, stop };\n}\n//# sourceMappingURL=windowOpenObservable.js.map","import { canUseEventBridge, currentDrift, round, timeStampNow } from '@datadog/browser-core';\nexport function startDefaultContext(hooks, configuration, sdkName) {\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        const source = configuration.source;\n        return {\n            type: eventType,\n            _dd: {\n                format_version: 2,\n                drift: currentDrift(),\n                configuration: {\n                    session_sample_rate: round(configuration.sessionSampleRate, 3),\n                    session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),\n                    profiling_sample_rate: round(configuration.profilingSampleRate, 3),\n                },\n                browser_sdk_version: canUseEventBridge() ? \"6.22.0\" : undefined,\n                sdk_name: sdkName,\n            },\n            application: {\n                id: configuration.applicationId,\n            },\n            date: timeStampNow(),\n            source,\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, () => ({\n        application: { id: configuration.applicationId },\n    }));\n}\n//# sourceMappingURL=defaultContext.js.map","import { DISCARDED, SKIPPED } from '@datadog/browser-core';\nimport { RumEventType } from '../../rawRumEvent.types';\nexport function startSessionContext(hooks, sessionManager, recorderApi, viewHistory) {\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType, startTime }) => {\n        const session = sessionManager.findTrackedSession(startTime);\n        const view = viewHistory.findView(startTime);\n        if (!session || !view) {\n            return DISCARDED;\n        }\n        let hasReplay;\n        let sampledForReplay;\n        let isActive;\n        if (eventType === RumEventType.VIEW) {\n            hasReplay = recorderApi.getReplayStats(view.id) ? true : undefined;\n            sampledForReplay = session.sessionReplay === 1 /* SessionReplayState.SAMPLED */;\n            isActive = view.sessionIsActive ? undefined : false;\n        }\n        else {\n            hasReplay = recorderApi.isRecording() ? true : undefined;\n        }\n        return {\n            type: eventType,\n            session: {\n                id: session.id,\n                type: \"user\" /* SessionType.USER */,\n                has_replay: hasReplay,\n                sampled_for_replay: sampledForReplay,\n                is_active: isActive,\n            },\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, ({ startTime }) => {\n        const session = sessionManager.findTrackedSession(startTime);\n        if (!session) {\n            return SKIPPED;\n        }\n        return {\n            session: {\n                id: session.id,\n            },\n        };\n    });\n}\n//# sourceMappingURL=sessionContext.js.map","import { getConnectivity } from '@datadog/browser-core';\nexport function startConnectivityContext(hooks) {\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => ({\n        type: eventType,\n        connectivity: getConnectivity(),\n    }));\n}\n//# sourceMappingURL=connectivityContext.js.map","import { DISCARDED, SKIPPED } from '@datadog/browser-core';\nexport function startTrackingConsentContext(hooks, trackingConsentState) {\n    hooks.register(1 /* HookNames.AssembleTelemetry */, () => {\n        const wasConsented = trackingConsentState.isGranted();\n        if (!wasConsented) {\n            return DISCARDED;\n        }\n        return SKIPPED;\n    });\n}\n//# sourceMappingURL=trackingConsentContext.js.map","import { monitor } from '@datadog/browser-core';\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nexport function startDisplayContext(hooks, configuration) {\n    let viewport;\n    // Use requestAnimationFrame to delay the calculation of viewport dimensions until after SDK initialization, preventing long tasks.\n    const animationFrameId = requestAnimationFrame(monitor(() => {\n        viewport = getViewportDimension();\n    }));\n    const unsubscribeViewport = initViewportObservable(configuration).subscribe((viewportDimension) => {\n        viewport = viewportDimension;\n    }).unsubscribe;\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => ({\n        type: eventType,\n        display: viewport ? { viewport } : undefined,\n    }));\n    return {\n        stop: () => {\n            unsubscribeViewport();\n            if (animationFrameId) {\n                cancelAnimationFrame(animationFrameId);\n            }\n        },\n    };\n}\n//# sourceMappingURL=displayContext.js.map","import { SKIPPED, getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum, isSyntheticsTest, } from '@datadog/browser-core';\nexport function startSyntheticsContext(hooks) {\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        if (!isSyntheticsTest()) {\n            return SKIPPED;\n        }\n        const testId = getSyntheticsTestId();\n        const resultId = getSyntheticsResultId();\n        return {\n            type: eventType,\n            session: {\n                type: \"synthetics\" /* SessionType.SYNTHETICS */,\n            },\n            synthetics: {\n                test_id: testId,\n                result_id: resultId,\n                injected: willSyntheticsInjectRum(),\n            },\n        };\n    });\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { addTelemetryMetrics, noop } from '@datadog/browser-core';\nexport function startInitialViewMetricsTelemetry(lifeCycle, telemetry) {\n    if (!telemetry.metricsEnabled) {\n        return { stop: noop };\n    }\n    const { unsubscribe } = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_UPDATED */, ({ initialViewMetrics }) => {\n        if (!initialViewMetrics.largestContentfulPaint || !initialViewMetrics.navigationTimings) {\n            return;\n        }\n        // The navigation timings become available shortly after the load event fires, so\n        // we're snapshotting the LCP value available at that point. However, more LCP values\n        // can be emitted until the page is scrolled or interacted with, so it's possible that\n        // the final LCP value may differ. These metrics are intended to help diagnose\n        // performance issues early in the page load process, and using LCP-at-page-load is a\n        // good fit for that use case, but it's important to be aware that this is not\n        // necessarily equivalent to the normal LCP metric.\n        // monitor-until: 2026-07-01\n        addTelemetryMetrics(\"Initial view metrics\" /* TelemetryMetrics.INITIAL_VIEW_METRICS_TELEMETRY_NAME */, {\n            metrics: createCoreInitialViewMetrics(initialViewMetrics.largestContentfulPaint, initialViewMetrics.navigationTimings),\n        });\n        unsubscribe();\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\nfunction createCoreInitialViewMetrics(lcp, navigation) {\n    return {\n        lcp: {\n            value: lcp.value,\n        },\n        navigation: {\n            domComplete: navigation.domComplete,\n            domContentLoaded: navigation.domContentLoaded,\n            domInteractive: navigation.domInteractive,\n            firstByte: navigation.firstByte,\n            loadEvent: navigation.loadEvent,\n        },\n    };\n}\n//# sourceMappingURL=startInitialViewMetricsTelemetry.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable';\nexport function startLongAnimationFrameCollection(lifeCycle, configuration) {\n    const performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_ANIMATION_FRAME,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            const startClocks = relativeToClocks(entry.startTime);\n            const rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,\n                    duration: toServerDuration(entry.duration),\n                    blocking_duration: toServerDuration(entry.blockingDuration),\n                    first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),\n                    render_start: toServerDuration(entry.renderStart),\n                    style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),\n                    start_time: toServerDuration(entry.startTime),\n                    scripts: entry.scripts.map((script) => ({\n                        duration: toServerDuration(script.duration),\n                        pause_duration: toServerDuration(script.pauseDuration),\n                        forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),\n                        start_time: toServerDuration(script.startTime),\n                        execution_start: toServerDuration(script.executionStart),\n                        source_url: script.sourceURL,\n                        source_function_name: script.sourceFunctionName,\n                        source_char_position: script.sourceCharPosition,\n                        invoker: script.invoker,\n                        invoker_type: script.invokerType,\n                        window_attribution: script.windowAttribution,\n                    })),\n                },\n                type: RumEventType.LONG_TASK,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent,\n                startTime: startClocks.relative,\n                duration: entry.duration,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return { stop: () => performanceResourceSubscription.unsubscribe() };\n}\n//# sourceMappingURL=longAnimationFrameCollection.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable';\nexport function startLongTaskCollection(lifeCycle, configuration) {\n    const performanceLongTaskSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_TASK,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            if (entry.entryType !== RumPerformanceEntryType.LONG_TASK) {\n                break;\n            }\n            if (!configuration.trackLongTasks) {\n                break;\n            }\n            const startClocks = relativeToClocks(entry.startTime);\n            const rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    entry_type: RumLongTaskEntryType.LONG_TASK,\n                    duration: toServerDuration(entry.duration),\n                },\n                type: RumEventType.LONG_TASK,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent,\n                startTime: startClocks.relative,\n                duration: entry.duration,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return {\n        stop() {\n            performanceLongTaskSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=longTaskCollection.js.map","/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, viewHistory, actionContexts, urlContexts) {\n    return {\n        get: (startTime) => {\n            const viewContext = viewHistory.findView(startTime);\n            const urlContext = urlContexts.findUrl(startTime);\n            const session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                const actionId = actionContexts.findActionId(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionId ? { id: actionId } : undefined,\n                    view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, { session, viewContext, errorType, }) {\n    const sessionId = session ? session.id : 'no-session-id';\n    const parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(`error-type=${errorType}`);\n    }\n    if (viewContext) {\n        parameters.push(`seed=${viewContext.id}`);\n        parameters.push(`from=${viewContext.startClocks.timeStamp}`);\n    }\n    const origin = getDatadogSiteUrl(configuration);\n    const path = `/rum/replay/sessions/${sessionId}`;\n    return `${origin}${path}?${parameters.join('&')}`;\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    const site = rumConfiguration.site;\n    const subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return `https://${subdomain ? `${subdomain}.` : ''}${site}`;\n}\nfunction getSiteDefaultSubdomain(configuration) {\n    switch (configuration.site) {\n        case INTAKE_SITE_US1:\n        case INTAKE_SITE_EU1:\n            return 'app';\n        case INTAKE_SITE_STAGING:\n            return 'dd';\n        default:\n            return undefined;\n    }\n}\n//# sourceMappingURL=getSessionReplayUrl.js.map","import { addTelemetryDebug, createHttpRequest, jsonStringify, objectEntries } from '@datadog/browser-core';\nexport function createFormDataTransport(configuration, lifeCycle, createEncoder, streamId) {\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        // monitor-until: forever, to keep an eye on the errors reported to customers\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const httpRequest = createHttpRequest([configuration.profilingEndpointBuilder], configuration.batchBytesLimit, reportError);\n    const encoder = createEncoder(streamId);\n    return {\n        async send({ event, ...attachments }) {\n            const formData = new FormData();\n            const serializedEvent = jsonStringify(event);\n            if (!serializedEvent) {\n                throw new Error('Failed to serialize event');\n            }\n            formData.append('event', new Blob([serializedEvent], { type: 'application/json' }), 'event.json');\n            let bytesCount = serializedEvent.length;\n            for (const [key, value] of objectEntries(attachments)) {\n                const serializedValue = jsonStringify(value);\n                if (!serializedValue) {\n                    throw new Error('Failed to serialize attachment');\n                }\n                const result = await encode(encoder, serializedValue);\n                bytesCount += result.outputBytesCount;\n                formData.append(key, new Blob([result.output]), key);\n            }\n            httpRequest.send({\n                data: formData,\n                bytesCount,\n            });\n        },\n    };\n}\nfunction encode(encoder, data) {\n    return new Promise((resolve) => {\n        encoder.write(data);\n        encoder.finish((encoderResult) => {\n            resolve(encoderResult);\n        });\n    });\n}\n//# sourceMappingURL=formDataTransport.js.map","import { getGlobalObject } from './globalObject';\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n    const browserWindow = getGlobalObject();\n    let original;\n    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n        original = target[browserWindow.Zone.__symbol__(name)];\n    }\n    if (!original) {\n        original = target[name];\n    }\n    return original;\n}\n//# sourceMappingURL=getZoneJsOriginalValue.js.map","export const TelemetryType = {\n    LOG: 'log',\n    CONFIGURATION: 'configuration',\n    USAGE: 'usage',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { buildTags } from '../tags';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../intakeSites';\nimport { BufferedObservable, Observable } from '../../tools/observable';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { sendToExtension } from '../../tools/sendToExtension';\nimport { performDraw } from '../../tools/utils/numberUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { combine } from '../../tools/mergeInto';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { getConnectivity } from '../connectivity';\nimport { canUseEventBridge, createFlushController, createHttpRequest, getEventBridge, createBatch, } from '../../transport';\nimport { DISCARDED } from '../../tools/abstractHooks';\nimport { globalObject, isWorkerEnvironment } from '../../tools/globalObject';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nconst ALLOWED_FRAME_URLS = [\n    'https://www.datadoghq-browser-agent.com',\n    'https://www.datad0g-browser-agent.com',\n    'https://d3uc069fcn7uxw.cloudfront.net',\n    'https://d20xtzwzcl0ceb.cloudfront.net',\n    'http://localhost',\n    '<anonymous>',\n];\nconst METRIC_SAMPLE_RATE = 1;\nconst TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\nlet telemetryObservable;\nexport function getTelemetryObservable() {\n    if (!telemetryObservable) {\n        telemetryObservable = new BufferedObservable(100);\n    }\n    return telemetryObservable;\n}\nexport function startTelemetry(telemetryService, configuration, hooks, reportError, pageMayExitObservable, createEncoder) {\n    const observable = new Observable();\n    const { stop } = startTelemetryTransport(configuration, reportError, pageMayExitObservable, createEncoder, observable);\n    const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hooks, observable);\n    return {\n        stop,\n        enabled,\n        metricsEnabled,\n    };\n}\nexport function startTelemetryCollection(telemetryService, configuration, hooks, observable, metricSampleRate = METRIC_SAMPLE_RATE) {\n    const alreadySentEventsByKind = {};\n    const telemetryEnabled = !TELEMETRY_EXCLUDED_SITES.includes(configuration.site) && performDraw(configuration.telemetrySampleRate);\n    const telemetryEnabledPerType = {\n        [TelemetryType.LOG]: telemetryEnabled,\n        [TelemetryType.CONFIGURATION]: telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),\n        [TelemetryType.USAGE]: telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),\n        // not an actual \"type\" but using a single draw for all metrics\n        metric: telemetryEnabled && performDraw(metricSampleRate),\n    };\n    const runtimeEnvInfo = getRuntimeEnvInfo();\n    const telemetryObservable = getTelemetryObservable();\n    telemetryObservable.subscribe(({ rawEvent, metricName }) => {\n        if ((metricName && !telemetryEnabledPerType['metric']) || !telemetryEnabledPerType[rawEvent.type]) {\n            return;\n        }\n        const kind = metricName || rawEvent.status || rawEvent.type;\n        let alreadySentEvents = alreadySentEventsByKind[kind];\n        if (!alreadySentEvents) {\n            alreadySentEvents = alreadySentEventsByKind[kind] = new Set();\n        }\n        if (alreadySentEvents.size >= configuration.maxTelemetryEventsPerPage) {\n            return;\n        }\n        const stringifiedEvent = jsonStringify(rawEvent);\n        if (alreadySentEvents.has(stringifiedEvent)) {\n            return;\n        }\n        const defaultTelemetryEventAttributes = hooks.triggerHook(1 /* HookNames.AssembleTelemetry */, {\n            startTime: clocksNow().relative,\n        });\n        if (defaultTelemetryEventAttributes === DISCARDED) {\n            return;\n        }\n        const event = toTelemetryEvent(defaultTelemetryEventAttributes, telemetryService, rawEvent, runtimeEnvInfo);\n        observable.notify(event);\n        sendToExtension('telemetry', event);\n        alreadySentEvents.add(stringifiedEvent);\n    });\n    telemetryObservable.unbuffer();\n    startMonitorErrorCollection(addTelemetryError);\n    return {\n        enabled: telemetryEnabled,\n        metricsEnabled: telemetryEnabledPerType['metric'],\n    };\n    function toTelemetryEvent(defaultTelemetryEventAttributes, telemetryService, rawEvent, runtimeEnvInfo) {\n        const clockNow = clocksNow();\n        const event = {\n            type: 'telemetry',\n            date: clockNow.timeStamp,\n            service: telemetryService,\n            version: \"6.22.0\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: combine(rawEvent, {\n                runtime_env: runtimeEnvInfo,\n                connectivity: getConnectivity(),\n                sdk_setup: \"npm\",\n            }),\n            ddtags: buildTags(configuration).join(','),\n            experimental_features: Array.from(getExperimentalFeatures()),\n        };\n        return combine(event, defaultTelemetryEventAttributes);\n    }\n}\nfunction startTelemetryTransport(configuration, reportError, pageMayExitObservable, createEncoder, telemetryObservable) {\n    const cleanupTasks = [];\n    if (canUseEventBridge()) {\n        const bridge = getEventBridge();\n        const telemetrySubscription = telemetryObservable.subscribe((event) => bridge.send('internal_telemetry', event));\n        cleanupTasks.push(telemetrySubscription.unsubscribe);\n    }\n    else {\n        const endpoints = [configuration.rumEndpointBuilder];\n        if (configuration.replica && isTelemetryReplicationAllowed(configuration)) {\n            endpoints.push(configuration.replica.rumEndpointBuilder);\n        }\n        const telemetryBatch = createBatch({\n            encoder: createEncoder(4 /* DeflateEncoderStreamId.TELEMETRY */),\n            request: createHttpRequest(endpoints, configuration.batchBytesLimit, reportError),\n            flushController: createFlushController({\n                messagesLimit: configuration.batchMessagesLimit,\n                bytesLimit: configuration.batchBytesLimit,\n                durationLimit: configuration.flushTimeout,\n                pageMayExitObservable,\n                // We don't use an actual session expire observable here, to make telemetry collection\n                // independent of the session. This allows to start and send telemetry events earlier.\n                sessionExpireObservable: new Observable(),\n            }),\n            messageBytesLimit: configuration.messageBytesLimit,\n        });\n        cleanupTasks.push(telemetryBatch.stop);\n        const telemetrySubscription = telemetryObservable.subscribe(telemetryBatch.add);\n        cleanupTasks.push(telemetrySubscription.unsubscribe);\n    }\n    return {\n        stop: () => cleanupTasks.forEach((task) => task()),\n    };\n}\nfunction getRuntimeEnvInfo() {\n    var _a;\n    return {\n        is_local_file: ((_a = globalObject.location) === null || _a === void 0 ? void 0 : _a.protocol) === 'file:',\n        is_worker: isWorkerEnvironment,\n    };\n}\nexport function resetTelemetry() {\n    telemetryObservable = undefined;\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nfunction isTelemetryReplicationAllowed(configuration) {\n    return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n    displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n    getTelemetryObservable().notify({\n        rawEvent: {\n            type: TelemetryType.LOG,\n            message,\n            status: \"debug\" /* StatusType.debug */,\n            ...context,\n        },\n    });\n}\nexport function addTelemetryError(e, context) {\n    getTelemetryObservable().notify({\n        rawEvent: {\n            type: TelemetryType.LOG,\n            status: \"error\" /* StatusType.error */,\n            ...formatError(e),\n            ...context,\n        },\n    });\n}\nexport function addTelemetryConfiguration(configuration) {\n    getTelemetryObservable().notify({\n        rawEvent: {\n            type: TelemetryType.CONFIGURATION,\n            configuration,\n        },\n    });\n}\nexport function addTelemetryMetrics(metricName, context) {\n    getTelemetryObservable().notify({\n        rawEvent: {\n            type: TelemetryType.LOG,\n            message: metricName,\n            status: \"debug\" /* StatusType.debug */,\n            ...context,\n        },\n        metricName,\n    });\n}\nexport function addTelemetryUsage(usage) {\n    getTelemetryObservable().notify({\n        rawEvent: {\n            type: TelemetryType.USAGE,\n            usage,\n        },\n    });\n}\nexport function formatError(e) {\n    if (isError(e)) {\n        const stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(scrubCustomerFrames(stackTrace)),\n            },\n            message: stackTrace.message,\n        };\n    }\n    return {\n        error: {\n            stack: NO_ERROR_STACK_PRESENT_MESSAGE,\n        },\n        message: `${\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */} ${jsonStringify(e)}`,\n    };\n}\nexport function scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter((frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => frame.url.startsWith(allowedFrameUrl)));\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { getType } from './utils/typeUtils';\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker = createCircularReferenceChecker()) {\n    // ignore the source if it is undefined\n    if (source === undefined) {\n        return destination;\n    }\n    if (typeof source !== 'object' || source === null) {\n        // primitive values - just return source\n        return source;\n    }\n    else if (source instanceof Date) {\n        return new Date(source.getTime());\n    }\n    else if (source instanceof RegExp) {\n        const flags = source.flags ||\n            // old browsers compatibility\n            [\n                source.global ? 'g' : '',\n                source.ignoreCase ? 'i' : '',\n                source.multiline ? 'm' : '',\n                source.sticky ? 'y' : '',\n                source.unicode ? 'u' : '',\n            ].join('');\n        return new RegExp(source.source, flags);\n    }\n    if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n        // remove circular references\n        return undefined;\n    }\n    else if (Array.isArray(source)) {\n        const merged = Array.isArray(destination) ? destination : [];\n        for (let i = 0; i < source.length; ++i) {\n            merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker);\n        }\n        return merged;\n    }\n    const merged = getType(destination) === 'object' ? destination : {};\n    for (const key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n            merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);\n        }\n    }\n    return merged;\n}\n/**\n * A simplistic implementation of a deep clone algorithm.\n * Caveats:\n * - It doesn't maintain prototype chains - don't use with instances of custom classes.\n * - It doesn't handle Map and Set\n */\nexport function deepClone(value) {\n    return mergeInto(undefined, value);\n}\nexport function combine(...sources) {\n    let destination;\n    for (const source of sources) {\n        // Ignore any undefined or null sources.\n        if (source === undefined || source === null) {\n            continue;\n        }\n        destination = mergeInto(destination, source);\n    }\n    return destination;\n}\nfunction createCircularReferenceChecker() {\n    if (typeof WeakSet !== 'undefined') {\n        const set = new WeakSet();\n        return {\n            hasAlreadyBeenSeen(value) {\n                const has = set.has(value);\n                if (!has) {\n                    set.add(value);\n                }\n                return has;\n            },\n        };\n    }\n    const array = [];\n    return {\n        hasAlreadyBeenSeen(value) {\n            const has = array.indexOf(value) >= 0;\n            if (!has) {\n                array.push(value);\n            }\n            return has;\n        },\n    };\n}\n//# sourceMappingURL=mergeInto.js.map","export function shallowClone(object) {\n    return { ...object };\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some((key) => object[key] === value);\n}\nexport function isEmptyObject(object) {\n    return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n    const newObject = {};\n    for (const key of Object.keys(object)) {\n        newObject[key] = fn(object[key]);\n    }\n    return newObject;\n}\n//# sourceMappingURL=objectUtils.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { display } from '../tools/display';\nexport function makePublicApi(stub) {\n    const publicApi = {\n        version: \"6.22.0\",\n        // This API method is intentionally not monitored, since the only thing executed is the\n        // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and\n        // we don't want to interfere with the user uncaught exceptions.\n        onReady(callback) {\n            callback();\n        },\n        ...stub,\n    };\n    // Add a \"hidden\" property to set debug mode. We define it that way to hide it\n    // as much as possible but of course it's not a real protection.\n    Object.defineProperty(publicApi, '_setDebug', {\n        get() {\n            return setDebugMode;\n        },\n        enumerable: false,\n    });\n    return publicApi;\n}\nexport function defineGlobal(global, name, api) {\n    const existingGlobalVariable = global[name];\n    if (existingGlobalVariable && !existingGlobalVariable.q && existingGlobalVariable.version) {\n        display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.');\n    }\n    global[name] = api;\n    if (existingGlobalVariable && existingGlobalVariable.q) {\n        existingGlobalVariable.q.forEach((fn) => catchUserErrors(fn, 'onReady callback threw an error:')());\n    }\n}\n//# sourceMappingURL=init.js.map","import { Observable } from '../tools/observable';\nexport const TrackingConsent = {\n    GRANTED: 'granted',\n    NOT_GRANTED: 'not-granted',\n};\nexport function createTrackingConsentState(currentConsent) {\n    const observable = new Observable();\n    return {\n        tryToInit(trackingConsent) {\n            if (!currentConsent) {\n                currentConsent = trackingConsent;\n            }\n        },\n        update(trackingConsent) {\n            currentConsent = trackingConsent;\n            observable.notify();\n        },\n        isGranted() {\n            return currentConsent === TrackingConsent.GRANTED;\n        },\n        observable,\n    };\n}\n//# sourceMappingURL=trackingConsent.js.map","export const ErrorSource = {\n    AGENT: 'agent',\n    CONSOLE: 'console',\n    CUSTOM: 'custom',\n    LOGGER: 'logger',\n    NETWORK: 'network',\n    SOURCE: 'source',\n    REPORT: 'report',\n};\n//# sourceMappingURL=error.types.js.map","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\nconst UNKNOWN_FUNCTION = '?';\nexport function computeStackTrace(ex) {\n    var _a, _b;\n    const stack = [];\n    let stackProperty = tryToGetString(ex, 'stack');\n    const exString = String(ex);\n    if (stackProperty && stackProperty.startsWith(exString)) {\n        stackProperty = stackProperty.slice(exString.length);\n    }\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach((line) => {\n            const stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);\n            if (stackFrame) {\n                if (!stackFrame.func && stackFrame.line) {\n                    stackFrame.func = UNKNOWN_FUNCTION;\n                }\n                stack.push(stackFrame);\n            }\n        });\n    }\n    if (stack.length > 0 && isWronglyReportingCustomErrors() && ex instanceof Error) {\n        // if we are wrongly reporting custom errors\n        const constructors = [];\n        // go through each inherited constructor\n        let currentPrototype = ex;\n        while ((currentPrototype = Object.getPrototypeOf(currentPrototype)) &&\n            isNonNativeClassPrototype(currentPrototype)) {\n            const constructorName = ((_a = currentPrototype.constructor) === null || _a === void 0 ? void 0 : _a.name) || UNKNOWN_FUNCTION;\n            constructors.push(constructorName);\n        }\n        // traverse the stacktrace in reverse order because the stacktrace starts with the last inherited constructor\n        // we check constructor names to ensure we remove the correct frame (and there isn't a weird unsupported environment behavior)\n        for (let i = constructors.length - 1; i >= 0 && ((_b = stack[0]) === null || _b === void 0 ? void 0 : _b.func) === constructors[i]; i--) {\n            // if the first stack frame is the custom error constructor\n            // null stack frames may represent frames that failed to be parsed because the error class did not have a constructor\n            stack.shift(); // remove it\n        }\n    }\n    return {\n        message: tryToGetString(ex, 'message'),\n        name: tryToGetString(ex, 'name'),\n        stack,\n    };\n}\nconst fileUrl = '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nconst filePosition = '(?::(\\\\d+))';\nconst CHROME_LINE_RE = new RegExp(`^\\\\s*at (.*?) ?\\\\(${fileUrl}${filePosition}?${filePosition}?\\\\)?\\\\s*$`, 'i');\nconst CHROME_EVAL_RE = new RegExp(`\\\\((\\\\S*)${filePosition}${filePosition}\\\\)`);\nfunction parseChromeLine(line) {\n    const parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    const submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && 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    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nconst CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\\\s*at ?${fileUrl}${filePosition}?${filePosition}??\\\\s*$`, 'i');\nfunction parseChromeAnonymousLine(line) {\n    const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[3] ? +parts[3] : undefined,\n        func: UNKNOWN_FUNCTION,\n        line: parts[2] ? +parts[2] : undefined,\n        url: parts[1],\n    };\n}\nconst WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    const parts = WINJS_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: +parts[3],\n        url: parts[2],\n    };\n}\nconst GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:(?:(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle|\\[wasm code\\])(?::(\\d+))?(?::(\\d+))?)|@)\\s*$/i;\nconst GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    const parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    const submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    const value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\nexport function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {\n    if (url === undefined) {\n        return;\n    }\n    const { name, message } = tryToParseMessage(messageObj);\n    return {\n        name,\n        message,\n        stack: [{ url, column, line }],\n    };\n}\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nconst ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/;\nfunction tryToParseMessage(messageObj) {\n    let name;\n    let message;\n    if ({}.toString.call(messageObj) === '[object String]') {\n        ;\n        [, name, message] = ERROR_TYPES_RE.exec(messageObj);\n    }\n    return { name, message };\n}\n// Custom error stacktrace fix\n// Some browsers (safari/firefox) add the error constructor as a frame in the stacktrace\n// In order to normalize the stacktrace, we need to remove it\nfunction isNonNativeClassPrototype(prototype) {\n    return String(prototype.constructor).startsWith('class ');\n}\nlet isWronglyReportingCustomErrorsCache;\nfunction isWronglyReportingCustomErrors() {\n    if (isWronglyReportingCustomErrorsCache !== undefined) {\n        return isWronglyReportingCustomErrorsCache;\n    }\n    /* eslint-disable no-restricted-syntax */\n    class DatadogTestCustomError extends Error {\n        constructor() {\n            super();\n            this.name = 'Error'; // set name to Error so that no browser would default to the constructor name\n        }\n    }\n    const [customError, nativeError] = [DatadogTestCustomError, Error].map((errConstructor) => new errConstructor()); // so that both errors should exactly have the same stacktrace\n    isWronglyReportingCustomErrorsCache =\n        // If customError is not a class, it means that this was built with ES5 as target, converting the class to a normal object.\n        // Thus, error constructors will be reported on all browsers, which is the expected behavior.\n        isNonNativeClassPrototype(Object.getPrototypeOf(customError)) &&\n            // If the browser is correctly reporting the stacktrace, the normal error stacktrace should be the same as the custom error stacktrace\n            nativeError.stack !== customError.stack;\n    return isWronglyReportingCustomErrorsCache;\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n    return (...args) => {\n        try {\n            return fn(...args);\n        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","export const RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport const NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport const IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport const MouseInteractionType = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport const MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nconst TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport const convertMouseEventToLayoutCoordinates = (clientX, clientY) => {\n    const visualViewport = window.visualViewport;\n    const normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport const getVisualViewport = (visualViewport) => ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n});\n//# sourceMappingURL=viewports.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: {\n            source,\n            ...data,\n        },\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { addEventListeners, throttle } from '@datadog/browser-core';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function trackMove(configuration, scope, moveCb) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        const id = scope.nodeIds.get(target);\n        if (id === undefined) {\n            return;\n        }\n        const coordinates = tryToComputeCoordinates(event);\n        if (!coordinates) {\n            return;\n        }\n        const position = {\n            id,\n            timeOffset: 0,\n            x: coordinates.x,\n            y: coordinates.y,\n        };\n        moveCb(assembleIncrementalSnapshot(isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove, { positions: [position] }));\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\nexport function tryToComputeCoordinates(event) {\n    let { clientX: x, clientY: y } = isTouchEvent(event) ? event.changedTouches[0] : event;\n    if (window.visualViewport) {\n        const { visualViewportX, visualViewportY } = convertMouseEventToLayoutCoordinates(x, y);\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        return undefined;\n    }\n    return { x, y };\n}\n//# sourceMappingURL=trackMove.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { tryToComputeCoordinates } from './trackMove';\nconst eventTypeToMouseInteraction = {\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    [\"pointerup\" /* DOM_EVENT.POINTER_UP */]: MouseInteractionType.MouseUp,\n    [\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */]: MouseInteractionType.MouseDown,\n    [\"click\" /* DOM_EVENT.CLICK */]: MouseInteractionType.Click,\n    [\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */]: MouseInteractionType.ContextMenu,\n    [\"dblclick\" /* DOM_EVENT.DBL_CLICK */]: MouseInteractionType.DblClick,\n    [\"focus\" /* DOM_EVENT.FOCUS */]: MouseInteractionType.Focus,\n    [\"blur\" /* DOM_EVENT.BLUR */]: MouseInteractionType.Blur,\n    [\"touchstart\" /* DOM_EVENT.TOUCH_START */]: MouseInteractionType.TouchStart,\n    [\"touchend\" /* DOM_EVENT.TOUCH_END */]: MouseInteractionType.TouchEnd,\n};\nexport function trackMouseInteraction(configuration, scope, mouseInteractionCb, recordIds) {\n    const handler = (event) => {\n        const target = getEventTarget(event);\n        const id = scope.nodeIds.get(target);\n        if (id === undefined ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        const type = eventTypeToMouseInteraction[event.type];\n        let interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            const coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id, type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id, type };\n        }\n        const record = {\n            id: recordIds.getIdForEvent(event),\n            ...assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction),\n        };\n        mouseInteractionCb(record);\n    };\n    return addEventListeners(configuration, document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMouseInteraction.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY, getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst SCROLL_OBSERVER_THRESHOLD = 100;\nexport function trackScroll(configuration, scope, scrollCb, elementsScrollPositions, target = document) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        if (!target) {\n            return;\n        }\n        const id = scope.nodeIds.get(target);\n        if (id === undefined ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        const scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        scrollCb(assembleIncrementalSnapshot(IncrementalSource.Scroll, {\n            id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD);\n    const { stop: removeListener } = addEventListener(configuration, target, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackScroll.js.map","import { throttle, addEventListeners, timeStampNow, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { IncrementalSource, RecordType } from '../../../types';\nimport { getVisualViewport } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function trackViewportResize(configuration, viewportResizeCb) {\n    const viewportResizeSubscription = initViewportObservable(configuration).subscribe((data) => {\n        viewportResizeCb(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: () => {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function trackVisualViewportResize(configuration, visualViewportResizeCb) {\n    const visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    const { throttled: updateDimension, cancel: cancelThrottle } = throttle(() => {\n        visualViewportResizeCb({\n            data: getVisualViewport(visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp: timeStampNow(),\n        });\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackViewportResize.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackMediaInteraction(configuration, scope, mediaInteractionCb) {\n    return addEventListeners(configuration, document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], (event) => {\n        const target = getEventTarget(event);\n        if (!target) {\n            return;\n        }\n        const id = scope.nodeIds.get(target);\n        if (id === undefined ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        mediaInteractionCb(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, {\n            id,\n            type: event.type === \"play\" /* DOM_EVENT.PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        }));\n    }, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMediaInteraction.js.map","import { instrumentMethod } from '@datadog/browser-core';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackStyleSheet(scope, styleSheetCb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (!styleSheet || !styleSheet.ownerNode) {\n            return;\n        }\n        const id = scope.nodeIds.get(styleSheet.ownerNode);\n        if (id === undefined) {\n            return;\n        }\n        callback(id);\n    }\n    const instrumentationStoppers = [\n        instrumentMethod(CSSStyleSheet.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                adds: [{ rule, index }],\n            })));\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                removes: [{ index }],\n            })));\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethod(cls.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index || 0);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        adds: [{ rule, index: path }],\n                    }));\n                }\n            });\n        }), instrumentMethod(cls.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        removes: [{ index: path }],\n                    }));\n                }\n            });\n        }));\n    }\n    return {\n        stop: () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        },\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    const path = [];\n    let currentRule = rule;\n    while (currentRule.parentRule) {\n        const rules = Array.from(currentRule.parentRule.cssRules);\n        const index = rules.indexOf(currentRule);\n        path.unshift(index);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    const rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    const index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=trackStyleSheet.js.map","import { addEventListeners, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackFocus(configuration, focusCb) {\n    return addEventListeners(configuration, window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], () => {\n        focusCb({\n            data: { has_focus: document.hasFocus() },\n            type: RecordType.Focus,\n            timestamp: timeStampNow(),\n        });\n    });\n}\n//# sourceMappingURL=trackFocus.js.map","import { ActionType, RumEventType } from '@datadog/browser-rum-core';\nimport { RecordType } from '../../../types';\nexport function trackFrustration(lifeCycle, frustrationCb, recordIds) {\n    const frustrationSubscription = lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, (data) => {\n        var _a, _b;\n        if (data.rawRumEvent.type === RumEventType.ACTION &&\n            data.rawRumEvent.action.type === ActionType.CLICK &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            data.domainContext.events &&\n            data.domainContext.events.length) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map((e) => recordIds.getIdForEvent(e)),\n                },\n            });\n        }\n    });\n    return {\n        stop: () => {\n            frustrationSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFrustration.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackViewEnd(lifeCycle, viewEndCb) {\n    const viewEndSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, () => {\n        viewEndCb({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    });\n    return {\n        stop: () => {\n            viewEndSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackViewEnd.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { CENSORED_STRING_MARK, shouldMaskNode } from '@datadog/browser-rum-core';\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    const tagName = element.tagName;\n    const value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        const type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\nexport const URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport const ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport const DATA_URI = /^[\"']?data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) => {\n        const url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        const quote = singleQuote || doubleQuote || '';\n        return `url(${quote}${makeUrlAbsolute(url, cssHref)}${quote})`;\n    });\n}\nfunction makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_a) {\n        return url;\n    }\n}\nconst TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    const processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nexport function censoredImageForSize(width, height) {\n    return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${width}' height='${height}' style='background-color:silver'%3E%3C/svg%3E`;\n}\n//# sourceMappingURL=serializationUtils.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map((cssStyleSheet) => {\n        const rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        const cssRules = Array.from(rules, (cssRule) => cssRule.cssText);\n        const styleSheet = {\n            cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK, STABLE_ATTRIBUTES, sanitizeIfLongDataUrl, } from '@datadog/browser-rum-core';\nimport { censoredImageForSize } from './serializationUtils';\n// TODO: temporarily bump the Session Replay limit to 1Mb for dataUrls\n// This limit should be removed after [PANA-2843] is implemented\nexport const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 1000000;\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    const attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        const tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' && (attributeName === 'src' || attributeName === 'srcset')) {\n            // generate image with similar dimension than the original to have the same rendering behaviour\n            const image = element;\n            if (image.naturalWidth > 0) {\n                return censoredImageForSize(image.naturalWidth, image.naturalHeight);\n            }\n            const { width, height } = element.getBoundingClientRect();\n            if (width > 0 || height > 0) {\n                return censoredImageForSize(width, height);\n            }\n            // if we can't get the image size, fallback to the censored image\n            return CENSORED_IMG_MARK;\n        }\n        // mask source URLs\n        if (tagName === 'SOURCE' && (attributeName === 'src' || attributeName === 'srcset')) {\n            return CENSORED_IMG_MARK;\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && attributeName.startsWith('data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n        // mask iframe srcdoc\n        if (tagName === 'IFRAME' && attributeName === 'srcdoc') {\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    return sanitizeIfLongDataUrl(attributeValue, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH);\n}\n//# sourceMappingURL=serializeAttribute.js.map","export function createSerializationStats() {\n    return {\n        cssText: {\n            count: 0,\n            max: 0,\n            sum: 0,\n        },\n        serializationDuration: {\n            count: 0,\n            max: 0,\n            sum: 0,\n        },\n    };\n}\nexport function updateSerializationStats(stats, metric, value) {\n    stats[metric].count += 1;\n    stats[metric].max = Math.max(stats[metric].max, value);\n    stats[metric].sum += value;\n}\nexport function aggregateSerializationStats(aggregateStats, stats) {\n    for (const metric of ['cssText', 'serializationDuration']) {\n        aggregateStats[metric].count += stats[metric].count;\n        aggregateStats[metric].max = Math.max(aggregateStats[metric].max, stats[metric].max);\n        aggregateStats[metric].sum += stats[metric].sum;\n    }\n}\n//# sourceMappingURL=serializationStats.js.map","import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { isSafari } from '@datadog/browser-core';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nimport { updateSerializationStats } from './serializationStats';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    const safeAttrs = {};\n    const tagName = getValidTagName(element.tagName);\n    const doc = element.ownerDocument;\n    for (let i = 0; i < element.attributes.length; i += 1) {\n        const attribute = element.attributes.item(i);\n        const attributeName = attribute.name;\n        const attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName, options.configuration);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        const formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        const optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => s.href === element.href);\n        const cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            updateSerializationStats(options.serializationContext.serializationStats, 'cssText', cssText.length);\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        const cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            updateSerializationStats(options.serializationContext.serializationStats, 'cssText', cssText.length);\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    const inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            delete safeAttrs.checked;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        const mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element only for full snapshot\n     */\n    let scrollTop;\n    let scrollLeft;\n    const serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop, scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                ({ scrollTop, scrollLeft } = serializationContext.elementsScrollPositions.get(element));\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\nexport function getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    let rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    const styleSheetCssText = Array.from(rules, isSafari() ? getCssRuleStringForSafari : getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleStringForSafari(rule) {\n    // Safari does not escape attribute selectors containing : properly\n    // https://bugs.webkit.org/show_bug.cgi?id=184604\n    if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n        // This regex replaces [foo:bar] by [foo\\\\:bar]\n        const escapeColon = /(\\[[\\w-]+[^\\\\])(:[^\\]]+\\])/g;\n        return rule.cssText.replace(escapeColon, '$1\\\\$2');\n    }\n    return getCssRuleString(rule);\n}\nfunction getCssRuleString(rule) {\n    // If it's an @import rule, try to inline sub-rules recursively with `getCssRulesString`. This\n    // operation can fail if the imported stylesheet is protected by CORS, in which case we fallback\n    // to the @import rule CSS text.\n    return (isCSSImportRule(rule) && getCssRulesString(rule.styleSheet)) || rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isNodeShadowRoot, hasChildNodes, forEachChildNodes, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, } from '@datadog/browser-rum-core';\nimport { NodeType } from '../../../types';\nimport { getValidTagName } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\nexport function serializeNodeWithId(node, parentNodePrivacyLevel, options) {\n    const serializedNode = serializeNode(node, parentNodePrivacyLevel, options);\n    if (!serializedNode) {\n        return null;\n    }\n    const id = options.scope.nodeIds.assign(node);\n    const serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nexport function serializeChildNodes(node, parentNodePrivacyLevel, options) {\n    const result = [];\n    forEachChildNodes(node, (childNode) => {\n        const serializedChildNode = serializeNodeWithId(childNode, parentNodePrivacyLevel, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nfunction serializeNode(node, parentNodePrivacyLevel, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, parentNodePrivacyLevel, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, parentNodePrivacyLevel, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, parentNodePrivacyLevel, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, parentNodePrivacyLevel);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, parentNodePrivacyLevel, options) {\n    return {\n        type: NodeType.Document,\n        childNodes: serializeChildNodes(document, parentNodePrivacyLevel, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentFragmentNode(element, parentNodePrivacyLevel, options) {\n    const isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: serializeChildNodes(element, parentNodePrivacyLevel, options),\n        isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nfunction serializeElementNode(element, parentNodePrivacyLevel, options) {\n    const tagName = getValidTagName(element.tagName);\n    const isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        const { width, height } = element.getBoundingClientRect();\n        return {\n            type: NodeType.Element,\n            tagName,\n            attributes: {\n                rr_width: `${width}px`,\n                rr_height: `${height}px`,\n                [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_HIDDEN,\n            },\n            childNodes: [],\n            isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    const attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    let childNodes = [];\n    if (hasChildNodes(element) &&\n        // Do not serialize style children as the css rules are already in the _cssText attribute\n        tagName !== 'style') {\n        childNodes = serializeChildNodes(element, nodePrivacyLevel, options);\n    }\n    return {\n        type: NodeType.Element,\n        tagName,\n        attributes,\n        childNodes,\n        isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, parentNodePrivacyLevel) {\n    const textContent = getTextContent(textNode, parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { elapsed, timeStampNow } from '@datadog/browser-core';\nimport { serializeNodeWithId } from './serializeNode';\nimport { updateSerializationStats } from './serializationStats';\nexport function serializeDocument(document, configuration, scope, serializationContext) {\n    const serializationStart = timeStampNow();\n    const serializedNode = serializeNodeWithId(document, configuration.defaultPrivacyLevel, {\n        serializationContext,\n        configuration,\n        scope,\n    });\n    updateSerializationStats(serializationContext.serializationStats, 'serializationDuration', elapsed(serializationStart, timeStampNow()));\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializedNode;\n}\n//# sourceMappingURL=serializeDocument.js.map","import { instrumentSetter, addEventListeners, noop } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getElementInputValue } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackInput(configuration, scope, inputCb, target = document) {\n    const defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    const lastInputStateMap = new WeakMap();\n    const isShadowRoot = target !== document;\n    const { stop: stopEventListeners } = addEventListeners(configuration, target, \n    // The 'input' event bubbles across shadow roots, so we don't have to listen for it on shadow\n    // roots since it will be handled by the event listener that we did add to the document. Only\n    // the 'change' event is blocked and needs to be handled on shadow roots.\n    isShadowRoot ? [\"change\" /* DOM_EVENT.CHANGE */] : [\"input\" /* DOM_EVENT.INPUT */, \"change\" /* DOM_EVENT.CHANGE */], (event) => {\n        const target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    });\n    let stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        const instrumentationStoppers = [\n            instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n        ];\n        stopPropertySetterInstrumentation = () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return {\n        stop: () => {\n            stopPropertySetterInstrumentation();\n            stopEventListeners();\n        },\n    };\n    function onElementChange(target) {\n        const nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        const type = target.type;\n        let inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            const value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState, scope);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        const name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            document.querySelectorAll(`input[type=\"radio\"][name=\"${CSS.escape(name)}\"]`).forEach((el) => {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false }, scope);\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState, scope) {\n        const id = scope.nodeIds.get(target);\n        if (id === undefined) {\n            return;\n        }\n        const lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            inputCb(assembleIncrementalSnapshot(IncrementalSource.Input, {\n                id,\n                ...inputState,\n            }));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.js.map","import { noop, throttle, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nconst MUTATION_PROCESS_MAX_DELAY = 100;\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport const MUTATION_PROCESS_MIN_DELAY = 16;\nexport function createMutationBatch(processMutationBatch) {\n    let cancelScheduledFlush = noop;\n    let pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n        leading: false,\n    });\n    return {\n        addMutations: (mutations) => {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push(...mutations);\n        },\n        flush,\n        stop: () => {\n            cancelScheduledFlush();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { elapsed, monitor, noop, timeStampNow } from '@datadog/browser-core';\nimport { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getElementInputValue, serializeNodeWithId, serializeAttribute, createSerializationStats, updateSerializationStats, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\nimport { assembleIncrementalSnapshot } from '../assembly';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function trackMutation(mutationCallback, configuration, scope, shadowRootsController, target) {\n    const MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    const mutationBatch = createMutationBatch((mutations) => {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, scope, shadowRootsController);\n    });\n    const observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: () => {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: () => {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, scope, shadowRootsController) {\n    const nodePrivacyLevelCache = new Map();\n    mutations\n        .filter((mutation) => mutation.type === 'childList')\n        .forEach((mutation) => {\n        mutation.removedNodes.forEach((removedNode) => {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    const filteredMutations = mutations.filter((mutation) => mutation.target.isConnected &&\n        scope.nodeIds.areAssignedForNodeAndAncestors(mutation.target) &&\n        getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !==\n            NodePrivacyLevel.HIDDEN);\n    const serializationStats = createSerializationStats();\n    const { adds, removes, hasBeenSerialized } = processChildListMutations(filteredMutations.filter((mutation) => mutation.type === 'childList'), configuration, scope, serializationStats, shadowRootsController, nodePrivacyLevelCache);\n    const texts = processCharacterDataMutations(filteredMutations.filter((mutation) => mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)), configuration, scope, nodePrivacyLevelCache);\n    const attributes = processAttributesMutations(filteredMutations.filter((mutation) => mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)), configuration, scope, nodePrivacyLevelCache);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback(assembleIncrementalSnapshot(IncrementalSource.Mutation, { adds, removes, texts, attributes }), serializationStats);\n}\nfunction processChildListMutations(mutations, configuration, scope, serializationStats, shadowRootsController, nodePrivacyLevelCache) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    const addedAndMovedNodes = new Set();\n    const removedNodes = new Map();\n    for (const mutation of mutations) {\n        mutation.addedNodes.forEach((node) => {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach((node) => {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    const sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    const serializedNodeIds = new Set();\n    const serializationContext = {\n        status: 2 /* SerializationContextStatus.MUTATION */,\n        serializationStats,\n        shadowRootsController,\n    };\n    const addedNodeMutations = [];\n    for (const node of sortedAddedAndMovedNodes) {\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        const serializationStart = timeStampNow();\n        const serializedNode = serializeNodeWithId(node, parentNodePrivacyLevel, {\n            serializedNodeIds,\n            serializationContext,\n            configuration,\n            scope,\n        });\n        updateSerializationStats(serializationStats, 'serializationDuration', elapsed(serializationStart, timeStampNow()));\n        if (!serializedNode) {\n            continue;\n        }\n        const parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: scope.nodeIds.get(parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    const removedNodeMutations = [];\n    removedNodes.forEach((parent, node) => {\n        const parentId = scope.nodeIds.get(parent);\n        const id = scope.nodeIds.get(node);\n        if (parentId !== undefined && id !== undefined) {\n            removedNodeMutations.push({ parentId, id });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        const id = scope.nodeIds.get(node);\n        return id !== undefined && serializedNodeIds.has(id);\n    }\n    function getNextSibling(node) {\n        let nextSibling = node.nextSibling;\n        while (nextSibling) {\n            const id = scope.nodeIds.get(nextSibling);\n            if (id !== undefined) {\n                return id;\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, configuration, scope, nodePrivacyLevelCache) {\n    var _a;\n    const textMutations = [];\n    // Deduplicate mutations based on their target node\n    const handledNodes = new Set();\n    const filteredMutations = mutations.filter((mutation) => {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (const mutation of filteredMutations) {\n        const value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        const id = scope.nodeIds.get(mutation.target);\n        if (id === undefined) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id,\n            value: (_a = getTextContent(mutation.target, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, configuration, scope, nodePrivacyLevelCache) {\n    const attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    const handledElements = new Map();\n    const filteredMutations = mutations.filter((mutation) => {\n        const handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes && handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    const emittedMutations = new Map();\n    for (const mutation of filteredMutations) {\n        const uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        const id = scope.nodeIds.get(mutation.target);\n        if (id === undefined) {\n            continue;\n        }\n        const privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        const attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        let transformedValue;\n        if (mutation.attributeName === 'value') {\n            const inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        let emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = { id, attributes: {} };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort((a, b) => {\n        const position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    forEachChildNodes(removedNode, (childNode) => traverseRemovedShadowDom(childNode, shadowDomRemovedCallback));\n}\n//# sourceMappingURL=trackMutation.js.map","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport const initShadowRootsController = (configuration, scope, callback, elementsScrollPositions) => {\n    const controllerByShadowRoot = new Map();\n    const shadowRootsController = {\n        addShadowRoot: (shadowRoot) => {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            const mutationTracker = trackMutation(callback, configuration, scope, shadowRootsController, shadowRoot);\n            // The change event does not bubble up across the shadow root, we have to listen on the shadow root\n            const inputTracker = trackInput(configuration, scope, callback, shadowRoot);\n            // The scroll event does not bubble up across the shadow root, we have to listen on the shadow root\n            const scrollTracker = trackScroll(configuration, scope, callback, elementsScrollPositions, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: () => mutationTracker.flush(),\n                stop: () => {\n                    mutationTracker.stop();\n                    inputTracker.stop();\n                    scrollTracker.stop();\n                },\n            });\n        },\n        removeShadowRoot: (shadowRoot) => {\n            const entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: () => {\n            controllerByShadowRoot.forEach(({ stop }) => stop());\n        },\n        flush: () => {\n            controllerByShadowRoot.forEach(({ flush }) => flush());\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { sendToExtension } from '@datadog/browser-core';\nimport * as replayStats from '../replayStats';\nimport { trackFocus, trackFrustration, trackInput, trackMediaInteraction, trackMouseInteraction, trackMove, trackMutation, trackScroll, trackStyleSheet, trackViewEnd, trackViewportResize, trackVisualViewportResize, } from './trackers';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nimport { startFullSnapshots } from './startFullSnapshots';\nimport { initRecordIds } from './recordIds';\nimport { createSerializationScope } from './serialization';\nimport { createNodeIds } from './nodeIds';\nexport function record(options) {\n    const { emit, configuration, lifeCycle } = options;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    const emitAndComputeStats = (record, stats) => {\n        emit(record, stats);\n        sendToExtension('record', { record });\n        const view = options.viewHistory.findView();\n        replayStats.addRecord(view.id);\n    };\n    const elementsScrollPositions = createElementsScrollPositions();\n    const scope = createSerializationScope(createNodeIds());\n    const shadowRootsController = initShadowRootsController(configuration, scope, emitAndComputeStats, elementsScrollPositions);\n    const { stop: stopFullSnapshots } = startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, scope, flushMutations, emitAndComputeStats);\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    const recordIds = initRecordIds();\n    const mutationTracker = trackMutation(emitAndComputeStats, configuration, scope, shadowRootsController, document);\n    const trackers = [\n        mutationTracker,\n        trackMove(configuration, scope, emitAndComputeStats),\n        trackMouseInteraction(configuration, scope, emitAndComputeStats, recordIds),\n        trackScroll(configuration, scope, emitAndComputeStats, elementsScrollPositions, document),\n        trackViewportResize(configuration, emitAndComputeStats),\n        trackInput(configuration, scope, emitAndComputeStats),\n        trackMediaInteraction(configuration, scope, emitAndComputeStats),\n        trackStyleSheet(scope, emitAndComputeStats),\n        trackFocus(configuration, emitAndComputeStats),\n        trackVisualViewportResize(configuration, emitAndComputeStats),\n        trackFrustration(lifeCycle, emitAndComputeStats, recordIds),\n        trackViewEnd(lifeCycle, (viewEndRecord) => {\n            flushMutations();\n            emitAndComputeStats(viewEndRecord);\n        }),\n    ];\n    return {\n        stop: () => {\n            shadowRootsController.stop();\n            trackers.forEach((tracker) => tracker.stop());\n            stopFullSnapshots();\n        },\n        flushMutations,\n        shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    const scrollPositionsByElement = new WeakMap();\n    return {\n        set(element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get(element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has(element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","export function createSerializationScope(nodeIds) {\n    return { nodeIds };\n}\n//# sourceMappingURL=serializationScope.js.map","import { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nexport function createNodeIds() {\n    const nodeIds = new WeakMap();\n    let nextNodeId = 1 /* NodeIdConstants.FIRST_ID */;\n    const get = (node) => nodeIds.get(node);\n    return {\n        assign: (node) => {\n            // Try to reuse any existing id.\n            let nodeId = get(node);\n            if (nodeId === undefined) {\n                nodeId = nextNodeId++;\n                nodeIds.set(node, nodeId);\n            }\n            return nodeId;\n        },\n        get,\n        areAssignedForNodeAndAncestors: (node) => {\n            let current = node;\n            while (current) {\n                if (get(current) === undefined && !isNodeShadowRoot(current)) {\n                    return false;\n                }\n                current = getParentNode(current);\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=nodeIds.js.map","import { getScrollX, getScrollY, getViewportDimension } from '@datadog/browser-rum-core';\nimport { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { createSerializationStats, serializeDocument } from './serialization';\nimport { getVisualViewport } from './viewports';\nexport function startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, scope, flushMutations, emit) {\n    const takeFullSnapshot = (timestamp, status) => {\n        const { width, height } = getViewportDimension();\n        emit({\n            data: {\n                height,\n                href: window.location.href,\n                width,\n            },\n            type: RecordType.Meta,\n            timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp,\n        });\n        const serializationStats = createSerializationStats();\n        const serializationContext = {\n            status,\n            elementsScrollPositions,\n            serializationStats,\n            shadowRootsController,\n        };\n        emit({\n            data: {\n                node: serializeDocument(document, configuration, scope, serializationContext),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp,\n        }, serializationStats);\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp,\n            });\n        }\n    };\n    takeFullSnapshot(timeStampNow(), 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */);\n    const { unsubscribe } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, (view) => {\n        flushMutations();\n        takeFullSnapshot(view.startClocks.timeStamp, 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */);\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\n//# sourceMappingURL=startFullSnapshots.js.map","export function initRecordIds() {\n    const recordIds = new WeakMap();\n    let nextId = 1;\n    return {\n        getIdForEvent(event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nimport { aggregateSerializationStats, createSerializationStats } from '../record';\nexport function createSegment({ context, creationReason, encoder, }) {\n    let encodedBytesCount = 0;\n    const viewId = context.view.id;\n    const indexInView = replayStats.getSegmentsCount(viewId);\n    const metadata = {\n        start: Infinity,\n        end: -Infinity,\n        creation_reason: creationReason,\n        records_count: 0,\n        has_full_snapshot: false,\n        index_in_view: indexInView,\n        source: 'browser',\n        ...context,\n    };\n    const serializationStats = createSerializationStats();\n    replayStats.addSegment(viewId);\n    function addRecord(record, stats, callback) {\n        metadata.start = Math.min(metadata.start, record.timestamp);\n        metadata.end = Math.max(metadata.end, record.timestamp);\n        metadata.records_count += 1;\n        metadata.has_full_snapshot || (metadata.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        if (stats) {\n            aggregateSerializationStats(serializationStats, stats);\n        }\n        const prefix = encoder.isEmpty ? '{\"records\":[' : ',';\n        encoder.write(prefix + JSON.stringify(record), (additionalEncodedBytesCount) => {\n            encodedBytesCount += additionalEncodedBytesCount;\n            callback(encodedBytesCount);\n        });\n    }\n    function flush(callback) {\n        if (encoder.isEmpty) {\n            throw new Error('Empty segment flushed');\n        }\n        encoder.write(`],${JSON.stringify(metadata).slice(1)}\\n`);\n        encoder.finish((encoderResult) => {\n            replayStats.addWroteData(metadata.view.id, encoderResult.rawBytesCount);\n            callback(metadata, serializationStats, encoderResult);\n        });\n    }\n    return { addRecord, flush };\n}\n//# sourceMappingURL=segment.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { createSegment } from './segment';\nexport const SEGMENT_DURATION_LIMIT = 5 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport let SEGMENT_BYTES_LIMIT = 60000;\nexport function startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, httpRequest, encoder) {\n    return doStartSegmentCollection(lifeCycle, () => computeSegmentContext(configuration.applicationId, sessionManager, viewHistory), httpRequest, encoder);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, encoder) {\n    let state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    const { unsubscribe: unsubscribeViewCreated } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, () => {\n        flushSegment('view_change');\n    });\n    const { unsubscribe: unsubscribePageMayExit } = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, (pageMayExitEvent) => {\n        flushSegment(pageMayExitEvent.reason);\n    });\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush((metadata, stats, encoderResult) => {\n                const payload = buildReplayPayload(encoderResult.output, metadata, stats, encoderResult.rawBytesCount);\n                if (isPageExitReason(flushReason)) {\n                    httpRequest.sendOnExit(payload);\n                }\n                else {\n                    httpRequest.send(payload);\n                }\n            });\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* SegmentCollectionStatus.Stopped */,\n            };\n        }\n    }\n    return {\n        addRecord: (record, stats) => {\n            if (state.status === 2 /* SegmentCollectionStatus.Stopped */) {\n                return;\n            }\n            if (state.status === 0 /* SegmentCollectionStatus.WaitingForInitialRecord */) {\n                const context = getSegmentContext();\n                if (!context) {\n                    return;\n                }\n                state = {\n                    status: 1 /* SegmentCollectionStatus.SegmentPending */,\n                    segment: createSegment({ encoder, context, creationReason: state.nextSegmentCreationReason }),\n                    expirationTimeoutId: setTimeout(() => {\n                        flushSegment('segment_duration_limit');\n                    }, SEGMENT_DURATION_LIMIT),\n                };\n            }\n            state.segment.addRecord(record, stats, (encodedBytesCount) => {\n                if (encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        stop: () => {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageMayExit();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewHistory) {\n    const session = sessionManager.findTrackedSession();\n    const viewContext = viewHistory.findView();\n    if (!session || !viewContext) {\n        return undefined;\n    }\n    return {\n        application: {\n            id: applicationId,\n        },\n        session: {\n            id: session.id,\n        },\n        view: {\n            id: viewContext.id,\n        },\n    };\n}\nexport function setSegmentBytesLimit(newSegmentBytesLimit = 60000) {\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","export function buildReplayPayload(data, metadata, stats, rawSegmentBytesCount) {\n    const formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), `${metadata.session.id}-${metadata.start}`);\n    const metadataAndSegmentSizes = {\n        raw_segment_size: rawSegmentBytesCount,\n        compressed_segment_size: data.byteLength,\n        ...metadata,\n    };\n    const serializedMetadataAndSegmentSizes = JSON.stringify(metadataAndSegmentSizes);\n    formData.append('event', new Blob([serializedMetadataAndSegmentSizes], { type: 'application/json' }));\n    return {\n        data: formData,\n        bytesCount: data.byteLength,\n        cssText: stats.cssText,\n        isFullSnapshot: metadata.index_in_view === 0,\n        rawSize: rawSegmentBytesCount,\n        recordCount: metadata.records_count,\n        serializationDuration: stats.serializationDuration,\n    };\n}\n//# sourceMappingURL=buildReplayPayload.js.map","import { createHttpRequest, addTelemetryDebug, canUseEventBridge } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT, startSegmentTelemetry } from '../domain/segmentCollection';\nimport { startRecordBridge } from '../domain/startRecordBridge';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewHistory, encoder, telemetry, httpRequest) {\n    const cleanupTasks = [];\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        // monitor-until: forever, to keep an eye on the errors reported to customers\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const replayRequest = httpRequest || createHttpRequest([configuration.sessionReplayEndpointBuilder], SEGMENT_BYTES_LIMIT, reportError);\n    let addRecord;\n    if (!canUseEventBridge()) {\n        const segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);\n        addRecord = segmentCollection.addRecord;\n        cleanupTasks.push(segmentCollection.stop);\n        const segmentTelemetry = startSegmentTelemetry(telemetry, replayRequest.observable);\n        cleanupTasks.push(segmentTelemetry.stop);\n    }\n    else {\n        ;\n        ({ addRecord } = startRecordBridge(viewHistory));\n    }\n    const { stop: stopRecording } = record({\n        emit: addRecord,\n        configuration,\n        lifeCycle,\n        viewHistory,\n    });\n    cleanupTasks.push(stopRecording);\n    return {\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRecordBridge(viewHistory) {\n    const bridge = getEventBridge();\n    return {\n        addRecord: (record) => {\n            // Get the current active view, not at the time of the record, aligning with the segment logic.\n            // This approach could potentially associate the record to an incorrect view, in case the record date is in the past (e.g. frustration records).\n            // However the risk is minimal. We could address the issue when potential negative impact are identified.\n            const view = viewHistory.findView();\n            bridge.send('record', record, view.id);\n        },\n    };\n}\n//# sourceMappingURL=startRecordBridge.js.map","import { addTelemetryMetrics, noop } from '@datadog/browser-core';\nexport function startSegmentTelemetry(telemetry, requestObservable) {\n    if (!telemetry.metricsEnabled) {\n        return { stop: noop };\n    }\n    const { unsubscribe } = requestObservable.subscribe((requestEvent) => {\n        if (requestEvent.type === 'failure' ||\n            requestEvent.type === 'queue-full' ||\n            (requestEvent.type === 'success' && requestEvent.payload.isFullSnapshot)) {\n            const metrics = createSegmentMetrics(requestEvent.type, requestEvent.bandwidth, requestEvent.payload);\n            // monitor-until: 2026-07-01\n            addTelemetryMetrics(\"Segment network request metrics\" /* TelemetryMetrics.SEGMENT_METRICS_TELEMETRY_NAME */, { metrics });\n        }\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\nfunction createSegmentMetrics(result, bandwidthStats, payload) {\n    return {\n        cssText: {\n            count: payload.cssText.count,\n            max: payload.cssText.max,\n            sum: payload.cssText.sum,\n        },\n        isFullSnapshot: payload.isFullSnapshot,\n        ongoingRequests: {\n            count: bandwidthStats.ongoingRequestCount,\n            totalSize: bandwidthStats.ongoingByteCount,\n        },\n        recordCount: payload.recordCount,\n        result,\n        serializationDuration: {\n            count: payload.serializationDuration.count,\n            max: payload.serializationDuration.max,\n            sum: payload.serializationDuration.sum,\n        },\n        size: {\n            compressed: payload.bytesCount,\n            raw: payload.rawSize,\n        },\n    };\n}\n//# sourceMappingURL=startSegmentTelemetry.js.map","/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\nimport { objectHasValue } from './utils/objectUtils';\n// eslint-disable-next-line no-restricted-syntax\nexport var ExperimentalFeature;\n(function (ExperimentalFeature) {\n    ExperimentalFeature[\"TRACK_INTAKE_REQUESTS\"] = \"track_intake_requests\";\n    ExperimentalFeature[\"USE_TREE_WALKER_FOR_ACTION_NAME\"] = \"use_tree_walker_for_action_name\";\n    ExperimentalFeature[\"FEATURE_OPERATION_VITAL\"] = \"feature_operation_vital\";\n    ExperimentalFeature[\"SHORT_SESSION_INVESTIGATION\"] = \"short_session_investigation\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nconst enabledExperimentalFeatures = new Set();\nexport function initFeatureFlags(enableExperimentalFeatures) {\n    if (Array.isArray(enableExperimentalFeatures)) {\n        addExperimentalFeatures(enableExperimentalFeatures.filter((flag) => objectHasValue(ExperimentalFeature, flag)));\n    }\n}\nexport function addExperimentalFeatures(enabledFeatures) {\n    enabledFeatures.forEach((flag) => {\n        enabledExperimentalFeatures.add(flag);\n    });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n    return enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n    enabledExperimentalFeatures.clear();\n}\nexport function getExperimentalFeatures() {\n    return enabledExperimentalFeatures;\n}\n//# sourceMappingURL=experimentalFeatures.js.map","/**\n * Return true if the draw is successful\n *\n * @param threshold - Threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n    return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n    return +num.toFixed(decimals);\n}\nexport function isPercentage(value) {\n    return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n    return typeof value === 'number';\n}\n//# sourceMappingURL=numberUtils.js.map","import { isNumber, round } from './numberUtils';\nexport const ONE_SECOND = 1000;\nexport const ONE_MINUTE = 60 * ONE_SECOND;\nexport const ONE_HOUR = 60 * ONE_MINUTE;\nexport const ONE_DAY = 24 * ONE_HOUR;\nexport const ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n    return { relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nexport function timeStampToClocks(timeStamp) {\n    return { relative: getRelativeTime(timeStamp), timeStamp };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    const correctedOrigin = (dateNow() - performance.now());\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        return Math.round(addDuration(correctedOrigin, relativeTime));\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now()));\n}\nexport function toServerDuration(duration) {\n    if (!isNumber(duration)) {\n        return duration;\n    }\n    return round(duration * 1e6, 0);\n}\nexport function dateNow() {\n    // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n    // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n    // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n    // case ourselves.\n    // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n    return new Date().getTime();\n}\nexport function timeStampNow() {\n    return dateNow();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { relative: relativeNow(), timeStamp: timeStampNow() };\n}\nexport function clocksOrigin() {\n    return { relative: 0, timeStamp: getNavigationStart() };\n}\nexport function elapsed(start, end) {\n    return (end - start);\n}\nexport function addDuration(a, b) {\n    return a + b;\n}\n// Get the time since the navigation was started.\nexport function getRelativeTime(timestamp) {\n    return (timestamp - getNavigationStart());\n}\nexport function getTimeStamp(relativeTime) {\n    return Math.round(addDuration(getNavigationStart(), relativeTime));\n}\nexport function looksLikeRelativeTime(time) {\n    return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nlet navigationStart;\n/**\n * Notes: this does not use `performance.timeOrigin` because:\n * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,\n * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)\n * - It is not supported in Safari <15\n */\nfunction getNavigationStart() {\n    var _a, _b;\n    if (navigationStart === undefined) {\n        // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin\n        navigationStart = ((_b = (_a = performance.timing) === null || _a === void 0 ? void 0 : _a.navigationStart) !== null && _b !== void 0 ? _b : performance.timeOrigin);\n    }\n    return navigationStart;\n}\n//# sourceMappingURL=timeUtils.js.map","import { Observable } from '../tools/observable';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { addEventListeners, addEventListener } from './addEventListener';\nexport const PageExitReason = {\n    HIDDEN: 'visibility_hidden',\n    UNLOADING: 'before_unload',\n    PAGEHIDE: 'page_hide',\n    FROZEN: 'page_frozen',\n};\nexport function createPageMayExitObservable(configuration) {\n    return new Observable((observable) => {\n        const { stop: stopListeners } = addEventListeners(configuration, window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */], (event) => {\n            if (event.type === \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */ && document.visibilityState === 'hidden') {\n                /**\n                 * Only event that guarantee to fire on mobile devices when the page transitions to background state\n                 * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n                 */\n                observable.notify({ reason: PageExitReason.HIDDEN });\n            }\n            else if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n                /**\n                 * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n                 * Allow to collect events happening between hidden and frozen state.\n                 */\n                observable.notify({ reason: PageExitReason.FROZEN });\n            }\n        }, { capture: true });\n        const stopBeforeUnloadListener = addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, () => {\n            observable.notify({ reason: PageExitReason.UNLOADING });\n        }).stop;\n        return () => {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n}\nexport function isPageExitReason(reason) {\n    return objectValues(PageExitReason).includes(reason);\n}\n//# sourceMappingURL=pageMayExitObservable.js.map","export function findLast(array, predicate) {\n    for (let i = array.length - 1; i >= 0; i -= 1) {\n        const item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\n// Keep the following wrapper functions as it can be mangled and will result in smaller bundle size that using\n// the native Object.values and Object.entries directly\nexport function objectValues(object) {\n    return Object.values(object);\n}\nexport function objectEntries(object) {\n    return Object.entries(object);\n}\n//# sourceMappingURL=polyfills.js.map","import { DOCS_ORIGIN, MORE_DETAILS, display } from '../tools/display';\nexport const TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n    const { env, service, version, datacenter, sdkVersion, variant } = configuration;\n    const tags = [buildTag('sdk_version', sdkVersion !== null && sdkVersion !== void 0 ? sdkVersion : \"6.22.0\")];\n    if (env) {\n        tags.push(buildTag('env', env));\n    }\n    if (service) {\n        tags.push(buildTag('service', service));\n    }\n    if (version) {\n        tags.push(buildTag('version', version));\n    }\n    if (datacenter) {\n        tags.push(buildTag('datacenter', datacenter));\n    }\n    if (variant) {\n        tags.push(buildTag('variant', variant));\n    }\n    return tags;\n}\nexport function buildTag(key, rawValue) {\n    // See https://docs.datadoghq.com/getting_started/tagging/#defining-tags for tags syntax. Note\n    // that the backend may not follow the exact same rules, so we only want to display an informal\n    // warning.\n    const tag = rawValue ? `${key}:${rawValue}` : key;\n    if (tag.length > TAG_SIZE_LIMIT || hasForbiddenCharacters(tag)) {\n        display.warn(`Tag ${tag} doesn't meet tag requirements and will be sanitized. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/tagging/#defining-tags`);\n    }\n    // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted\n    // by forging a value containing commas.\n    return sanitizeTag(tag);\n}\nexport function sanitizeTag(tag) {\n    return tag.replace(/,/g, '_');\n}\nfunction hasForbiddenCharacters(rawValue) {\n    // Unicode property escapes is not supported in all browsers, so we use a try/catch.\n    // Todo: Remove the try/catch when dropping support for Chrome 63 and Firefox 67\n    // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#browser_compatibility\n    if (!supportUnicodePropertyEscapes()) {\n        return false;\n    }\n    // We use the Unicode property escapes to match any character that is a letter including other languages like Chinese, Japanese, etc.\n    // p{Ll} matches a lowercase letter.\n    // p{Lo} matches a letter that is neither uppercase nor lowercase (ex: Japanese characters).\n    // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#unicode_property_escapes_vs._character_classes\n    return new RegExp('[^\\\\p{Ll}\\\\p{Lo}0-9_:./-]', 'u').test(rawValue);\n}\nexport function supportUnicodePropertyEscapes() {\n    try {\n        new RegExp('[\\\\p{Ll}]', 'u');\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n//# sourceMappingURL=tags.js.map","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import { addEventListener, concatBuffers } from '@datadog/browser-core';\nexport function createDeflateEncoder(configuration, worker, streamId) {\n    let rawBytesCount = 0;\n    let compressedData = [];\n    let compressedDataTrailer;\n    let isEmpty = true;\n    let nextWriteActionId = 0;\n    const pendingWriteActions = [];\n    const { stop: removeMessageListener } = addEventListener(configuration, worker, 'message', ({ data: workerResponse }) => {\n        if (workerResponse.type !== 'wrote' || workerResponse.streamId !== streamId) {\n            return;\n        }\n        const nextPendingAction = pendingWriteActions[0];\n        if (nextPendingAction) {\n            if (nextPendingAction.id === workerResponse.id) {\n                pendingWriteActions.shift();\n                rawBytesCount += workerResponse.additionalBytesCount;\n                compressedData.push(workerResponse.result);\n                compressedDataTrailer = workerResponse.trailer;\n                if (nextPendingAction.writeCallback) {\n                    nextPendingAction.writeCallback(workerResponse.result.byteLength);\n                }\n                else if (nextPendingAction.finishCallback) {\n                    nextPendingAction.finishCallback();\n                }\n            }\n            else if (nextPendingAction.id < workerResponse.id) {\n                // Worker responses received out of order\n                removeMessageListener();\n            }\n        }\n    });\n    function consumeResult() {\n        const output = compressedData.length === 0 ? new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer));\n        const result = {\n            rawBytesCount,\n            output,\n            outputBytesCount: output.byteLength,\n            encoding: 'deflate',\n        };\n        rawBytesCount = 0;\n        compressedData = [];\n        return result;\n    }\n    function sendResetIfNeeded() {\n        if (!isEmpty) {\n            worker.postMessage({\n                action: 'reset',\n                streamId,\n            });\n            isEmpty = true;\n        }\n    }\n    return {\n        isAsync: true,\n        get isEmpty() {\n            return isEmpty;\n        },\n        write(data, callback) {\n            worker.postMessage({\n                action: 'write',\n                id: nextWriteActionId,\n                data,\n                streamId,\n            });\n            pendingWriteActions.push({\n                id: nextWriteActionId,\n                writeCallback: callback,\n                data,\n            });\n            isEmpty = false;\n            nextWriteActionId += 1;\n        },\n        finish(callback) {\n            sendResetIfNeeded();\n            if (!pendingWriteActions.length) {\n                callback(consumeResult());\n            }\n            else {\n                // Make sure we do not call any write callback\n                pendingWriteActions.forEach((pendingWriteAction) => {\n                    delete pendingWriteAction.writeCallback;\n                });\n                // Wait for the last action to finish before calling the finish callback\n                pendingWriteActions[pendingWriteActions.length - 1].finishCallback = () => callback(consumeResult());\n            }\n        },\n        finishSync() {\n            sendResetIfNeeded();\n            const pendingData = pendingWriteActions.map((pendingWriteAction) => pendingWriteAction.data).join('');\n            // Ignore all pending write actions responses from the worker\n            pendingWriteActions.length = 0;\n            return { ...consumeResult(), pendingData };\n        },\n        estimateEncodedBytesCount(data) {\n            // This is a rough estimation of the data size once it'll be encoded by deflate. We observed\n            // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but\n            // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce\n            // requests of the expected size.\n            return data.length / 8;\n        },\n        stop() {\n            removeMessageListener();\n        },\n    };\n}\n//# sourceMappingURL=deflateEncoder.js.map","import { addTelemetryError, display, DOCS_ORIGIN } from '@datadog/browser-core';\nexport function reportScriptLoadingError({ configuredUrl, error, source, scriptType, }) {\n    display.error(`${source} failed to start: an error occurred while initializing the ${scriptType}:`, error);\n    if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n        let baseMessage;\n        if (configuredUrl) {\n            baseMessage = `Please make sure the ${scriptType} URL ${configuredUrl} is correct and CSP is correctly configured.`;\n        }\n        else {\n            baseMessage = 'Please make sure CSP is correctly configured.';\n        }\n        display.error(`${baseMessage} See documentation at ${DOCS_ORIGIN}/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay`);\n    }\n    else if (scriptType === 'worker') {\n        addTelemetryError(error);\n    }\n}\nfunction isMessageCspRelated(message) {\n    return (message.includes('Content Security Policy') ||\n        // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n        message.includes(\"requires 'TrustedScriptURL'\"));\n}\n//# sourceMappingURL=scriptLoadingError.js.map","import { addTelemetryError, display, addEventListener, setTimeout, ONE_SECOND } from '@datadog/browser-core';\nimport { reportScriptLoadingError } from '../scriptLoadingError';\nexport const INITIALIZATION_TIME_OUT_DELAY = 30 * ONE_SECOND;\nfunction createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"(()=>{function t(t){const e=t.reduce((t,e)=>t+e.length,0),a=new Uint8Array(e);let n=0;for(const e of t)a.set(e,n),n+=e.length;return a}function e(t){for(var e=t.length;--e>=0;)t[e]=0}var a=new Uint8Array([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]),n=new Uint8Array([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]),r=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),i=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=Array(576);e(s);var h=Array(60);e(h);var l=Array(512);e(l);var _=Array(256);e(_);var o=Array(29);e(o);var d,u,f,c=Array(30);function p(t,e,a,n,r){this.static_tree=t,this.extra_bits=e,this.extra_base=a,this.elems=n,this.max_length=r,this.has_stree=t&&t.length}function g(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}e(c);var v=function(t){return t<256?l[t]:l[256+(t>>>7)]},w=function(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},m=function(t,e,a){t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,w(t,t.bi_buf),t.bi_buf=e>>16-t.bi_valid,t.bi_valid+=a-16):(t.bi_buf|=e<<t.bi_valid&65535,t.bi_valid+=a)},b=function(t,e,a){m(t,a[2*e],a[2*e+1])},y=function(t,e){var a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},z=function(t,e,a){var n,r,i=Array(16),s=0;for(n=1;n<=15;n++)i[n]=s=s+a[n-1]<<1;for(r=0;r<=e;r++){var h=t[2*r+1];0!==h&&(t[2*r]=y(i[h]++,h))}},k=function(t){var e;for(e=0;e<286;e++)t.dyn_ltree[2*e]=0;for(e=0;e<30;e++)t.dyn_dtree[2*e]=0;for(e=0;e<19;e++)t.bl_tree[2*e]=0;t.dyn_ltree[512]=1,t.opt_len=t.static_len=0,t.last_lit=t.matches=0},x=function(t){t.bi_valid>8?w(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},A=function(t,e,a,n){var r=2*e,i=2*a;return t[r]<t[i]||t[r]===t[i]&&n[e]<=n[a]},U=function(t,e,a){for(var n=t.heap[a],r=a<<1;r<=t.heap_len&&(r<t.heap_len&&A(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!A(e,n,t.heap[r],t.depth));)t.heap[a]=t.heap[r],a=r,r<<=1;t.heap[a]=n},B=function(t,e,r){var i,s,h,l,d=0;if(0!==t.last_lit)do{i=t.pending_buf[t.d_buf+2*d]<<8|t.pending_buf[t.d_buf+2*d+1],s=t.pending_buf[t.l_buf+d],d++,0===i?b(t,s,e):(h=_[s],b(t,h+256+1,e),0!==(l=a[h])&&(s-=o[h],m(t,s,l)),i--,h=v(i),b(t,h,r),0!==(l=n[h])&&(i-=c[h],m(t,i,l)))}while(d<t.last_lit);b(t,256,e)},I=function(t,e){var a,n,r,i=e.dyn_tree,s=e.stat_desc.static_tree,h=e.stat_desc.has_stree,l=e.stat_desc.elems,_=-1;for(t.heap_len=0,t.heap_max=573,a=0;a<l;a++)0!==i[2*a]?(t.heap[++t.heap_len]=_=a,t.depth[a]=0):i[2*a+1]=0;for(;t.heap_len<2;)i[2*(r=t.heap[++t.heap_len]=_<2?++_:0)]=1,t.depth[r]=0,t.opt_len--,h&&(t.static_len-=s[2*r+1]);for(e.max_code=_,a=t.heap_len>>1;a>=1;a--)U(t,i,a);r=l;do{a=t.heap[1],t.heap[1]=t.heap[t.heap_len--],U(t,i,1),n=t.heap[1],t.heap[--t.heap_max]=a,t.heap[--t.heap_max]=n,i[2*r]=i[2*a]+i[2*n],t.depth[r]=(t.depth[a]>=t.depth[n]?t.depth[a]:t.depth[n])+1,i[2*a+1]=i[2*n+1]=r,t.heap[1]=r++,U(t,i,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var a,n,r,i,s,h,l=e.dyn_tree,_=e.max_code,o=e.stat_desc.static_tree,d=e.stat_desc.has_stree,u=e.stat_desc.extra_bits,f=e.stat_desc.extra_base,c=e.stat_desc.max_length,p=0;for(i=0;i<=15;i++)t.bl_count[i]=0;for(l[2*t.heap[t.heap_max]+1]=0,a=t.heap_max+1;a<573;a++)(i=l[2*l[2*(n=t.heap[a])+1]+1]+1)>c&&(i=c,p++),l[2*n+1]=i,n>_||(t.bl_count[i]++,s=0,n>=f&&(s=u[n-f]),h=l[2*n],t.opt_len+=h*(i+s),d&&(t.static_len+=h*(o[2*n+1]+s)));if(0!==p){do{for(i=c-1;0===t.bl_count[i];)i--;t.bl_count[i]--,t.bl_count[i+1]+=2,t.bl_count[c]--,p-=2}while(p>0);for(i=c;0!==i;i--)for(n=t.bl_count[i];0!==n;)(r=t.heap[--a])>_||(l[2*r+1]!==i&&(t.opt_len+=(i-l[2*r+1])*l[2*r],l[2*r+1]=i),n--)}}(t,e),z(i,_,t.bl_count)},E=function(t,e,a){var n,r,i=-1,s=e[1],h=0,l=7,_=4;for(0===s&&(l=138,_=3),e[2*(a+1)+1]=65535,n=0;n<=a;n++)r=s,s=e[2*(n+1)+1],++h<l&&r===s||(h<_?t.bl_tree[2*r]+=h:0!==r?(r!==i&&t.bl_tree[2*r]++,t.bl_tree[32]++):h<=10?t.bl_tree[34]++:t.bl_tree[36]++,h=0,i=r,0===s?(l=138,_=3):r===s?(l=6,_=3):(l=7,_=4))},C=function(t,e,a){var n,r,i=-1,s=e[1],h=0,l=7,_=4;for(0===s&&(l=138,_=3),n=0;n<=a;n++)if(r=s,s=e[2*(n+1)+1],!(++h<l&&r===s)){if(h<_)do{b(t,r,t.bl_tree)}while(0!==--h);else 0!==r?(r!==i&&(b(t,r,t.bl_tree),h--),b(t,16,t.bl_tree),m(t,h-3,2)):h<=10?(b(t,17,t.bl_tree),m(t,h-3,3)):(b(t,18,t.bl_tree),m(t,h-11,7));h=0,i=r,0===s?(l=138,_=3):r===s?(l=6,_=3):(l=7,_=4)}},D=!1,M=function(t,e,a,n){m(t,0+(n?1:0),3),function(t,e,a){x(t),w(t,a),w(t,~a),t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a}(t,e,a)},j=M,L=function(t,e,a,n){for(var r=65535&t,i=t>>>16&65535,s=0;0!==a;){a-=s=a>2e3?2e3:a;do{i=i+(r=r+e[n++]|0)|0}while(--s);r%=65521,i%=65521}return r|i<<16},S=new Uint32Array(function(){for(var t,e=[],a=0;a<256;a++){t=a;for(var n=0;n<8;n++)t=1&t?3988292384^t>>>1:t>>>1;e[a]=t}return e}()),T=function(t,e,a,n){var r=S,i=n+a;t^=-1;for(var s=n;s<i;s++)t=t>>>8^r[255&(t^e[s])];return-1^t},O={2:\\\"need dictionary\\\",1:\\\"stream end\\\",0:\\\"\\\",\\\"-1\\\":\\\"file error\\\",\\\"-2\\\":\\\"stream error\\\",\\\"-3\\\":\\\"data error\\\",\\\"-4\\\":\\\"insufficient memory\\\",\\\"-5\\\":\\\"buffer error\\\",\\\"-6\\\":\\\"incompatible version\\\"},q=j,F=function(t,e,a){return t.pending_buf[t.d_buf+2*t.last_lit]=e>>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&e,t.pending_buf[t.l_buf+t.last_lit]=255&a,t.last_lit++,0===e?t.dyn_ltree[2*a]++:(t.matches++,e--,t.dyn_ltree[2*(_[a]+256+1)]++,t.dyn_dtree[2*v(e)]++),t.last_lit===t.lit_bufsize-1},G=-2,H=258,J=262,K=103,N=113,P=666,Q=function(t,e){return t.msg=O[e],e},R=function(t){return(t<<1)-(t>4?9:0)},V=function(t){for(var e=t.length;--e>=0;)t[e]=0},W=function(t,e,a){return(e<<t.hash_shift^a)&t.hash_mask},X=function(t){var e=t.state,a=e.pending;a>t.avail_out&&(a=t.avail_out),0!==a&&(t.output.set(e.pending_buf.subarray(e.pending_out,e.pending_out+a),t.next_out),t.next_out+=a,e.pending_out+=a,t.total_out+=a,t.avail_out-=a,e.pending-=a,0===e.pending&&(e.pending_out=0))},Y=function(t,e){(function(t,e,a,n){var r,l,_=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=function(t){var e,a=4093624447;for(e=0;e<=31;e++,a>>>=1)if(1&a&&0!==t.dyn_ltree[2*e])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(e=32;e<256;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0}(t)),I(t,t.l_desc),I(t,t.d_desc),_=function(t){var e;for(E(t,t.dyn_ltree,t.l_desc.max_code),E(t,t.dyn_dtree,t.d_desc.max_code),I(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*i[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e}(t),r=t.opt_len+3+7>>>3,(l=t.static_len+3+7>>>3)<=r&&(r=l)):r=l=a+5,a+4<=r&&-1!==e?M(t,e,a,n):4===t.strategy||l===r?(m(t,2+(n?1:0),3),B(t,s,h)):(m(t,4+(n?1:0),3),function(t,e,a,n){var r;for(m(t,e-257,5),m(t,a-1,5),m(t,n-4,4),r=0;r<n;r++)m(t,t.bl_tree[2*i[r]+1],3);C(t,t.dyn_ltree,e-1),C(t,t.dyn_dtree,a-1)}(t,t.l_desc.max_code+1,t.d_desc.max_code+1,_+1),B(t,t.dyn_ltree,t.dyn_dtree)),k(t),n&&x(t)})(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,X(t.strm)},Z=function(t,e){t.pending_buf[t.pending++]=e},$=function(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},tt=function(t,e,a,n){var r=t.avail_in;return r>n&&(r=n),0===r?0:(t.avail_in-=r,e.set(t.input.subarray(t.next_in,t.next_in+r),a),1===t.state.wrap?t.adler=L(t.adler,e,r,a):2===t.state.wrap&&(t.adler=T(t.adler,e,r,a)),t.next_in+=r,t.total_in+=r,r)},et=function(t,e){var a,n,r=t.max_chain_length,i=t.strstart,s=t.prev_length,h=t.nice_match,l=t.strstart>t.w_size-J?t.strstart-(t.w_size-J):0,_=t.window,o=t.w_mask,d=t.prev,u=t.strstart+H,f=_[i+s-1],c=_[i+s];t.prev_length>=t.good_match&&(r>>=2),h>t.lookahead&&(h=t.lookahead);do{if(_[(a=e)+s]===c&&_[a+s-1]===f&&_[a]===_[i]&&_[++a]===_[i+1]){i+=2,a++;do{}while(_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&_[++i]===_[++a]&&i<u);if(n=H-(u-i),i=u-H,n>s){if(t.match_start=e,s=n,n>=h)break;f=_[i+s-1],c=_[i+s]}}}while((e=d[e&o])>l&&0!==--r);return s<=t.lookahead?s:t.lookahead},at=function(t){var e,a,n,r,i,s=t.w_size;do{if(r=t.window_size-t.lookahead-t.strstart,t.strstart>=s+(s-J)){t.window.set(t.window.subarray(s,s+s),0),t.match_start-=s,t.strstart-=s,t.block_start-=s,e=a=t.hash_size;do{n=t.head[--e],t.head[e]=n>=s?n-s:0}while(--a);e=a=s;do{n=t.prev[--e],t.prev[e]=n>=s?n-s:0}while(--a);r+=s}if(0===t.strm.avail_in)break;if(a=tt(t.strm,t.window,t.strstart+t.lookahead,r),t.lookahead+=a,t.lookahead+t.insert>=3)for(i=t.strstart-t.insert,t.ins_h=t.window[i],t.ins_h=W(t,t.ins_h,t.window[i+1]);t.insert&&(t.ins_h=W(t,t.ins_h,t.window[i+3-1]),t.prev[i&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=i,i++,t.insert--,!(t.lookahead+t.insert<3)););}while(t.lookahead<J&&0!==t.strm.avail_in)},nt=function(t,e){for(var a,n;;){if(t.lookahead<J){if(at(t),t.lookahead<J&&0===e)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=W(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),0!==a&&t.strstart-a<=t.w_size-J&&(t.match_length=et(t,a)),t.match_length>=3)if(n=F(t,t.strstart-t.match_start,t.match_length-3),t.lookahead-=t.match_length,t.match_length<=t.max_lazy_match&&t.lookahead>=3){t.match_length--;do{t.strstart++,t.ins_h=W(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart}while(0!==--t.match_length);t.strstart++}else t.strstart+=t.match_length,t.match_length=0,t.ins_h=t.window[t.strstart],t.ins_h=W(t,t.ins_h,t.window[t.strstart+1]);else n=F(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(n&&(Y(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,4===e?(Y(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Y(t,!1),0===t.strm.avail_out)?1:2},rt=function(t,e){for(var a,n,r;;){if(t.lookahead<J){if(at(t),t.lookahead<J&&0===e)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=W(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),t.prev_length=t.match_length,t.prev_match=t.match_start,t.match_length=2,0!==a&&t.prev_length<t.max_lazy_match&&t.strstart-a<=t.w_size-J&&(t.match_length=et(t,a),t.match_length<=5&&(1===t.strategy||3===t.match_length&&t.strstart-t.match_start>4096)&&(t.match_length=2)),t.prev_length>=3&&t.match_length<=t.prev_length){r=t.strstart+t.lookahead-3,n=F(t,t.strstart-1-t.prev_match,t.prev_length-3),t.lookahead-=t.prev_length-1,t.prev_length-=2;do{++t.strstart<=r&&(t.ins_h=W(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart)}while(0!==--t.prev_length);if(t.match_available=0,t.match_length=2,t.strstart++,n&&(Y(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if((n=F(t,0,t.window[t.strstart-1]))&&Y(t,!1),t.strstart++,t.lookahead--,0===t.strm.avail_out)return 1}else t.match_available=1,t.strstart++,t.lookahead--}return t.match_available&&(n=F(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,4===e?(Y(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Y(t,!1),0===t.strm.avail_out)?1:2};function it(t,e,a,n,r){this.good_length=t,this.max_lazy=e,this.nice_length=a,this.max_chain=n,this.func=r}var st=[new it(0,0,0,0,function(t,e){var a=65535;for(a>t.pending_buf_size-5&&(a=t.pending_buf_size-5);;){if(t.lookahead<=1){if(at(t),0===t.lookahead&&0===e)return 1;if(0===t.lookahead)break}t.strstart+=t.lookahead,t.lookahead=0;var n=t.block_start+a;if((0===t.strstart||t.strstart>=n)&&(t.lookahead=t.strstart-n,t.strstart=n,Y(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-J&&(Y(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,4===e?(Y(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(Y(t,!1),t.strm.avail_out),1)}),new it(4,4,8,4,nt),new it(4,5,16,8,nt),new it(4,6,32,32,nt),new it(4,4,16,16,rt),new it(8,16,32,32,rt),new it(8,16,128,128,rt),new it(8,32,128,256,rt),new it(32,128,258,1024,rt),new it(32,258,258,4096,rt)];function ht(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=8,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new Uint16Array(1146),this.dyn_dtree=new Uint16Array(122),this.bl_tree=new Uint16Array(78),V(this.dyn_ltree),V(this.dyn_dtree),V(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new Uint16Array(16),this.heap=new Uint16Array(573),V(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),V(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}for(var lt=function(t){var e,i=function(t){if(!t||!t.state)return Q(t,G);t.total_in=t.total_out=0,t.data_type=2;var e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:N,t.adler=2===e.wrap?0:1,e.last_flush=0,function(t){D||(function(){var t,e,i,g,v,w=Array(16);for(i=0,g=0;g<28;g++)for(o[g]=i,t=0;t<1<<a[g];t++)_[i++]=g;for(_[i-1]=g,v=0,g=0;g<16;g++)for(c[g]=v,t=0;t<1<<n[g];t++)l[v++]=g;for(v>>=7;g<30;g++)for(c[g]=v<<7,t=0;t<1<<n[g]-7;t++)l[256+v++]=g;for(e=0;e<=15;e++)w[e]=0;for(t=0;t<=143;)s[2*t+1]=8,t++,w[8]++;for(;t<=255;)s[2*t+1]=9,t++,w[9]++;for(;t<=279;)s[2*t+1]=7,t++,w[7]++;for(;t<=287;)s[2*t+1]=8,t++,w[8]++;for(z(s,287,w),t=0;t<30;t++)h[2*t+1]=5,h[2*t]=y(t,5);d=new p(s,a,257,286,15),u=new p(h,n,0,30,15),f=new p([],r,0,19,7)}(),D=!0),t.l_desc=new g(t.dyn_ltree,d),t.d_desc=new g(t.dyn_dtree,u),t.bl_desc=new g(t.bl_tree,f),t.bi_buf=0,t.bi_valid=0,k(t)}(e),0}(t);return 0===i&&((e=t.state).window_size=2*e.w_size,V(e.head),e.max_lazy_match=st[e.level].max_lazy,e.good_match=st[e.level].good_length,e.nice_match=st[e.level].nice_length,e.max_chain_length=st[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=2,e.match_available=0,e.ins_h=0),i},_t=function(t,e){var a,n;if(!t||!t.state||e>5||e<0)return t?Q(t,G):G;var r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===P&&4!==e)return Q(t,0===t.avail_out?-5:G);r.strm=t;var i=r.last_flush;if(r.last_flush=e,42===r.status)if(2===r.wrap)t.adler=0,Z(r,31),Z(r,139),Z(r,8),r.gzhead?(Z(r,(r.gzhead.text?1:0)+(r.gzhead.hcrc?2:0)+(r.gzhead.extra?4:0)+(r.gzhead.name?8:0)+(r.gzhead.comment?16:0)),Z(r,255&r.gzhead.time),Z(r,r.gzhead.time>>8&255),Z(r,r.gzhead.time>>16&255),Z(r,r.gzhead.time>>24&255),Z(r,9===r.level?2:r.strategy>=2||r.level<2?4:0),Z(r,255&r.gzhead.os),r.gzhead.extra&&r.gzhead.extra.length&&(Z(r,255&r.gzhead.extra.length),Z(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(t.adler=T(t.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=69):(Z(r,0),Z(r,0),Z(r,0),Z(r,0),Z(r,0),Z(r,9===r.level?2:r.strategy>=2||r.level<2?4:0),Z(r,3),r.status=N);else{var h=8+(r.w_bits-8<<4)<<8;h|=(r.strategy>=2||r.level<2?0:r.level<6?1:6===r.level?2:3)<<6,0!==r.strstart&&(h|=32),h+=31-h%31,r.status=N,$(r,h),0!==r.strstart&&($(r,t.adler>>>16),$(r,65535&t.adler)),t.adler=1}if(69===r.status)if(r.gzhead.extra){for(a=r.pending;r.gzindex<(65535&r.gzhead.extra.length)&&(r.pending!==r.pending_buf_size||(r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),X(t),a=r.pending,r.pending!==r.pending_buf_size));)Z(r,255&r.gzhead.extra[r.gzindex]),r.gzindex++;r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=73)}else r.status=73;if(73===r.status)if(r.gzhead.name){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),X(t),a=r.pending,r.pending===r.pending_buf_size)){n=1;break}n=r.gzindex<r.gzhead.name.length?255&r.gzhead.name.charCodeAt(r.gzindex++):0,Z(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.gzindex=0,r.status=91)}else r.status=91;if(91===r.status)if(r.gzhead.comment){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),X(t),a=r.pending,r.pending===r.pending_buf_size)){n=1;break}n=r.gzindex<r.gzhead.comment.length?255&r.gzhead.comment.charCodeAt(r.gzindex++):0,Z(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=T(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.status=K)}else r.status=K;if(r.status===K&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&X(t),r.pending+2<=r.pending_buf_size&&(Z(r,255&t.adler),Z(r,t.adler>>8&255),t.adler=0,r.status=N)):r.status=N),0!==r.pending){if(X(t),0===t.avail_out)return r.last_flush=-1,0}else if(0===t.avail_in&&R(e)<=R(i)&&4!==e)return Q(t,-5);if(r.status===P&&0!==t.avail_in)return Q(t,-5);if(0!==t.avail_in||0!==r.lookahead||0!==e&&r.status!==P){var l=2===r.strategy?function(t,e){for(var a;;){if(0===t.lookahead&&(at(t),0===t.lookahead)){if(0===e)return 1;break}if(t.match_length=0,a=F(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(Y(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,4===e?(Y(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Y(t,!1),0===t.strm.avail_out)?1:2}(r,e):3===r.strategy?function(t,e){for(var a,n,r,i,s=t.window;;){if(t.lookahead<=H){if(at(t),t.lookahead<=H&&0===e)return 1;if(0===t.lookahead)break}if(t.match_length=0,t.lookahead>=3&&t.strstart>0&&(n=s[r=t.strstart-1])===s[++r]&&n===s[++r]&&n===s[++r]){i=t.strstart+H;do{}while(n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&r<i);t.match_length=H-(i-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=F(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=F(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(Y(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,4===e?(Y(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Y(t,!1),0===t.strm.avail_out)?1:2}(r,e):st[r.level].func(r,e);if(3!==l&&4!==l||(r.status=P),1===l||3===l)return 0===t.avail_out&&(r.last_flush=-1),0;if(2===l&&(1===e?function(t){m(t,2,3),b(t,256,s),function(t){16===t.bi_valid?(w(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)}(t)}(r):5!==e&&(q(r,0,0,!1),3===e&&(V(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),X(t),0===t.avail_out))return r.last_flush=-1,0}return 4!==e?0:r.wrap<=0?1:(2===r.wrap?(Z(r,255&t.adler),Z(r,t.adler>>8&255),Z(r,t.adler>>16&255),Z(r,t.adler>>24&255),Z(r,255&t.total_in),Z(r,t.total_in>>8&255),Z(r,t.total_in>>16&255),Z(r,t.total_in>>24&255)):($(r,t.adler>>>16),$(r,65535&t.adler)),X(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?0:1)},ot=function(t){if(!t||!t.state)return G;var e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==K&&e!==N&&e!==P?Q(t,G):(t.state=null,e===N?Q(t,-3):0)},dt=new Uint8Array(256),ut=0;ut<256;ut++)dt[ut]=ut>=252?6:ut>=248?5:ut>=240?4:ut>=224?3:ut>=192?2:1;dt[254]=dt[254]=1;var ft=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg=\\\"\\\",this.state=null,this.data_type=2,this.adler=0},ct=Object.prototype.toString;function pt(){this.options={level:-1,method:8,chunkSize:16384,windowBits:15,memLevel:8,strategy:0};var t=this.options;t.raw&&t.windowBits>0?t.windowBits=-t.windowBits:t.gzip&&t.windowBits>0&&t.windowBits<16&&(t.windowBits+=16),this.err=0,this.msg=\\\"\\\",this.ended=!1,this.chunks=[],this.strm=new ft,this.strm.avail_out=0;var e,a,n=function(t,e,a,n,r,i){if(!t)return G;var s=1;if(-1===e&&(e=6),n<0?(s=0,n=-n):n>15&&(s=2,n-=16),r<1||r>9||8!==a||n<8||n>15||e<0||e>9||i<0||i>4)return Q(t,G);8===n&&(n=9);var h=new ht;return t.state=h,h.strm=t,h.wrap=s,h.gzhead=null,h.w_bits=n,h.w_size=1<<h.w_bits,h.w_mask=h.w_size-1,h.hash_bits=r+7,h.hash_size=1<<h.hash_bits,h.hash_mask=h.hash_size-1,h.hash_shift=~~((h.hash_bits+3-1)/3),h.window=new Uint8Array(2*h.w_size),h.head=new Uint16Array(h.hash_size),h.prev=new Uint16Array(h.w_size),h.lit_bufsize=1<<r+6,h.pending_buf_size=4*h.lit_bufsize,h.pending_buf=new Uint8Array(h.pending_buf_size),h.d_buf=1*h.lit_bufsize,h.l_buf=3*h.lit_bufsize,h.level=e,h.strategy=i,h.method=a,lt(t)}(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(0!==n)throw Error(O[n]);if(t.header&&(e=this.strm,a=t.header,e&&e.state&&(2!==e.state.wrap||(e.state.gzhead=a))),t.dictionary){var r;if(r=\\\"[object ArrayBuffer]\\\"===ct.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,0!==(n=function(t,e){var a=e.length;if(!t||!t.state)return G;var n=t.state,r=n.wrap;if(2===r||1===r&&42!==n.status||n.lookahead)return G;if(1===r&&(t.adler=L(t.adler,e,a,0)),n.wrap=0,a>=n.w_size){0===r&&(V(n.head),n.strstart=0,n.block_start=0,n.insert=0);var i=new Uint8Array(n.w_size);i.set(e.subarray(a-n.w_size,a),0),e=i,a=n.w_size}var s=t.avail_in,h=t.next_in,l=t.input;for(t.avail_in=a,t.next_in=0,t.input=e,at(n);n.lookahead>=3;){var _=n.strstart,o=n.lookahead-2;do{n.ins_h=W(n,n.ins_h,n.window[_+3-1]),n.prev[_&n.w_mask]=n.head[n.ins_h],n.head[n.ins_h]=_,_++}while(--o);n.strstart=_,n.lookahead=2,at(n)}return n.strstart+=n.lookahead,n.block_start=n.strstart,n.insert=n.lookahead,n.lookahead=0,n.match_length=n.prev_length=2,n.match_available=0,t.next_in=h,t.input=l,t.avail_in=s,n.wrap=r,0}(this.strm,r)))throw Error(O[n]);this._dict_set=!0}}function gt(t,e,a){try{t.postMessage({type:\\\"errored\\\",error:e,streamId:a})}catch(n){t.postMessage({type:\\\"errored\\\",error:e+\\\"\\\",streamId:a})}}function vt(t){const e=t.strm.adler;return new Uint8Array([3,0,e>>>24&255,e>>>16&255,e>>>8&255,255&e])}pt.prototype.push=function(t,e){var a,n,r=this.strm,i=this.options.chunkSize;if(this.ended)return!1;for(n=e===~~e?e:!0===e?4:0,\\\"[object ArrayBuffer]\\\"===ct.call(t)?r.input=new Uint8Array(t):r.input=t,r.next_in=0,r.avail_in=r.input.length;;)if(0===r.avail_out&&(r.output=new Uint8Array(i),r.next_out=0,r.avail_out=i),(2===n||3===n)&&r.avail_out<=6)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else{if(1===(a=_t(r,n)))return r.next_out>0&&this.onData(r.output.subarray(0,r.next_out)),a=ot(this.strm),this.onEnd(a),this.ended=!0,0===a;if(0!==r.avail_out){if(n>0&&r.next_out>0)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else if(0===r.avail_in)break}else this.onData(r.output)}return!0},pt.prototype.onData=function(t){this.chunks.push(t)},pt.prototype.onEnd=function(t){0===t&&(this.result=function(t){for(var e=0,a=0,n=t.length;a<n;a++)e+=t[a].length;for(var r=new Uint8Array(e),i=0,s=0,h=t.length;i<h;i++){var l=t[i];r.set(l,s),s+=l.length}return r}(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg},function(e=self){try{const a=new Map;e.addEventListener(\\\"message\\\",n=>{try{const r=function(e,a){switch(a.action){case\\\"init\\\":return{type:\\\"initialized\\\",version:\\\"6.22.0\\\"};case\\\"write\\\":{let n=e.get(a.streamId);n||(n=new pt,e.set(a.streamId,n));const r=n.chunks.length,i=function(t){if(\\\"function\\\"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);let e,a,n,r,i,s=t.length,h=0;for(r=0;r<s;r++)a=t.charCodeAt(r),55296==(64512&a)&&r+1<s&&(n=t.charCodeAt(r+1),56320==(64512&n)&&(a=65536+(a-55296<<10)+(n-56320),r++)),h+=a<128?1:a<2048?2:a<65536?3:4;for(e=new Uint8Array(h),i=0,r=0;i<h;r++)a=t.charCodeAt(r),55296==(64512&a)&&r+1<s&&(n=t.charCodeAt(r+1),56320==(64512&n)&&(a=65536+(a-55296<<10)+(n-56320),r++)),a<128?e[i++]=a:a<2048?(e[i++]=192|a>>>6,e[i++]=128|63&a):a<65536?(e[i++]=224|a>>>12,e[i++]=128|a>>>6&63,e[i++]=128|63&a):(e[i++]=240|a>>>18,e[i++]=128|a>>>12&63,e[i++]=128|a>>>6&63,e[i++]=128|63&a);return e}(a.data);return n.push(i,2),{type:\\\"wrote\\\",id:a.id,streamId:a.streamId,result:t(n.chunks.slice(r)),trailer:vt(n),additionalBytesCount:i.length}}case\\\"reset\\\":e.delete(a.streamId)}}(a,n.data);r&&e.postMessage(r)}catch(t){gt(e,t,n.data&&\\\"streamId\\\"in n.data?n.data.streamId:void 0)}})}catch(t){gt(e,t)}}()})();\"])));\n}\nlet state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(configuration, source, onInitializationFailure, createDeflateWorkerImpl = createDeflateWorker) {\n    if (state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n        doStartDeflateWorker(configuration, source, createDeflateWorkerImpl);\n    }\n    switch (state.status) {\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.initializationFailureCallbacks.push(onInitializationFailure);\n            return state.worker;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            return state.worker;\n    }\n}\nexport function resetDeflateWorkerState() {\n    if (state.status === 3 /* DeflateWorkerStatus.Initialized */ || state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.stop();\n    }\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\n}\nexport function getDeflateWorkerStatus() {\n    return state.status;\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(configuration, source, createDeflateWorkerImpl = createDeflateWorker) {\n    try {\n        const worker = createDeflateWorkerImpl(configuration);\n        const { stop: removeErrorListener } = addEventListener(configuration, worker, 'error', (error) => {\n            onError(configuration, source, error);\n        });\n        const { stop: removeMessageListener } = addEventListener(configuration, worker, 'message', ({ data }) => {\n            if (data.type === 'errored') {\n                onError(configuration, source, data.error, data.streamId);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(data.version);\n            }\n        });\n        worker.postMessage({ action: 'init' });\n        setTimeout(() => onTimeout(source), INITIALIZATION_TIME_OUT_DELAY);\n        const stop = () => {\n            removeErrorListener();\n            removeMessageListener();\n        };\n        state = { status: 1 /* DeflateWorkerStatus.Loading */, worker, stop, initializationFailureCallbacks: [] };\n    }\n    catch (error) {\n        onError(configuration, source, error);\n    }\n}\nfunction onTimeout(source) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error(`${source} failed to start: a timeout occurred while initializing the Worker`);\n        state.initializationFailureCallbacks.forEach((callback) => callback());\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n}\nfunction onInitialized(version) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: state.worker, stop: state.stop, version };\n    }\n}\nfunction onError(configuration, source, error, streamId) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */ || state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        reportScriptLoadingError({\n            configuredUrl: configuration.workerUrl,\n            error,\n            source,\n            scriptType: 'worker',\n        });\n        if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n            state.initializationFailureCallbacks.forEach((callback) => callback());\n        }\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error, {\n            worker_version: state.status === 3 /* DeflateWorkerStatus.Initialized */ && state.version,\n            stream_id: streamId,\n        });\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map","/**\n * Test for Browser features used while recording\n */\nexport function isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' &&\n        typeof CSSSupportsRule === 'function' &&\n        typeof URL.createObjectURL === 'function' &&\n        'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=isBrowserSupported.js.map","import { getSessionReplayUrl } from '@datadog/browser-rum-core';\nimport { isBrowserSupported } from '../boot/isBrowserSupported';\nexport function getSessionReplayLink(configuration, sessionManager, viewHistory, isRecordingStarted) {\n    const session = sessionManager.findTrackedSession();\n    const errorType = getErrorType(session, isRecordingStarted);\n    const viewContext = viewHistory.findView();\n    return getSessionReplayUrl(configuration, {\n        viewContext,\n        errorType,\n        session,\n    });\n}\nfunction getErrorType(session, isRecordingStarted) {\n    if (!isBrowserSupported()) {\n        return 'browser-not-supported';\n    }\n    if (!session) {\n        // possibilities:\n        // - rum sampled out\n        // - session expired (edge case)\n        return 'rum-not-tracked';\n    }\n    if (session.sessionReplay === 0 /* SessionReplayState.OFF */) {\n        // possibilities\n        // - replay sampled out\n        return 'incorrect-session-plan';\n    }\n    if (!isRecordingStarted) {\n        return 'replay-not-started';\n    }\n}\n//# sourceMappingURL=getSessionReplayLink.js.map","import { asyncRunOnReadyState, monitorError, Observable } from '@datadog/browser-core';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { startRecorderInitTelemetry } from '../domain/startRecorderInitTelemetry';\nexport function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder, telemetry) {\n    let status = 0 /* RecorderStatus.Stopped */;\n    let stopRecording;\n    lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_EXPIRED */, () => {\n        if (status === 2 /* RecorderStatus.Starting */ || status === 3 /* RecorderStatus.Started */) {\n            stop();\n            status = 1 /* RecorderStatus.IntentToStart */;\n        }\n    });\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        if (status === 1 /* RecorderStatus.IntentToStart */) {\n            start();\n        }\n    });\n    const observable = new Observable();\n    startRecorderInitTelemetry(telemetry, observable);\n    const doStart = async (forced) => {\n        observable.notify({ type: 'start', forced });\n        const [startRecordingImpl] = await Promise.all([\n            notifyWhenSettled(observable, { type: 'recorder-settled' }, loadRecorder()),\n            notifyWhenSettled(observable, { type: 'document-ready' }, asyncRunOnReadyState(configuration, 'interactive')),\n        ]);\n        if (status !== 2 /* RecorderStatus.Starting */) {\n            observable.notify({ type: 'aborted' });\n            return;\n        }\n        if (!startRecordingImpl) {\n            status = 0 /* RecorderStatus.Stopped */;\n            observable.notify({ type: 'recorder-load-failed' });\n            return;\n        }\n        const deflateEncoder = getOrCreateDeflateEncoder();\n        if (!deflateEncoder) {\n            status = 0 /* RecorderStatus.Stopped */;\n            observable.notify({ type: 'deflate-encoder-load-failed' });\n            return;\n        }\n        ;\n        ({ stop: stopRecording } = startRecordingImpl(lifeCycle, configuration, sessionManager, viewHistory, deflateEncoder, telemetry));\n        status = 3 /* RecorderStatus.Started */;\n        observable.notify({ type: 'succeeded' });\n    };\n    function start(options) {\n        const session = sessionManager.findTrackedSession();\n        if (canStartRecording(session, options)) {\n            status = 1 /* RecorderStatus.IntentToStart */;\n            return;\n        }\n        if (isRecordingInProgress(status)) {\n            return;\n        }\n        status = 2 /* RecorderStatus.Starting */;\n        const forced = shouldForceReplay(session, options) || false;\n        // Intentionally not awaiting doStart() to keep it asynchronous\n        doStart(forced).catch(monitorError);\n        if (forced) {\n            sessionManager.setForcedReplay();\n        }\n    }\n    function stop() {\n        if (status === 3 /* RecorderStatus.Started */) {\n            stopRecording === null || stopRecording === void 0 ? void 0 : stopRecording();\n        }\n        status = 0 /* RecorderStatus.Stopped */;\n    }\n    return {\n        start,\n        stop,\n        getSessionReplayLink() {\n            return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== 0 /* RecorderStatus.Stopped */);\n        },\n        isRecording: () => status === 3 /* RecorderStatus.Started */,\n    };\n}\nfunction canStartRecording(session, options) {\n    return !session || (session.sessionReplay === 0 /* SessionReplayState.OFF */ && (!options || !options.force));\n}\nfunction isRecordingInProgress(status) {\n    return status === 2 /* RecorderStatus.Starting */ || status === 3 /* RecorderStatus.Started */;\n}\nfunction shouldForceReplay(session, options) {\n    return options && options.force && session.sessionReplay === 0 /* SessionReplayState.OFF */;\n}\nasync function notifyWhenSettled(observable, event, promise) {\n    try {\n        return await promise;\n    }\n    finally {\n        observable.notify(event);\n    }\n}\n//# sourceMappingURL=postStartStrategy.js.map","import { addTelemetryMetrics, noop, timeStampNow, elapsed } from '@datadog/browser-core';\nexport function startRecorderInitTelemetry(telemetry, observable) {\n    if (!telemetry.metricsEnabled) {\n        return { stop: noop };\n    }\n    let startContext;\n    let documentReadyDuration;\n    let recorderSettledDuration;\n    const { unsubscribe } = observable.subscribe((event) => {\n        switch (event.type) {\n            case 'start':\n                startContext = { forced: event.forced, timestamp: timeStampNow() };\n                documentReadyDuration = undefined;\n                recorderSettledDuration = undefined;\n                break;\n            case 'document-ready':\n                if (startContext) {\n                    documentReadyDuration = elapsed(startContext.timestamp, timeStampNow());\n                }\n                break;\n            case 'recorder-settled':\n                if (startContext) {\n                    recorderSettledDuration = elapsed(startContext.timestamp, timeStampNow());\n                }\n                break;\n            case 'aborted':\n            case 'deflate-encoder-load-failed':\n            case 'recorder-load-failed':\n            case 'succeeded':\n                // Only send metrics for the first attempt at starting the recorder.\n                unsubscribe();\n                if (startContext) {\n                    // monitor-until: 2026-07-01\n                    addTelemetryMetrics(\"Recorder init metrics\" /* TelemetryMetrics.RECORDER_INIT_METRICS_TELEMETRY_NAME */, {\n                        metrics: createRecorderInitMetrics(startContext.forced, recorderSettledDuration, elapsed(startContext.timestamp, timeStampNow()), event.type, documentReadyDuration),\n                    });\n                }\n                break;\n        }\n    });\n    return { stop: unsubscribe };\n}\nfunction createRecorderInitMetrics(forced, loadRecorderModuleDuration, recorderInitDuration, result, waitForDocReadyDuration) {\n    return {\n        forced,\n        loadRecorderModuleDuration,\n        recorderInitDuration,\n        result,\n        waitForDocReadyDuration,\n    };\n}\n//# sourceMappingURL=startRecorderInitTelemetry.js.map","import { reportScriptLoadingError } from '../domain/scriptLoadingError';\nexport async function lazyLoadRecorder(importRecorderImpl = importRecorder) {\n    try {\n        return await importRecorderImpl();\n    }\n    catch (error) {\n        reportScriptLoadingError({\n            error,\n            source: 'Recorder',\n            scriptType: 'module',\n        });\n    }\n}\nasync function importRecorder() {\n    const module = await import(/* webpackChunkName: \"recorder\" */ './startRecording');\n    return module.startRecording;\n}\n//# sourceMappingURL=lazyLoadRecorder.js.map","import { reportScriptLoadingError } from '../domain/scriptLoadingError';\nexport async function lazyLoadProfiler(importProfilerImpl = importProfiler) {\n    try {\n        return await importProfilerImpl();\n    }\n    catch (error) {\n        reportScriptLoadingError({\n            error,\n            source: 'Profiler',\n            scriptType: 'module',\n        });\n    }\n}\nasync function importProfiler() {\n    const module = await import(/* webpackChunkName: \"profiler\" */ '../domain/profiling/profiler');\n    return module.createRumProfiler;\n}\n//# sourceMappingURL=lazyLoadProfiler.js.map","/**\n * Datadog Browser RUM SDK - Full version with Session Replay and Real User Profiling capabilities.\n * Use this package to monitor your web application's performance and user experience.\n *\n * @packageDocumentation\n * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)\n */\n// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { makeRecorderApi } from '../boot/recorderApi';\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate';\nimport { lazyLoadRecorder } from '../boot/lazyLoadRecorder';\nimport { makeProfilerApi } from '../boot/profilerApi';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nconst recorderApi = makeRecorderApi(lazyLoadRecorder);\nconst profilerApi = makeProfilerApi();\n/**\n * The global RUM instance. Use this to call RUM methods.\n *\n * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)\n */\nexport const datadogRum = makeRumPublicApi(startRum, recorderApi, profilerApi, {\n    startDeflateWorker,\n    createDeflateEncoder,\n    sdkName: 'rum',\n});\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { canUseEventBridge, noop, bridgeSupports, } from '@datadog/browser-core';\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats';\nimport { createDeflateEncoder, getDeflateWorkerStatus, startDeflateWorker, } from '../domain/deflate';\nimport { isBrowserSupported } from './isBrowserSupported';\nimport { createPostStartStrategy } from './postStartStrategy';\nimport { createPreStartStrategy } from './preStartStrategy';\nexport function makeRecorderApi(loadRecorder, createDeflateWorkerImpl) {\n    if ((canUseEventBridge() && !bridgeSupports(\"records\" /* BridgeCapability.RECORDS */)) || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: () => undefined,\n            onRumStart: noop,\n            isRecording: () => false,\n            getSessionReplayLink: () => undefined,\n        };\n    }\n    // eslint-disable-next-line prefer-const\n    let { strategy, shouldStartImmediately } = createPreStartStrategy();\n    return {\n        start: (options) => strategy.start(options),\n        stop: () => strategy.stop(),\n        getSessionReplayLink: () => strategy.getSessionReplayLink(),\n        onRumStart,\n        isRecording: () => \n        // The worker is started optimistically, meaning we could have started to record but its\n        // initialization fails a bit later. This could happen when:\n        // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n        // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n        // * the browser fails to load the worker in case the workerUrl is used\n        // * an unexpected error occurs in the Worker before initialization, ex:\n        //   * a runtime exception collected by monitor()\n        //   * a syntax error notified by the browser via an error event\n        // * the worker is unresponsive for some reason and timeouts\n        //\n        // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n        // an important part of the Datadog App:\n        // * If we have a false positive (we set has_replay: true even if no replay data is present),\n        // we might display broken links to the Session Replay player.\n        // * If we have a false negative (we don't set has_replay: true even if replay data is\n        // available), it is less noticeable because no link will be displayed.\n        //\n        // Thus, it is better to have false negative, so let's make sure the worker is correctly\n        // initialized before advertizing that we are recording.\n        //\n        // In the future, when the compression worker will also be used for RUM data, this will be\n        // less important since no RUM event will be sent when the worker fails to initialize.\n        getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ && strategy.isRecording(),\n        getReplayStats: (viewId) => getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ ? getReplayStatsImpl(viewId) : undefined,\n    };\n    function onRumStart(lifeCycle, configuration, sessionManager, viewHistory, worker, telemetry) {\n        let cachedDeflateEncoder;\n        function getOrCreateDeflateEncoder() {\n            if (!cachedDeflateEncoder) {\n                worker !== null && worker !== void 0 ? worker : (worker = startDeflateWorker(configuration, 'Datadog Session Replay', () => {\n                    strategy.stop();\n                }, createDeflateWorkerImpl));\n                if (worker) {\n                    cachedDeflateEncoder = createDeflateEncoder(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */);\n                }\n            }\n            return cachedDeflateEncoder;\n        }\n        strategy = createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder, telemetry);\n        if (shouldStartImmediately(configuration)) {\n            strategy.start();\n        }\n    }\n}\n//# sourceMappingURL=recorderApi.js.map","import { noop } from '@datadog/browser-core';\nexport function createPreStartStrategy() {\n    let status = 0 /* PreStartRecorderStatus.None */;\n    return {\n        strategy: {\n            start() {\n                status = 1 /* PreStartRecorderStatus.HadManualStart */;\n            },\n            stop() {\n                status = 2 /* PreStartRecorderStatus.HadManualStop */;\n            },\n            isRecording: () => false,\n            getSessionReplayLink: noop,\n        },\n        shouldStartImmediately(configuration) {\n            return (status === 1 /* PreStartRecorderStatus.HadManualStart */ ||\n                (status === 0 /* PreStartRecorderStatus.None */ && !configuration.startSessionReplayRecordingManually));\n        },\n    };\n}\n//# sourceMappingURL=preStartStrategy.js.map","import { isSampled } from '@datadog/browser-rum-core';\nimport { addTelemetryDebug, monitorError } from '@datadog/browser-core';\nimport { isProfilingSupported } from '../domain/profiling/profilingSupported';\nimport { startProfilingContext } from '../domain/profiling/profilingContext';\nimport { lazyLoadProfiler } from './lazyLoadProfiler';\nexport function makeProfilerApi() {\n    let profiler;\n    function onRumStart(lifeCycle, hooks, configuration, sessionManager, viewHistory, createEncoder) {\n        const session = sessionManager.findTrackedSession(); // Check if the session is tracked.\n        if (!session) {\n            // No session tracked, no profiling.\n            // Note: No Profiling context is set at this stage.\n            return;\n        }\n        // Sampling (sticky sampling based on session id)\n        if (!isSampled(session.id, configuration.profilingSampleRate)) {\n            // No sampling, no profiling.\n            // Note: No Profiling context is set at this stage.\n            return;\n        }\n        // Listen to events and add the profiling context to them.\n        const profilingContextManager = startProfilingContext(hooks);\n        // Browser support check\n        if (!isProfilingSupported()) {\n            profilingContextManager.set({\n                status: 'error',\n                error_reason: 'not-supported-by-browser',\n            });\n            return;\n        }\n        lazyLoadProfiler()\n            .then((createRumProfiler) => {\n            if (!createRumProfiler) {\n                // monitor-until: 2026-01-01, reconsider after profiling GA\n                addTelemetryDebug('[DD_RUM] Failed to lazy load the RUM Profiler');\n                profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' });\n                return;\n            }\n            profiler = createRumProfiler(configuration, lifeCycle, sessionManager, profilingContextManager, createEncoder);\n            profiler.start(viewHistory.findView());\n        })\n            .catch(monitorError);\n    }\n    return {\n        onRumStart,\n        stop: () => {\n            profiler === null || profiler === void 0 ? void 0 : profiler.stop().catch(monitorError);\n        },\n    };\n}\n//# sourceMappingURL=profilerApi.js.map","import { SKIPPED } from '@datadog/browser-core';\nimport { RumEventType } from '@datadog/browser-rum-core';\nexport const startProfilingContext = (hooks) => {\n    // Default status is `starting`.\n    let currentContext = {\n        status: 'starting',\n    };\n    // Register the assemble hook to add the profiling context to the event attributes.\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        if (eventType !== RumEventType.VIEW && eventType !== RumEventType.LONG_TASK) {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            _dd: {\n                profiling: currentContext,\n            },\n        };\n    });\n    return {\n        get: () => currentContext,\n        set: (newContext) => {\n            currentContext = newContext;\n        },\n    };\n};\n//# sourceMappingURL=profilingContext.js.map","import { getGlobalObject } from '@datadog/browser-core';\nexport function isProfilingSupported() {\n    const globalThis = getGlobalObject();\n    // This API might be unavailable in some browsers\n    const globalThisProfiler = globalThis.Profiler;\n    return globalThisProfiler !== undefined;\n}\n//# sourceMappingURL=profilingSupported.js.map","import {\n  Consent as packageConsent,\n  consented as packageConsented,\n  deferRun as packageDeferRun,\n  userHasOptedOutOfCookiesForCategory as packageUserOptedOut,\n} from '@envato/cookiebot-wrapper'\n\nconst checkConsentTypePresent = (consentType) => {\n  if (!consentType) {\n    throw Error('Consent type unspecified')\n  }\n}\n// Wrapping these allows for more readable mocks in tests\n// Also allows us to make sure we are always passing consentType\nexport const Consent = packageConsent\nexport const consented = (consentType) => {\n  checkConsentTypePresent(consentType)\n  return packageConsented(consentType)\n}\nexport const deferRun = (job, consentType) => {\n  checkConsentTypePresent(consentType)\n  return packageDeferRun(job, consentType)\n}\nexport const userHasOptedOutOfCookiesForCategory = (consentType) => {\n  checkConsentTypePresent(consentType)\n  return packageUserOptedOut(consentType)\n}\n","import { datadogRum } from '@datadog/browser-rum'\nimport { TrackingConsent } from '@datadog/browser-core'\nimport { Consent, consented } from '../utils/consent.js'\n\nwindow.addEventListener('CookiebotOnConsentReady', () => {\n  if (!window.datadogEnvironment) return\n\n  datadogRum.init({\n    applicationId: '00847d7d-72d5-4ede-91ac-2efdc9af7278',\n    clientToken: 'pubb2da50a99f90a160463bb01ac07a1019',\n    site: 'datadoghq.com',\n    service: 'market-storefront',\n    env: window.datadogEnvironment,\n    version: window.datadogVersion,\n    sessionSampleRate: window.datadogSampleRate,\n    sessionReplaySampleRate: 0,\n    trackUserInteractions: true,\n    defaultPrivacyLevel: 'mask-user-input',\n    trackingConsent: consented(Consent.statistics) ? TrackingConsent.GRANTED : TrackingConsent.NOT_GRANTED,\n  })\n})\n"],"names":["getGlobalObject","globalThis","Object","defineProperty","prototype","get","this","configurable","globalObject","_dd_temp_","self","window","isWorkerEnvironment","MAX_STATS_HISTORY","statsPerView","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addSegment","addRecord","records_count","addWroteData","additionalBytesCount","segments_total_raw_size","getReplayStats","replayStats","Map","has","set","size","toDelete","keys","next","value","delete","deleteOldestStats","queueMicrotask","callback","_a","nativeImplementation","bind","monitor","Promise","resolve","then","Observable","constructor","onFirstSubscribe","observers","subscribe","observer","addObserver","unsubscribe","removeObserver","notify","data","forEach","push","length","onLastUnsubscribe","undefined","filter","other","mergeObservables","observables","globalObservable","subscriptions","map","observable","subscription","BufferedObservable","maxBufferSize","super","buffer","shift","closed","unbuffer","factory","module","exports","OldCookies","Cookies","api","noConflict","extend","i","result","arguments","attributes","key","decode","s","replace","decodeURIComponent","init","converter","document","path","defaults","expires","Date","toUTCString","JSON","stringify","test","e","write","encodeURIComponent","String","escape","stringifiedAttributes","attributeName","split","cookie","json","jar","cookies","parts","slice","join","charAt","name","read","parse","getJSON","remove","withConverter","addEventListener","configuration","eventTarget","eventName","listener","options","addEventListeners","eventNames","once","capture","passive","listenerWithMonitor","event","isTrusted","__ddIsTrusted","allowUntrustedEvents","stop","listenerTarget","EventTarget","add","call","getConnectivity","navigator","status","onLine","interfaces","connection","type","effective_type","effectiveType","runOnReadyState","expectedReadyState","readyState","asyncRunOnReadyState","getType","Array","isArray","isServerError","tryToClone","response","clone","ownKeys","__createBinding","create","o","m","k","k2","desc","getOwnPropertyDescriptor","__esModule","writable","enumerable","__setModuleDefault","v","__importStar","getOwnPropertyNames","ar","hasOwnProperty","mod","userHasOptedOutOfCookiesForCategory","consented","checkCookieConsent","deferRun","Consent","queue","execute","cookiebotJob","job","consent","Cookiebot","hasResponse","CookieString","parsedCookieConsent","CookieConsent","onMonitorErrorCollected","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","fn","callMonitored","context","args","apply","monitorError","displayIfDebugEnabled","error","ConsoleApiName","log","debug","info","warn","globalConsole","console","originalConsoleMethods","PREFIX","display","DOCS_ORIGIN","DOCS_TROUBLESHOOTING","MORE_DETAILS","sendToExtension","payload","__ddBrowserSdkExtensionCallback","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_US1_FED","PCI_INTAKE_HOST_US1","INTAKE_URL_PARAMETERS","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","JSON_PATH_ROOT_ELEMENT","KEY_DECORATION_LENGTH","sanitize","source","maxCharacterCount","restoreObjectPrototypeToJson","restoreArrayPrototypeToJson","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","serializedSanitizedData","accumulatedCharacterCount","containerToProcess","separatorLength","targetData","warnOverCharacterLimit","target","parentPath","sourceToSanitize","object","toJSON","tryToApplyToJSON","toString","description","sanitizePrimitivesAndFunctions","sanitizedSource","sanitizeObjects","sourceAsObject","currentPath","Event","currentTarget","RegExp","match","changeType","throttle","wait","needLeadingExecution","leading","needTrailingExecution","trailing","pendingExecutionWithParameters","pendingTimeoutId","inWaitPeriod","throttled","parameters","cancel","noop","setTimeout","delay","clearTimeout","timeoutId","setInterval","clearInterval","instrumentMethod","targetPrototype","method","onPreCall","computeHandlingStack","original","startsWith","stopped","instrumentation","from","postCallCallback","onPostCall","handlingStack","instrumentSetter","property","after","originalDescriptor","stoppedInstrumentation","instrumentationWrapper","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","componentStack","startClocks","nonErrorPrefix","useFallbackStack","handling","isErrorInstance","isError","message","computeMessage","stack","causes","flattenErrorCauses","fingerprint","tryToGetFingerprint","tryToGetErrorContext","dd_fingerprint","dd_context","Error","parentSource","currentError","cause","registry","getLongTaskId","startTime","cleanupLongTaskRegistryAfterCollection","collectionRelativeTime","performanceStartTime","mayStoreLongTaskIdForProfilerCorrelation","rawRumEvent","LONG_TASK","longTaskId","setLongTaskId","long_task","id","PATH_MIXED_ALPHANUMERICS","getCustomOrDefaultViewName","customViewName","viewPathUrl","getDefaultViewName","buildProfileEventAttributes","profilerTrace","applicationId","sessionId","application","session","ids","names","views","view","viewName","Set","extractViewIdsAndNames","longTaskIds","longTasks","longTask","assembleProfilingPayload","tags","profileAttributes","profileEventTags","concat","buildProfileEventTags","profileEvent","attachments","start","timeStamp","toISOString","end","endClocks","family","runtime","format","version","tags_profiler","_dd","clock_drift","buildProfileEvent","DEFAULT_RUM_PROFILER_CONFIGURATION","sampleIntervalMs","collectIntervalMs","minProfileDurationMs","minNumberOfSamples","createRumProfiler","lifeCycle","profilingContextManager","createEncoder","profilerConfiguration","transport","isLongAnimationFrameEnabled","LONG_ANIMATION_FRAME","lastViewEntry","globalCleanupTasks","instance","state","startNextProfilerInstance","globalThisProfiler","Profiler","error_reason","collectProfilerInstance","catch","cleanupTasks","existingInstance","trackLongTasks","PerformanceObserver","handlePerformance","observe","entryTypes","rawEventCollectedSubscription","disconnect","viewUpdatedSubscription","viewEntry","location","pathname","collectViewEntry","profiler","sampleInterval","Math","round","includes","handleSampleBufferFull","async","lastInstance","_b","handleLongTaskEntries","takeRecords","removeEventListener","collectClocks","trace","hasLongTasks","isBelowDurationThreshold","isBelowSampleThreshold","samples","numberOfSamples","sample","stackId","getNumberOfSamples","findTrackedSession","send","handleProfilerTrace","assign","clocksOrigin","relative","stopProfilerInstance","nextState","cleanupTask","list","getEntries","entries","entry","duration","entryType","handleVisibilityChange","visibilityState","handleBeforeUnload","task","isStopped","isRunning","isPaused","requestIdleCallback","opts","cancelIdleCallback","didTimeout","timeRemaining","max","MAX_TASK_TIME","requestIdleCallbackShim","isChromium","detectBrowserCached","isSafari","browserCache","browserWindow","userAgent","chrome","vendor","indexOf","detectBrowser","jsonStringify","replacer","space","detachToJsonMethod","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","createHandlingStack","formattedStack","toStackTraceString","formatErrorMessage","frame","func","line","column","url","normalizeUrl","buildUrl","href","isValidUrl","getPathName","base","URL","getPristineGlobalObjectCache","iframe","pristineWindow","createElement","style","body","appendChild","contentWindow","getPristineWindow","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","getPrivacyLevel","getAllowedWebViewHosts","eventType","bridgeSupports","capability","bridge","canUseEventBridge","currentHost","hostname","some","allowedHost","endsWith","createBatch","encoder","request","flushController","messageBytesLimit","upsertBuffer","flushSubscription","flushObservable","upsertMessages","pageMightExit","reason","sendOnExit","isAsync","encoderResult","finishSync","outputBytesCount","formatPayloadFromEncoder","pendingMessages","pendingData","Boolean","bytesCount","isEmpty","finish","flush","addOrUpdate","serializedMessage","estimatedMessageBytesCount","estimateEncodedBytesCount","hasMessageFor","removedMessage","messageBytesCount","notifyAfterRemoveMessage","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","upsert","output","Blob","encoding","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","sendStrategy","trackType","reportError","requestObservable","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","bandwidth","stats","scheduleRetry","first","dequeue","currentBackoffTime","min","shouldRetryRequest","ongoingRequestCount","retry","count","lastFailureStatus","isFull","queueFullReported","AGENT","previousQueue","newPayloadQueue","createHttpRequest","endpointBuilders","bytesLimit","retryState","ongoingByteCount","endpointBuilder","onResponse","fetchKeepAliveStrategy","sendBeaconStrategy","sendBeacon","beaconUrl","build","hasReportedBeaconError","reportBeaconError","fetchStrategy","Request","isKeepAliveSupported","fetchUrl","fetch","keepalive","mode","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","candidate","TextEncoder","encode","concatBuffers","buffers","reduce","total","Uint8Array","offset","DISCARDED","SKIPPED","abstractHooks","callbacks","register","hookName","unregister","cb","triggerHook","param","hookCallbacks","results","createFlushController","messagesLimit","durationLimit","pageMayExitObservable","sessionExpireObservable","pageMayExitSubscription","sessionExpireSubscription","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","flushReason","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","trackRuntimeError","handleRuntimeError","rawError","SOURCE","stopInstrumentingOnError","messageObj","errorObj","computeStackTrace","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","BUFFER_LIMIT","createIdentityEncoder","additionalEncodedBytesCount","rawBytesCount","defineContextMethod","getStrategy","contextName","methodName","usage","feature","CustomerContextKey","userContext","globalContext","accountContext","ContextManagerMethod","getContext","setContext","setContextProperty","removeContextProperty","clearContext","displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","RumEventType","ACTION","ERROR","VIEW","RESOURCE","VITAL","RumLongTaskEntryType","ViewLoadingType","INITIAL_LOAD","ROUTE_CHANGE","BF_CACHE","ActionType","CLICK","CUSTOM","FrustrationType","RAGE_CLICK","ERROR_CLICK","DEAD_CLICK","VitalType","DURATION","OPERATION_STEP","generateUUID","placeholder","parseInt","random","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","exec","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","startVitalCollection","pageStateHistory","customVitalsState","addDurationVital","vital","wasInPageStateDuringPeriod","isValid","processVital","addOperationStepVital","stepType","failureReason","FEATURE_OPERATION_VITAL","operationKey","startDurationVital","stopDurationVital","nameOrRef","vitalsByName","vitalsByReference","reference","__dd_vital_reference","stopCallback","vitalStart","stopOptions","stopClocks","buildDurationVital","vitalData","step_type","operation_key","failure_reason","date","domainContext","callPluginsMethod","plugins","parameter","plugin","removeItem","array","item","index","splice","isNonEmptyArray","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","contextManager","productKey","customerDataType","storageKey","buildStorageKey","getFromStorage","changeObservable","localStorage","setItem","contextFromStorage","rawContext","getItem","ensureProperties","propertiesConfig","newContext","required","isDefined","createContextManager","maybeContext","checkContext","buildGlobalContextManager","buildUserContextManager","email","buildAccountContextManager","fetchObservable","initCookieParsed","getCurrentSiteCache","initFetchObservable","input","methodFromParams","toUpperCase","responsePromise","startContext","reportFetch","partialContext","responseType","isAborted","signal","aborted","DOMException","code","ABORT_ERR","afterSend","beforeSend","setCookie","expireDelay","setTime","getTime","sameSite","crossSite","domain","secure","partitioned","getCookie","getInitCookie","findCommaSeparatedValues","deleteCookie","getCurrentSite","referrer","defaultHostName","getCookieDefaultHostName","testCookieName","testCookieValue","domainLevels","candidateDomain","pop","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","_DATADOG_SYNTHETICS_INJECTS_RUM","getSyntheticsTestId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsResultId","_DATADOG_SYNTHETICS_RESULT_ID","isSyntheticsTest","SESSION_STORE_KEY","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_COOKIE_EXPIRATION_DELAY","SESSION_NOT_TRACKED","SessionPersistence","COOKIE","LOCAL_STORAGE","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","EXPIRED","getExpiredSessionState","previousSessionState","expiredSessionState","isExpired","trackAnonymousUser","anonymousId","isSessionInNotStartedState","isSessionStarted","isSessionInExpiredState","sessionState","created","Number","expire","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","matches","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","selectCookieStrategy","cookieOptions","useSecureSessionCookie","usePartitionedCrossSiteSessionCookie","trackSessionAcrossSubdomains","currentSite","buildCookieOptions","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","isLockEnabled","persistSession","storeSessionCookie","retrieveSession","retrieveSessionCookie","expireSession","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","defaultTimeout","LOCAL_STORAGE_TEST_KEY","selectLocalStorageStrategy","testKey","retrievedId","initLocalStorageStrategy","persistInLocalStorage","retrieveSessionFromLocalStorage","expireSessionFromLocalStorage","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","LOCK_EXPIRATION_DELAY","LOCK_SEPARATOR","bufferedOperations","ongoingOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","persistWithLock","lock","currentLock","retrieveStore","isLockExpired","currentStore","retryLater","processedSession","process","sessionStore","currentNumberOfRetries","nextOperations","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionPersistence","sessionStoreStrategyType","allowFallbackToLocalStorage","startSessionStore","computeTrackingType","getSessionStoreStrategy","renewObservable","expireObservable","sessionStateUpdateObservable","watchSessionTimeoutId","synchronizeSession","sessionCache","startSession","throttledExpandOrRenewSession","cancelExpandOrRenewSession","synchronizedSession","trackingType","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","isSessionInCacheOutdated","previousState","newState","expandOrRenewSession","expandSession","getSession","restartSession","updateSessionState","partialSessionState","isMatchOption","itemType","matchList","useStartsWith","EXTENSION_PREFIXES","containsExtensionUrl","str","prefix","ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN","ERROR_NOT_ALLOWED_TRACKING_ORIGIN","isAllowedTrackingOrigins","errorStack","windowOrigin","origin","allowedTrackingOrigins","windowLocation","trimmedLine","trim","isUnsupportedExtensionEnvironment","isAllowed","createEndpointBuilder","extraParameters","buildUrlWithParameters","proxy","normalizedProxyUrl","host","buildEndpointHost","createEndpointUrlWithParametersBuilder","clientToken","internalAnalyticsSubdomain","reverse","buildEndpointParameters","site","usePciIntake","domainParts","extension","computeTransportConfiguration","validateSource","logsEndpointBuilder","rumEndpointBuilder","profilingEndpointBuilder","sessionReplayEndpointBuilder","exposuresEndpointBuilder","computeEndpointBuilders","replicaConfiguration","replica","computeReplicaConfiguration","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","MASK_UNLESS_ALLOWLISTED","TraceContextInjection","ALL","SAMPLED","isString","tag","tagName","isSampleRate","sampleRate","validateAndBuildConfiguration","_c","_d","_e","_f","_g","_h","_j","_k","sessionSampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","telemetryUsageSampleRate","env","service","trackingConsent","catchUserErrors","datacenter","GRANTED","storeContextsAcrossPages","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","variant","sdkVersion","sampleDecisionCache","isSampled","cachedDecision","decision","BigInt","identifier","knuthFactor","twoPow64","sampleUsingKnuthFactor","createSpanIdentifier","createIdentifier","bits","crypto","getRandomValues","Uint32Array","radix","high","low","floor","toPaddedHexadecimalString","padStart","clearTracingIfNeeded","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","tracingOption","allowedTracingUrls","find","traceSampleRate","traceContextInjection","propagatorTypes","tracingHeaders","propagatorType","traceparent","tracestate","b3","propagateTraceBaggage","baggageItems","userId","accountId","baggageHeader","makeTracingHeaders","DEFAULT_PROPAGATOR_TYPES","validateAndBuildRumConfiguration","trackFeatureFlagsForEvents","sessionReplaySampleRate","excludedActivityUrls","tracingOptions","option","expectedItem","isTracingOption","validateAndBuildTracingOptions","baseConfiguration","allowedGraphQlUrls","graphQlOptions","trackPayload","validateAndBuildGraphQlOptions","actionNameAttribute","startSessionReplayRecordingManually","rulePsr","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackBfcacheViews","trackEarlyRequests","subdomain","defaultPrivacyLevel","enablePrivacyForActionName","profilingSampleRate","getSelectedTracingPropagators","usedTracingPropagators","serializeRumConfiguration","baseSerializedConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","telemetry_usage_sample_rate","use_before_send","use_partitioned_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_anonymous_user","session_persistence","allow_fallback_to_local_storage","store_contexts_across_pages","allow_untrusted_events","tracking_consent","use_allowed_tracking_origins","sdk_version","session_replay_sample_rate","start_session_replay_recording_manually","trace_sample_rate","trace_context_injection","propagate_trace_baggage","action_name_attribute","use_allowed_tracing_urls","use_allowed_graph_ql_urls","use_track_graph_ql_payload","selected_tracing_propagators","default_privacy_level","enable_privacy_for_action_name","use_excluded_activity_urls","use_worker_url","compress_intake_requests","track_views_manually","track_user_interactions","track_resources","track_long_task","track_bfcache_views","track_early_requests","getConfigurationTelemetry","track_feature_flags_for_events","remote_configuration_id","remoteConfigurationId","profiling_sample_rate","use_remote_configuration_proxy","remoteConfigurationProxy","NAME_SHORTHAND_FIRST_CHAR_REGEX","NAME_SHORTHAND_CHAR_REGEX","DIGIT_REGEX","UNICODE_CHAR_REGEX","TOKEN_PREDICATE","char","parsingContext","quote","escapeSequence","ALLOWED_NEXT_TOKENS","ALLOWED_SELECTOR_TOKENS","ALLOWED_SELECTOR_DELIMITER_TOKENS","isValidEscapeSequence","ESCAPED_CHARS","b","f","n","r","t","resolveEscapeSequence","fromCharCode","REMOTE_CONFIGURATION_VERSION","SUPPORTED_FIELDS","fetchAndApplyRemoteConfiguration","supportedContextManagers","rumInitConfiguration","metrics","increment","metricName","initMetrics","fetchResult","buildEndpoint","ok","remoteConfiguration","rum","fetchRemoteConfiguration","rumRemoteConfiguration","appliedConfiguration","resolveConfigurationProperty","resolveContextProperty","isObject","rcSerializedType","resolveRegex","resolveDynamicOption","contextItems","strategy","resolvedValue","resolveCookieValue","resolveDomValue","resolveJsValue","extractor","resolvedExtractor","regexResult","extractValue","selector","attribute","element","querySelector","isForbidden","domValue","getAttribute","textContent","current","pathParts","selectors","currentToken","previousToken","currentSelector","token","parseJsonPath","pathPart","applyRemoteConfiguration","pattern","createPreStartStrategy","ignoreInitIfSyntheticsWillInjectRum","startDeflateWorker","trackingConsentState","doStartRum","bufferApiCalls","drain","arg","createBoundedBuffer","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","trackingConsentStateSubscription","tryStartRum","emptyContext","isGranted","initialViewOptions","startRumResult","doInit","eventBridgeAvailable","overrideInitConfigurationForBridge","tryToInit","publicApi","enableExperimentalFeatures","user","getInternalContext","stopSession","addTiming","time","startView","setViewName","setViewContext","setViewContextProperty","getViewContext","addAction","action","addError","providedError","addFeatureFlagEvaluation","preStartContextManager","makeRumPublicApi","startRumImpl","recorderApi","profilerApi","bufferedDataObservable","trackRuntimeErrorImpl","runtimeErrorSubscription","startBufferingData","createDeflateEncoder","streamId","onRumStart","viewHistory","telemetry","hooks","preStartStrategy","createPostStartStrategy","addEvent","sanitizedOptions","rumPublicApi","setTrackingConsent","update","getInitConfiguration","setGlobalContext","getGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","setUser","getUser","setUserProperty","removeUserProperty","clearUser","setAccount","getAccount","setAccountProperty","removeAccountProperty","clearAccount","getSessionReplayLink","startSessionReplayRecording","force","stopSessionReplayRecording","startFeatureOperation","action_type","succeedFeatureOperation","failFeatureOperation","getMutationObserverConstructor","Zone","getZoneJsOriginalValue","MutationObserver","patchedInstance","originalInstance","LifeCycle","eventCallbacks","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","cleanupHistoriesInterval","createValueHistory","maxEntries","clearExpiredValues","oldTimeThreshold","endTime","close","unshift","returnInactive","closeActive","latestEntry","findAll","reset","VIEW_CONTEXT_TIME_OUT_DELAY","xhrObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","ResourceType","DOCUMENT","XHR","BEACON","FETCH","CSS","JS","IMAGE","FONT","MEDIA","OTHER","RequestType","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","computeResourceEntryType","isType","areInOrder","numbers","isResourceEntryRequestType","computeResourceEntryDetails","hasValidResourceEntryTimings","fetchStart","workerStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","responseEnd","details","download","formatTiming","first_byte","worker","connect","ssl","dns","redirect","hasValidResourceEntryDuration","areCommonTimingsInOrder","areRedirectionTimingsInOrder","hasRedirection","computeResourceEntryProtocol","nextHopProtocol","computeResourceEntryDeliveryType","deliveryType","computeResourceEntrySize","encodedBodySize","decodedBodySize","transferSize","encoded_body_size","decoded_body_size","transfer_size","isAllowedRequestUrl","every","isIntakeUrl","TRACK_INTAKE_REQUESTS","DATA_URL_REGEX","MAX_RESOURCE_VALUE_CHAR_LENGTH","sanitizeIfLongDataUrl","lengthLimit","dataUrlMatchArray","substring","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","Headers","header","traceXhr","setRequestHeader","startTracer","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","collectStreamBody","completeBuffer","chunk","readMore","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","discardNegativeDuration","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","retrieveFirstInputTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","timing","processingStart","processingEnd","sendTiming","sendTimingIfPointerIsNotCancelled","RumPerformanceEntryType","createPerformanceObservable","handlePerformanceEntries","rumPerformanceEntries","isForbiddenResource","filterRumPerformanceEntries","isObserverInitializing","NAVIGATION","PAINT","buffered","performance","getEntriesByType","stopFirstInputTiming","resourceTimingBufferFullListener","clearResourceTimings","manageResourceTimingBufferFull","supportPerformanceTimingEvent","FIRST_INPUT","supportedEntryTypes","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","hasChildNodes","childNodes","forEachChildNodes","child","firstChild","nextSibling","getParentNode","parentNode","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","EXCLUDED_MUTATIONS_ATTRIBUTE","waitPageActivityEnd","domMutationObservable","windowOpenObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","mutations","isExcludedMutation","notifyPageActivity","isExcludedUrl","startEvent","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","mutation","targetElement","parentElement","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","ACTION_NAME_PLACEHOLDER","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","className","getSelectorFromElement","isConnected","targetElementSelector","currentElement","nodeName","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","getAttributeSelector","hasAttribute","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","predicate","childSelector","selectorGetter","elementSelector","ownerDocument","querySelectorAll","currentElementSelector","isSiblingMatching","scopedSelector","parent","NodePrivacyLevel","IGNORE","HIDDEN","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_PREFIX","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getPrivacySelector","privacyLevel","getNodePrivacyLevel","cache","parentNodePrivacyLevel","nodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","inputElement","autocomplete","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","isFormElement","isAllowlisted","censorText","text","getTextContent","textNode","parentTagName","fixedMask","maskDisallowedTextContent","$DD_ALLOW","toLocaleLowerCase","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","bufferedClicks","maxDurationBetweenClicksTimeoutId","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","tryAppend","second","sqrt","pow","clientX","clientY","getActionNameFromElementProgrammatically","programmaticAttribute","elementWithAttribute","closest","truncate","normalizeWhitespace","priorityStrategies","rumConfiguration","labels","getActionNameFromTextualContent","nameSource","getActionNameFromStandardAttribute","labelledByAttribute","refElement","getElementById","label","getTextualContent","fallbackStrategies","MAX_PARENTS_TO_CONSIDER","getActionNameFromElementForStrategies","strategies","recursionCounter","actionName","trimmedName","isContentEditable","userProgrammaticAttribute","USE_TREE_WALKER_FOR_ACTION_NAME","privacyEnabledActionName","nodePrivacyLevelCache","walker","createTreeWalker","NodeFilter","SHOW_ELEMENT","SHOW_TEXT","rejectInvisibleOrMaskedElementsFilter","nextNode","currentNode","getComputedStyle","nodeSelfPrivacyLevel","FILTER_REJECT","visibility","contentVisibility","FILTER_ACCEPT","getTextualContentWithTreeWalker","innerText","removeTextFromElements","query","textToReplace","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","computeFrustration","clicks","rageClick","getUserActivity","scroll","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","CLICK_ACTION_MAX_DURATION","interactionSelectorCache","updateInteractionSelector","relativeTimestamp","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","history","currentClickChain","stopClickChain","UNLOADING","stopActionEventsListener","onPointerDown","onPointerUp","selectionEmptyAtPointerDown","clickContext","userActivity","listeners","localUserActivity","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","defaultActionName","getActionNameFromElement","width","height","position","x","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","viewEndedSubscription","stopSubscription","startClickAction","actionContexts","findActionId","validate","finalizeClicks","historyEntry","eventCountsSubscription","activityEndTime","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","events","processAction","autoActionProperties","isAutoAction","loading_time","resource","name_source","actionEvent","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","formatConsoleParameters","firstErrorParam","CONSOLE","buildConsoleLog","createConsoleObservable","RawReportType","intervention","deprecation","cspViolation","initReportObservable","blockedURI","effectiveDirective","buildRawReportError","csp","disposition","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportErrorFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportErrorFromReport","types","createReportObservable","partial","REPORT","startErrorCollection","errorObservable","bufferedData","consoleLog","trackConsoleError","trackReportError","handling_stack","component_stack","source_type","processError","doStartErrorCollection","IDLE_CALLBACK_TIMEOUT","MAX_EXECUTION_TIME_ON_TIMEOUT","alreadyMatchedEntries","WeakSet","matchRequestResourceEntry","sameNameEntries","getEntriesByName","candidates","errorMargin","isBetween","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","traceIdMeta","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","getNavigationEntry","navigationEntry","timings","numberKey","timingElement","computeTimingsFromDeprecatedPerformanceTiming","loadEventEnd","retrieveInitialDocumentResourceTiming","getNavigationEntryImpl","MAX_REQUESTS","GRAPHQL_PAYLOAD_LIMIT","startResourceCollection","taskQueue","pendingTasks","run","deadline","executionTimeRemaining","now","scheduleNextRun","timeout","createTaskQueue","retrieveInitialDocumentResourceTimingImpl","requestRegistry","isEarlyRequestCollectionEnabled","requests","values","getMatchingRequest","closestRequest","minTimeDifference","timeDifference","abs","createRequestRegistry","handleResource","matchingTiming","assembleResource","processRequest","performanceResourceSubscription","processResourceEntry","computeRawEvent","rawEvent","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","computeRequestTracingInfo","computeResourceEntryTracingInfo","computeResourceEntryDuration","computeRequestDuration","graphql","graphQlConfig","graphQlOption","findGraphQlConfiguration","requestBody","graphqlBody","operationType","getOperationType","operationName","variables","extractGraphQlMetadata","computeGraphQlMetaData","resourceEvent","status_code","statusCode","responseStatus","protocol","delivery_type","renderBlockingStatus","render_blocking_status","computeResourceEntryMetrics","getResourceDomainContext","baseDomainContext","performanceEntry","requestInput","requestInit","getTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","FCP_MAXIMUM_DELAY","trackNavigationTimings","stopOnReadyState","waitAfterLoadEvent","isIncompleteNavigation","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","processNavigationEntry","LCP_MAXIMUM_DELAY","trackFirstHidden","viewStart","VISIBILITY_STATE","firstHiddenEntry","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","navigationTimings","firstHidden","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","biggestLcpSize","performanceLcpSubscription","LARGEST_CONTENTFUL_PAINT","lcpEntry","lcpTargetSelector","targetSelector","resourceUrl","trackLargestContentfulPaint","largestContentfulPaint","stopFIDTracking","performanceFirstInputSubscription","firstInputEntry","firstInputDelay","firstInputTargetSelector","trackFirstInput","firstInput","calculateArea","getClsAttributionImpactedArea","previousRect","currentRect","rect1","rect2","right","bottom","calculateIntersectionArea","trackCumulativeLayoutShift","LAYOUT_SHIFT","biggestShift","maxClsValue","slidingWindow","cumulatedValue","maxValue","isMaxValue","MAX_UPDATE_GAP","MAX_WINDOW_DURATION","slidingSessionWindow","performanceSubscription","hadRecentInput","attribution","getTopImpactedElement","sources","WeakRef","devicePixelRatio","deref","asRumRect","topImpactedSource","currentImpactedArea","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","getInteractionCount","interactionCount","MAX_INTERACTION_ENTRIES","MAX_INP_VALUE","trackInteractionToNextPaint","viewLoadingType","EVENT","PerformanceEventTiming","getInteractionToNextPaint","setViewEnd","getViewInteractionCount","stopViewInteractionCount","interactionId","durationThreshold","previousInteractionCount","computeViewInteractionCount","trackViewInteractionCount","viewEnd","longestInteractions","sortAndTrimLongestInteractions","sort","a","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaintTargetSelector","interactionToNextPaintStartTime","interactionToNextPaint","handleEntries","newInteraction","getInteractionSelector","firstInputSubscription","eventSubscription","viewEndTime","getScrollX","scrollX","visual","visualViewport","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","viewportObservable","initViewportObservable","updateDimension","getViewportDimension","createViewportObservable","scale","innerWidth","innerHeight","THROTTLE_SCROLL_DURATION","trackScrollMetrics","scrollValues","throttleDuration","scrollTop","scrollHeight","scrollingElement","documentElement","scrollDepth","computeScrollValues","ResizeObserver","throttledNotify","observerTarget","resizeObserver","eventListener","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","maxDepth","maxDepthScrollTop","trackCommonViewMetrics","loadingType","commonViewMetrics","stopLoadingTimeTracking","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","loadingTime","trackLoadingTime","newLoadingTime","stopScrollMetricsTracking","newScrollMetrics","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","getCommonViewMetrics","trackBfcacheMetrics","viewStartRelative","paintTime","requestAnimationFrame","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","activeViews","stopOnBFCacheRestore","locationChangeSubscription","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","customTimings","documentVersion","sessionIsActive","viewCreatedEvent","cancelScheduleViewUpdate","triggerViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","stopEventCountsTracking","trackViewEventCounts","keepAliveIntervalId","pageMayExitEvent","triggerBeforeViewUpdate","currentEnd","isActive","relativeTime","sanitized","sanitizeTiming","updatedName","newView","oldLocation","newLocation","currentLocation","otherLocation","hash","correspondingId","isHashAnAnchor","getPathFromHash","renewViewOnLocationChange","persisted","onBFCacheRestore","pageshowEvent","startViewCollection","pageOpenObservable","_l","_m","_o","_p","_q","_r","_s","_t","clsDevicePixelRatio","viewEvent","document_version","replay_stats","cls","device_pixel_ratio","cumulative_layout_shift","cumulative_layout_shift_time","cumulative_layout_shift_target_selector","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","first_input_target_selector","interaction_to_next_paint","interaction_to_next_paint_time","interaction_to_next_paint_target_selector","is_active","largest_contentful_paint","largest_contentful_paint_target_selector","load_event","loading_type","computeViewPerformanceData","time_spent","max_depth","max_depth_scroll_top","max_scroll_height","max_scroll_height_time","privacy","replay_level","device","locale","language","locales","languages","time_zone","custom_timings","processViewUpdate","findView","score","timestamp","target_selector","previous_rect","current_rect","fcp","fid","inp","lcp","resource_url","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","SHORT_SESSION_INVESTIGATION","initialSessionState","sessionCreatedTime","sdkInitTime","changed","change","sessionAge","newSessionState","getSessionCookies","session_age","old","new","detectSessionIdChange","isReplayForced","forcedReplay","rawSession","createdTimestamp","expireTimestamp","currentDomain","reportUnexpectedSessionState","trackActivity","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","trackResume","findSession","sessionCookies","getAll","startRumSessionManager","rawTrackingType","sessionEntity","sessionReplay","setForcedReplay","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","getHistoryInstrumentationTarget","stopInstrumentingReplaceState","removeListener","trackHistory","onLocationChange","stopHashTracking","onHashChange","trackHash","History","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","MEASURES_PERIOD_DURATION","currentPeriodMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","batchBytesCount","batchMessagesCount","MAX_PAGE_STATE_ENTRIES","MAX_PAGE_STATE_ENTRIES_SELECTABLE","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","startPageStateHistory","maxPageStateEntriesSelectable","pageStateEntryHistory","currentPageState","addPageState","getPageState","stopEventListeners","computePageState","nextPageState","pageState","page_states","processPageStates","in_foreground","pageStateEntries","eventStartTime","hasFocus","createCookieObservable","cookieName","detectCookieChangeStrategy","changeEvent","deleted","listenToCookieStoreChange","watchCookieFallback","WATCH_COOKIE_INTERVAL_DELAY","previousCookieValue","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","limitModification","modifiableFieldPaths","modifier","fieldPath","fieldType","setValueAtPath","pathSegments","field","restPathSegments","isValidObject","newType","setNestedValue","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","ROOT_MODIFIABLE_FIELD_PATHS","modifiableFieldPathsByEvent","startRumAssembly","eventRateLimiters","defaultRumEventAttributes","serverRumEvent","ddtags","rateLimitReached","shouldSend","createHooks","allowedEventTypes","startRum","startRumSessionManagerStub","startRumEventBridge","batch","endpoints","startRumBatch","batchFlushObservable","metricsEnabled","startCustomerDataTelemetry","records","characterData","childList","subtree","createDOMMutationObservable","stopWindowOpen","createWindowOpenObservable","format_version","drift","browser_sdk_version","sdk_name","startDefaultContext","viewValueHistory","buildViewHistoryEntry","viewUpdate","startViewHistory","urlContexts","urlContextHistory","previousViewUrl","viewUrl","buildUrlContext","changeTime","urlContext","findUrl","startUrlContexts","featureFlagContexts","featureFlagContext","feature_flags","currentContext","startFeatureFlagContexts","hasReplay","sampledForReplay","isRecording","has_replay","sampled_for_replay","startSessionContext","connectivity","startConnectivityContext","startTrackingConsentContext","useContextNamespace","globalContextManager","startGlobalContext","userContextManager","anonymous_id","usr","startUserContext","accountContextManager","account","startAccountContext","stopRumEventCollection","actionCollection","unsubscribeAutoAction","actionId","startActionCollection","eventCollection","startEventCollection","displayContext","viewport","animationFrameId","unsubscribeViewport","viewportDimension","cancelAnimationFrame","startDisplayContext","ciVisibilityContext","cookieObservable","testExecutionId","Cypress","cookieObservableSubscription","ci_test","test_execution_id","startCiVisibilityContext","synthetics","test_id","result_id","injected","startSyntheticsContext","startRumEventCollection","stopViewCollection","stopInitialViewMetricsTelemetry","navigation","startInitialViewMetricsTelemetry","stopResourceCollection","stopLongAnimationFrameCollection","entry_type","blocking_duration","blockingDuration","first_ui_event_timestamp","firstUIEventTimestamp","render_start","renderStart","style_and_layout_start","styleAndLayoutStart","start_time","scripts","script","pause_duration","pauseDuration","forced_style_and_layout_duration","forcedStyleAndLayoutDuration","execution_start","executionStart","source_url","sourceURL","source_function_name","sourceFunctionName","source_char_position","sourceCharPosition","invoker","invoker_type","invokerType","window_attribution","windowAttribution","startLongAnimationFrameCollection","performanceLongTaskSubscription","startLongTaskCollection","vitalCollection","internalContext","viewContext","application_id","session_id","user_action","startInternalContext","getSessionReplayUrl","errorType","getSiteDefaultSubdomain","getDatadogSiteUrl","createFormDataTransport","httpRequest","formData","FormData","serializedEvent","serializedValue","__symbol__","TelemetryType","LOG","CONFIGURATION","USAGE","ALLOWED_FRAME_URLS","METRIC_SAMPLE_RATE","TELEMETRY_EXCLUDED_SITES","telemetryObservable","getTelemetryObservable","startTelemetry","telemetryService","telemetrySubscription","isTelemetryReplicationAllowed","telemetryBatch","startTelemetryTransport","enabled","metricSampleRate","alreadySentEventsByKind","telemetryEnabled","telemetryEnabledPerType","metric","runtimeEnvInfo","is_local_file","is_worker","kind","alreadySentEvents","stringifiedEvent","defaultTelemetryEventAttributes","toTelemetryEvent","addTelemetryError","runtime_env","sdk_setup","experimental_features","startTelemetryCollection","addTelemetryDebug","formatError","addTelemetryConfiguration","addTelemetryMetrics","addTelemetryUsage","scrubCustomerFrames","allowedFrameUrl","mergeInto","destination","circularReferenceChecker","hasAlreadyBeenSeen","createCircularReferenceChecker","flags","global","ignoreCase","multiline","sticky","unicode","merged","deepClone","combine","shallowClone","objectHasValue","isEmptyObject","mapValues","newObject","makePublicApi","stub","onReady","defineGlobal","existingGlobalVariable","q","TrackingConsent","NOT_GRANTED","createTrackingConsentState","currentConsent","ErrorSource","LOGGER","NETWORK","UNKNOWN_FUNCTION","ex","stackProperty","tryToGetString","exString","stackFrame","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","isWronglyReportingCustomErrorsCache","DatadogTestCustomError","customError","nativeError","errConstructor","isNonNativeClassPrototype","isWronglyReportingCustomErrors","constructors","currentPrototype","constructorName","fileUrl","filePosition","computeStackTraceFromOnErrorMessage","ERROR_TYPES_RE","tryToParseMessage","errorMsg","err","RecordType","FullSnapshot","IncrementalSnapshot","Meta","Focus","ViewEnd","VisualViewport","FrustrationRecord","NodeType","Document","DocumentType","Text","CDATA","DocumentFragment","IncrementalSource","Mutation","MouseMove","MouseInteraction","Scroll","ViewportResize","Input","TouchMove","MediaInteraction","StyleSheetRule","MouseInteractionType","MouseUp","MouseDown","Click","ContextMenu","DblClick","Blur","TouchStart","TouchEnd","MediaInteractionType","Play","Pause","isTouchEvent","changedTouches","getEventTarget","composed","composedPath","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","isVisualViewportFactoredIn","getVisualViewport","assembleIncrementalSnapshot","MOUSE_MOVE_OBSERVER_THRESHOLD","trackMove","scope","moveCb","updatePosition","cancelThrottle","nodeIds","coordinates","tryToComputeCoordinates","timeOffset","positions","isFinite","eventTypeToMouseInteraction","trackMouseInteraction","mouseInteractionCb","recordIds","record","getIdForEvent","SCROLL_OBSERVER_THRESHOLD","trackScroll","scrollCb","elementsScrollPositions","scrollPositions","scrollLeft","VISUAL_VIEWPORT_OBSERVER_THRESHOLD","trackViewportResize","viewportResizeCb","viewportResizeSubscription","trackVisualViewportResize","visualViewportResizeCb","trackMediaInteraction","mediaInteractionCb","trackStyleSheet","styleSheetCb","checkStyleSheetAndCallback","styleSheet","ownerNode","instrumentationStoppers","CSSStyleSheet","rule","adds","removes","instrumentGroupingCSSRuleClass","parentStyleSheet","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","stopper","currentRule","parentRule","cssRules","trackFocus","focusCb","has_focus","trackFrustration","frustrationCb","frustrationSubscription","trackViewEnd","viewEndCb","viewEndSubscription","getElementInputValue","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","censoredImageForSize","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRule","disabled","media","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","serializeAttribute","attributeValue","image","naturalWidth","naturalHeight","updateSerializationStats","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","isCSSStyleRule","selectorText","escapeColon","isCSSImportRule","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","isSVG","el","SVGElement","rr_width","rr_height","safeAttrs","doc","formValue","optionElement","selected","stylesheet","styleSheets","serializationStats","_cssText","sheet","checked","mediaElement","rr_mediaState","paused","rr_scrollLeft","rr_scrollTop","serializeAttributes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","serializedNodeWithId","serializedNodeIds","childNode","serializedChildNode","serializeDocument","serializationStart","trackInput","inputCb","lastInputStateMap","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","onElementChange","stopPropertySetterInstrumentation","inputState","isChecked","cbWithDedup","lastInputState","MUTATION_PROCESS_MAX_DELAY","MUTATION_PROCESS_MIN_DELAY","trackMutation","mutationCallback","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","throttledFlush","addMutations","createMutationBatch","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","areAssignedForNodeAndAncestors","serializationDuration","hasBeenSerialized","addedAndMovedNodes","addedNodes","sortedAddedAndMovedNodes","nodes","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","nextId","getNextSibling","parentId","removedNodeMutations","processChildListMutations","texts","textMutations","handledNodes","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","attributeOldValue","characterDataOldValue","shadowDomRemovedCallback","initShadowRootsController","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","emit","emitAndComputeStats","scrollPositionsByElement","createElementsScrollPositions","nextNodeId","nodeId","createNodeIds","stopFullSnapshots","flushMutations","takeFullSnapshot","initialOffset","startFullSnapshots","initRecordIds","trackers","viewEndRecord","tracker","createSegment","creationReason","encodedBytesCount","metadata","creation_reason","has_full_snapshot","index_in_view","aggregateStats","aggregateSerializationStats","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageMayExit","segment","rawSegmentBytesCount","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","isFullSnapshot","rawSize","recordCount","buildReplayPayload","expirationTimeoutId","doStartSegmentCollection","computeSegmentContext","startRecording","replayRequest","startRecordBridge","segmentCollection","segmentTelemetry","requestEvent","bandwidthStats","ongoingRequests","totalSize","compressed","raw","startSegmentTelemetry","stopRecording","ExperimentalFeature","enabledExperimentalFeatures","initFeatureFlags","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","performDraw","threshold","num","decimals","toFixed","isPercentage","isNumber","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","getCorrectedTimeStamp","timeStampToClocks","getRelativeTime","correctedOrigin","dateNow","getNavigationStart","addDuration","getTimeStamp","currentDrift","toServerDuration","timeStampNow","relativeNow","clocksNow","elapsed","looksLikeRelativeTime","navigationStart","timeOrigin","PageExitReason","PAGEHIDE","FROZEN","createPageMayExitObservable","stopListeners","stopBeforeUnloadListener","isPageExitReason","findLast","objectValues","objectEntries","TAG_SIZE_LIMIT","buildTags","buildTag","rawValue","supportUnicodePropertyEscapes","hasForbiddenCharacters","sanitizeTag","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","obj","prop","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","workerResponse","nextPendingAction","trailer","writeCallback","finishCallback","consumeResult","sendResetIfNeeded","postMessage","pendingWriteAction","reportScriptLoadingError","configuredUrl","scriptType","baseMessage","INITIALIZATION_TIME_OUT_DELAY","createDeflateWorker","Worker","createObjectURL","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener","onError","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","worker_version","stream_id","isBrowserSupported","NodeList","isRecordingStarted","getErrorType","loadRecorder","getOrCreateDeflateEncoder","documentReadyDuration","recorderSettledDuration","forced","loadRecorderModuleDuration","recorderInitDuration","waitForDocReadyDuration","startRecorderInitTelemetry","doStart","startRecordingImpl","all","notifyWhenSettled","deflateEncoder","canStartRecording","isRecordingInProgress","shouldForceReplay","promise","importRecorder","lazyLoadProfiler","importProfilerImpl","importProfiler","shouldStartImmediately","cachedDeflateEncoder","makeRecorderApi","importRecorderImpl","profiling","startProfilingContext","makeProfilerApi","datadogRum","checkConsentTypePresent","consentType","packageConsent","datadogEnvironment","datadogVersion","datadogSampleRate","statistics","packageConsented"],"sourceRoot":""}