{"version":3,"file":"datadog.js","mappings":"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","sources":["webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/fetch.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/pageMayExitObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/connectivity/connectivity.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/intakeSites.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/tags.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/domain/trackingConsent.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/abstractHooks.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/encoder.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/globalObject.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/mockable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/monitor.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/@datadog/browser-core/esm/tools/requestIdleCallback.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/computeStackTrace.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/handlingStack.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/timer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.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/objectUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.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/urlPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/flushController.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/domain/error/trackRuntimeError.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/tools/utils/stringUtils.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-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/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/tools/readBytesFromStream.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-rum-core/esm/domain/hooks.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/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/storeStrategies/sessionInCookie.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/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/storeStrategies/sessionInMemory.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/configuration/configuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/extractRegexMatch.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-core/esm/tools/boundedBuffer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/contexts/tabContext.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-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/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/resource/graphql.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/discardNegativeDuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.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/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/trackEventCounts.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/eventTracker.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/getComposedPathSelector.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/isActionChildEvent.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-rum-core/esm/domain/action/trackManualActions.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/resourceCollection.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/trackManualResources.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-rum-core/esm/domain/longTask/longTaskCollection.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/event/eventCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/sourceCodeContext.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/domain/contexts/trackingConsentContext.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/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/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/contexts/internalContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/bufferedData.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-rum/esm/types/sessionReplayConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/experimentalFeatures.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/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/serializationStats.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationTransaction.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/changeEncoder.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeFullSnapshot.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNodeAsChange.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/insertionCursor.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeFullSnapshotAsChange.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/serialization/serializeMutations.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeMutationsAsChange.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/startFullSnapshots.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/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/trackViewEnd.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/trackers/trackMutation.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/itemIds.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/recordingScope.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/shadowRootsController.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.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/domain/segmentCollection/startSegmentTelemetry.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/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/longTaskHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/actionHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/profiling/vitalHistory.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-rum/esm/domain/replayStats.js","webpack://market-storefront/./node_modules/@envato/cookiebot-wrapper/dist/index.js","webpack://market-storefront/./node_modules/@envato/cookiebot-wrapper/node_modules/js-cookie/src/js.cookie.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/lazyLoadRecorder.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/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":["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.33.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 { 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 { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\nimport { getGlobalObject } from '../tools/globalObject';\n/**\n * Make a fetch request using the native implementation, bypassing Zone.js patching.\n * This prevents unnecessary Angular change detection cycles.\n *\n * @param input - The resource to fetch (URL or Request object)\n * @param init - Optional fetch options\n * @returns A Promise that resolves to the Response\n */\nexport function fetch(input, init) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'fetch')(input, init);\n}\n//# sourceMappingURL=fetch.js.map","import { Observable } from '../tools/observable';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isWorkerEnvironment } from '../tools/globalObject';\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        if (isWorkerEnvironment) {\n            // Page exit is not observable in worker environments (no window/document events)\n            return;\n        }\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","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","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 { sanitize } from '../../tools/serialisation/sanitize';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { isIndexableObject } from '../../tools/utils/typeUtils';\nexport const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nfunction computeErrorBase({ originalError, stackTrace, source, useFallbackStack = true, nonErrorPrefix, }) {\n    const isErrorInstance = isError(originalError);\n    if (!stackTrace && isErrorInstance) {\n        stackTrace = computeStackTrace(originalError);\n    }\n    return {\n        source,\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    };\n}\nexport function computeRawError({ stackTrace, originalError, handlingStack, componentStack, startClocks, nonErrorPrefix, useFallbackStack = true, source, handling, }) {\n    const errorBase = computeErrorBase({ originalError, stackTrace, source, useFallbackStack, nonErrorPrefix });\n    return {\n        startClocks,\n        handling,\n        handlingStack,\n        componentStack,\n        originalError,\n        ...errorBase,\n        causes: isError(originalError) ? 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\n                ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))}`\n                : 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 (isIndexableObject(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    const causes = [];\n    let currentCause = error.cause;\n    while (currentCause !== undefined && currentCause !== null && causes.length < 10) {\n        const causeBase = computeErrorBase({\n            originalError: currentCause,\n            source: parentSource,\n            useFallbackStack: false,\n        });\n        causes.push(causeBase);\n        currentCause = isError(currentCause) ? currentCause.cause : undefined;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.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","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 INTAKE_SITE_US2_FED = 'us2.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 { 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    MEMORY: 'memory',\n    LOCAL_STORAGE: 'local-storage',\n};\n//# sourceMappingURL=sessionConstants.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.33.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","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, INTAKE_SITE_US2_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 { createIdentityEncoder } from '../../tools/encoder';\nimport { createPageMayExitObservable } from '../../browser/pageMayExitObservable';\nimport { DISCARDED } from '../../tools/abstractHooks';\nimport { globalObject, isWorkerEnvironment } from '../../tools/globalObject';\nimport { noop } from '../../tools/utils/functionUtils';\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, INTAKE_SITE_US2_FED];\nconst MAX_TELEMETRY_EVENTS_PER_PAGE = 15;\nlet telemetryObservable;\nexport function getTelemetryObservable() {\n    if (!telemetryObservable) {\n        telemetryObservable = new BufferedObservable(100);\n    }\n    return telemetryObservable;\n}\nexport function startTelemetry(telemetryService, configuration, hooks) {\n    const observable = new Observable();\n    const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hooks, observable);\n    const { stop } = startTelemetryTransport(configuration, observable);\n    return {\n        stop,\n        enabled,\n        metricsEnabled,\n    };\n}\nexport function startTelemetryCollection(telemetryService, configuration, hooks, observable, metricSampleRate = METRIC_SAMPLE_RATE, maxTelemetryEventsPerPage = MAX_TELEMETRY_EVENTS_PER_PAGE) {\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 >= 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.33.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}\nexport function startTelemetryTransport(configuration, 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: createIdentityEncoder(),\n            request: createHttpRequest(endpoints, \n            // Ignore transport errors for telemetry\n            noop),\n            flushController: createFlushController({\n                pageMayExitObservable: createPageMayExitObservable(configuration),\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        });\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 { 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","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 { 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","/* 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 { 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","/**\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[\"START_STOP_ACTION\"] = \"start_stop_action\";\n    ExperimentalFeature[\"START_STOP_RESOURCE\"] = \"start_stop_resource\";\n    ExperimentalFeature[\"USE_CHANGE_RECORDS\"] = \"use_change_records\";\n    ExperimentalFeature[\"USE_INCREMENTAL_CHANGE_RECORDS\"] = \"use_incremental_change_records\";\n    ExperimentalFeature[\"TOO_MANY_REQUESTS_INVESTIGATION\"] = \"too_many_requests_investigation\";\n    ExperimentalFeature[\"TRACK_RESOURCE_HEADERS\"] = \"track_resource_headers\";\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","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","/**\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","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 && typeof method === 'string' && 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 { 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 const mockableReplacements = new Map();\n/**\n * Wraps a value to make it mockable in tests. In production builds, this is a no-op\n * that returns the value as-is. In test builds, it checks if a mock replacement has\n * been registered and returns that instead.\n *\n * @example\n * // In source file:\n * import { mockable } from '../tools/mockable'\n * export function formatNavigationEntry(): string {\n *   const navigationEntry = mockable(getNavigationEntry)()\n *   ...\n * }\n *\n * // In test file:\n * import { replaceMockable } from '@datadog/browser-core/test'\n * it('...', () => {\n *   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)\n *   expect(formatNavigationEntry()).toEqual(...)\n * })\n */\nexport function mockable(value) {\n    // In test builds, return a wrapper that checks for mocks at call time\n    if (\"6.33.0\" === 'test' && mockableReplacements.has(value)) {\n        return mockableReplacements.get(value);\n    }\n    // In production, return the value as-is\n    return value;\n}\n//# sourceMappingURL=mockable.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 (...args) {\n        return callMonitored(fn, this, args);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\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","import { monitor } from './monitor';\nimport { globalObject } from './globalObject';\nexport function queueMicrotask(callback) {\n    // Intentionally avoid .bind(globalObject): in some environments (e.g. Selenium GeckoDriver's\n    // executeScript), globalThis is not a proper global object, so calling the bound function throws\n    // 'queueMicrotask called on an object that does not implement interface Window'. Calling it as an\n    // unbound method is fine, as the proper global object will be used implicitly.\n    // See https://github.com/mozilla/geckodriver/issues/1798\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const nativeImplementation = globalObject.queueMicrotask;\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","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","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","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 { 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, ...\nexport const 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","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\nimport { isIndexableObject } from '../utils/typeUtils';\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 htmlAnonymousPart = '(?:(.*)?(?: @))';\nconst CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\\\s*at\\\\s*${htmlAnonymousPart}?\\\\s*${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[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: parts[2],\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    return isIndexableObject(candidate) && typeof candidate[property] === 'string' ? candidate[property] : 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 { 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 { 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","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","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","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    // Optimization: if there is a single buffer, no need to copy it\n    if (buffers.length === 1) {\n        return buffers[0];\n    }\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 { 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","/**\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","export function tryJsonParse(text) {\n    try {\n        return JSON.parse(text);\n    }\n    catch (_a) {\n        // ignore\n    }\n}\nexport 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","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","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","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","/**\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/**\n * Checks whether a value can have properties. Use this when you have an unknown value and you want\n * to access its properties as unknown. This is a friendly solution for dealing with unknown objects\n * in TypeScript.\n *\n * This function is intended to be used on values that will be used as \"plain objects\", i.e. not\n * Array, Date, RegExp or other class instances. But it's safe to use on any value.\n *\n * @example\n * ```\n * // Before:\n * if (typeof value === 'object' && value !== null && 'property' in value && typeof value.property === 'string') {\n *   // use value.property\n * }\n * // After:\n * if (isIndexableObject(value) && typeof value.property === 'string') {\n *   // use value.property\n * }\n * ```\n */\nexport function isIndexableObject(value) {\n    return getType(value) === 'object';\n}\n//# sourceMappingURL=typeUtils.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    var _a;\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 = ((_a = iframe.contentWindow) !== null && _a !== void 0 ? _a : globalObject);\n        }\n        catch (_b) {\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 { 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;\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     * Return all the entries whose start time is equal to the given startTime.\n     */\n    function getEntries(startTime) {\n        return entries.filter((entry) => entry.startTime === startTime);\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 = undefined;\n        }\n    }\n    return { add, find, closeActive, findAll, getEntries, reset, stop };\n}\n/**\n * Reset all global state. This is useful for testing to ensure clean state between tests.\n *\n * @internal\n */\nexport function resetValueHistoryGlobals() {\n    cleanupTasks.clear();\n    clearInterval(cleanupHistoriesInterval);\n    cleanupHistoriesInterval = undefined;\n}\n//# sourceMappingURL=valueHistory.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, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nexport const MESSAGE_BYTES_LIMIT = 256 * ONE_KIBI_BYTE;\nexport function createBatch({ encoder, request, flushController, }) {\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 >= MESSAGE_BYTES_LIMIT) {\n            display.warn(`Discarded a message whose size was bigger than the maximum allowed size ${MESSAGE_BYTES_LIMIT / ONE_KIBI_BYTE}KiB. ${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 { 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 { isWorkerEnvironment } from '../tools/globalObject';\nimport { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\nimport { ONE_SECOND } from '../tools/utils/timeUtils';\nimport { RECOMMENDED_REQUEST_BYTES_LIMIT } from './httpRequest';\n/**\n * flush automatically, aim to be lower than ALB connection timeout\n * to maximize connection reuse.\n */\nexport const FLUSH_DURATION_LIMIT = (30 * ONE_SECOND);\n/**\n * When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent\n * in a single event.\n */\nexport const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50;\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({ pageMayExitObservable, sessionExpireObservable }) {\n    let forcedFlushReason;\n    const preparePageExitFlushObservable = new Observable();\n    const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n        forcedFlushReason = event.reason;\n        try {\n            preparePageExitFlushObservable.notify(event.reason);\n        }\n        finally {\n            forcedFlushReason = undefined;\n        }\n        flush(event.reason);\n    });\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            }, FLUSH_DURATION_LIMIT);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable,\n        preparePageExitFlushObservable,\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 >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n                flush(forcedFlushReason !== null && forcedFlushReason !== void 0 ? forcedFlushReason : '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 >= MESSAGES_LIMIT) {\n                flush(forcedFlushReason !== null && forcedFlushReason !== void 0 ? forcedFlushReason : 'messages_limit');\n            }\n            else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n                flush(forcedFlushReason !== null && forcedFlushReason !== void 0 ? forcedFlushReason : '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 { 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 { fetch } from '../browser/fetch';\nimport { monitor, monitorError } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\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 const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;\nexport function createHttpRequest(endpointBuilders, reportError, bytesLimit = RECOMMENDED_REQUEST_BYTES_LIMIT) {\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) => {\n                    fetchStrategy(endpointBuilder, payload, onResponse);\n                }, 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 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}\n//# sourceMappingURL=httpRequest.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 { 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","/**\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}\n// Assuming input string is following the HTTP Cookie format defined in\n// https://www.ietf.org/rfc/rfc2616.txt and https://www.ietf.org/rfc/rfc6265.txt, we don't need to\n// be too strict with this regex.\nconst COMMA_SEPARATED_KEY_VALUE = /(\\S+?)\\s*=\\s*(.+?)(?:;|$)/g;\n/**\n * Returns the value of the key with the given name\n * If there are multiple values with the same key, returns the first one\n */\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}\n/**\n * Returns a map of all the values with the given key\n * If there are multiple values with the same key, returns all the values\n */\nexport function findAllCommaSeparatedValues(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            const key = match[1];\n            const value = match[2];\n            if (result.has(key)) {\n                result.get(key).push(value);\n            }\n            else {\n                result.set(key, [value]);\n            }\n        }\n        else {\n            break;\n        }\n    }\n    return result;\n}\n/**\n * Returns a map of the values with the given key\n * ⚠️ If there are multiple values with the same key, returns the LAST one\n *\n * @deprecated use `findAllCommaSeparatedValues()` instead\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 { 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    TAP: 'tap',\n    SCROLL: 'scroll',\n    SWIPE: 'swipe',\n    APPLICATION_START: 'application_start',\n    BACK: 'back',\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","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, handlingStack } = 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            handlingStack,\n        };\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processVital(vital));\n    }\n    return {\n        addOperationStepVital,\n        addDurationVital,\n        startDurationVital: (name, options = {}) => {\n            const ref = startDurationVital(customVitalsState, name, options);\n            const vitalState = customVitalsState.vitalsByReference.get(ref);\n            if (vitalState) {\n                lifeCycle.notify(16 /* LifeCycleEventType.VITAL_STARTED */, vitalState);\n            }\n            return ref;\n        },\n        stopDurationVital: (nameOrRef, options = {}) => {\n            stopDurationVital(addDurationVital, customVitalsState, nameOrRef, options);\n        },\n    };\n}\nexport function startDurationVital({ vitalsByName, vitalsByReference }, name, options = {}) {\n    const vital = {\n        id: generateUUID(),\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        id: vitalStart.id,\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        handlingStack: vitalStart.handlingStack,\n    };\n}\nfunction processVital(vital) {\n    const { startClocks, type, name, description, context, handlingStack } = vital;\n    const vitalId = vital.type === VitalType.DURATION ? vital.id : undefined;\n    const vitalData = {\n        id: vitalId !== null && vitalId !== void 0 ? vitalId : 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        startClocks,\n        duration: type === VitalType.DURATION ? vital.duration : undefined,\n        domainContext: handlingStack ? { handlingStack } : {},\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","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 { monitorError } 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';\nimport { readBytesFromStream } from '../tools/readBytesFromStream';\nimport { tryToClone } from '../tools/utils/responseUtils';\nlet fetchObservable;\nconst responseBodyActionGetters = [];\nexport function initFetchObservable({ responseBodyAction } = {}) {\n    if (responseBodyAction) {\n        responseBodyActionGetters.push(responseBodyAction);\n    }\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nexport function resetFetchObservable() {\n    fetchObservable = undefined;\n    responseBodyActionGetters.length = 0;\n}\nfunction createFetchObservable() {\n    return new Observable((observable) => {\n        // eslint-disable-next-line local-rules/disallow-zone-js-patched-values\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    var _a, _b;\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        isAbortedOnStart: (input instanceof Request && ((_a = input.signal) === null || _a === void 0 ? void 0 : _a.aborted)) || ((_b = init === null || init === void 0 ? void 0 : init.signal) === null || _b === void 0 ? void 0 : _b.aborted) || false,\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) => {\n        afterSend(observable, responsePromise, context).catch(monitorError);\n    });\n}\nasync function afterSend(observable, responsePromise, startContext) {\n    var _a, _b;\n    const context = startContext;\n    context.state = 'resolve';\n    let response;\n    try {\n        response = await responsePromise;\n    }\n    catch (error) {\n        context.status = 0;\n        context.isAborted =\n            ((_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        context.error = error;\n        observable.notify(context);\n        return;\n    }\n    context.response = response;\n    context.status = response.status;\n    context.responseType = response.type;\n    context.isAborted = false;\n    const responseBodyCondition = responseBodyActionGetters.reduce((action, getter) => Math.max(action, getter(context)), 0 /* ResponseBodyAction.IGNORE */);\n    if (responseBodyCondition !== 0 /* ResponseBodyAction.IGNORE */) {\n        const clonedResponse = tryToClone(response);\n        if (clonedResponse && clonedResponse.body) {\n            try {\n                const bytes = await readBytesFromStream(clonedResponse.body, {\n                    collectStreamBody: responseBodyCondition === 2 /* ResponseBodyAction.COLLECT */,\n                });\n                context.responseBody = bytes && new TextDecoder().decode(bytes);\n            }\n            catch (_c) {\n                // Ignore errors when reading the response body (e.g., stream aborted, network errors)\n                // This is not critical and should not be reported as an SDK error\n            }\n        }\n    }\n    observable.notify(context);\n}\n//# sourceMappingURL=fetchObservable.js.map","import { concatBuffers } from './utils/byteUtils';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until the end of the stream.\n * Returns the bytes if collectStreamBody is true, otherwise returns undefined.\n */\nexport async function readBytesFromStream(stream, options) {\n    const reader = stream.getReader();\n    const chunks = [];\n    while (true) {\n        const result = await reader.read();\n        if (result.done) {\n            break;\n        }\n        if (options.collectStreamBody) {\n            chunks.push(result.value);\n        }\n    }\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    return options.collectStreamBody ? concatBuffers(chunks) : undefined;\n}\n//# sourceMappingURL=readBytesFromStream.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findAllCommaSeparatedValues, 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}\n/**\n * Returns the value of the cookie with the given name\n * If there are multiple cookies with the same name, returns the first one\n */\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\n/**\n * Returns all the values of the cookies with the given name\n */\nexport function getCookies(name) {\n    return findAllCommaSeparatedValues(document.cookie).get(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 *\n * ⚠️ If there are multiple cookies with the same name, returns the LAST one (unlike `getCookie()`)\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';\nimport { tryJsonParse } from '../../tools/utils/objectUtils';\nconst cookieNamePrefix = 'datadog-synthetics-';\nexport const SYNTHETICS_TEST_ID_COOKIE_NAME = `${cookieNamePrefix}public-id`;\nexport const SYNTHETICS_RESULT_ID_COOKIE_NAME = `${cookieNamePrefix}result-id`;\nexport const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = `${cookieNamePrefix}injects-rum`;\nexport const SYNTHETICS_CONTEXT_COOKIE_NAME = `${cookieNamePrefix}rum-context`;\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 getSyntheticsContext() {\n    const raw = getRawSyntheticsContext();\n    return isValidSyntheticsContext(raw) ? raw : undefined;\n}\nexport function isSyntheticsTest() {\n    return Boolean(getSyntheticsContext());\n}\nfunction getRawSyntheticsContext() {\n    const rawGlobal = globalObject._DATADOG_SYNTHETICS_RUM_CONTEXT;\n    if (rawGlobal) {\n        return rawGlobal;\n    }\n    const rawCookie = getInitCookie(SYNTHETICS_CONTEXT_COOKIE_NAME);\n    if (rawCookie) {\n        return tryJsonParse(decodeURIComponent(rawCookie));\n    }\n    return {\n        test_id: window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME),\n        result_id: window._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME),\n    };\n}\nfunction isValidSyntheticsContext(value) {\n    return (typeof value === 'object' &&\n        value !== null &&\n        typeof value.test_id === 'string' &&\n        typeof value.result_id === 'string');\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","import { abstractHooks } from '@datadog/browser-core';\nexport const createHooks = (abstractHooks);\n//# sourceMappingURL=hooks.js.map","export const SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.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 { 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 && (previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId)) {\n        expiredSessionState.anonymousId = previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId;\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 { isEmptyObject } from '../../../tools/utils/objectUtils';\nimport { isChromium } from '../../../tools/utils/browserDetection';\nimport { getCurrentSite, areCookiesAuthorized, getCookies, setCookie, getCookie } 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';\nconst SESSION_COOKIE_VERSION = 0;\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(cookieOptions, configuration),\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    let sessionStateString = toSessionString(sessionState);\n    if (configuration.betaEncodeCookieOptions) {\n        sessionStateString = toSessionString({\n            ...sessionState,\n            // deleting a cookie is writing a new cookie with an empty value\n            // we don't want to store the cookie options in this case otherwise the cookie will not be deleted\n            ...(!isEmptyObject(sessionState) ? { c: encodeCookieOptions(options) } : {}),\n        });\n    }\n    setCookie(SESSION_STORE_KEY, sessionStateString, configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout, options);\n}\n/**\n * Retrieve the session state from the cookie that was set with the same cookie options\n * If there is no match, return the first cookie, because that's how `getCookie()` works\n */\nexport function retrieveSessionCookie(cookieOptions, configuration) {\n    if (configuration.betaEncodeCookieOptions) {\n        return retrieveSessionCookieFromEncodedCookie(cookieOptions);\n    }\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}\nfunction encodeCookieOptions(cookieOptions) {\n    const domainCount = cookieOptions.domain ? cookieOptions.domain.split('.').length - 1 : 0;\n    /* eslint-disable no-bitwise */\n    let byte = 0;\n    byte |= SESSION_COOKIE_VERSION << 5; // Store version in upper 3 bits\n    byte |= domainCount << 1; // Store domain count in next 4 bits\n    byte |= cookieOptions.crossSite ? 1 : 0; // Store useCrossSiteScripting in next bit\n    /* eslint-enable no-bitwise */\n    return byte.toString(16); // Convert to hex string\n}\n/**\n * Retrieve the session state from the cookie that was set with the same cookie options.\n * If there is no match, fallback to the first cookie, (because that's how `getCookie()` works)\n * and this allows to keep the current session id when we release this feature.\n */\nfunction retrieveSessionCookieFromEncodedCookie(cookieOptions) {\n    const cookies = getCookies(SESSION_STORE_KEY);\n    const opts = encodeCookieOptions(cookieOptions);\n    let sessionState;\n    // reverse the cookies so that if there is no match, the cookie returned is the first one\n    for (const cookie of cookies.reverse()) {\n        sessionState = toSessionState(cookie);\n        if (sessionState.c === opts) {\n            break;\n        }\n    }\n    // remove the cookie options from the session state as this is not part of the session state\n    sessionState === null || sessionState === void 0 ? true : delete sessionState.c;\n    return sessionState !== null && sessionState !== void 0 ? sessionState : {};\n}\n//# sourceMappingURL=sessionInCookie.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 { 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}\nexport function 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 { getGlobalObject } from '../../../tools/globalObject';\nimport { SessionPersistence } from '../sessionConstants';\nimport { getExpiredSessionState } from '../sessionState';\nimport { shallowClone } from '../../../tools/utils/objectUtils';\n/**\n * Key used to store session state in the global object.\n * This allows RUM and Logs SDKs to share the same session when using memory storage.\n */\nexport const MEMORY_SESSION_STORE_KEY = '_DD_SESSION';\nexport function selectMemorySessionStoreStrategy() {\n    return { type: SessionPersistence.MEMORY };\n}\nexport function initMemorySessionStoreStrategy(configuration) {\n    return {\n        expireSession: (sessionState) => expireSessionFromMemory(sessionState, configuration),\n        isLockEnabled: false,\n        persistSession: persistInMemory,\n        retrieveSession: retrieveFromMemory,\n    };\n}\nfunction retrieveFromMemory() {\n    const globalObject = getGlobalObject();\n    if (!globalObject[MEMORY_SESSION_STORE_KEY]) {\n        globalObject[MEMORY_SESSION_STORE_KEY] = {};\n    }\n    return shallowClone(globalObject[MEMORY_SESSION_STORE_KEY]);\n}\nfunction persistInMemory(state) {\n    const globalObject = getGlobalObject();\n    globalObject[MEMORY_SESSION_STORE_KEY] = shallowClone(state);\n}\nfunction expireSessionFromMemory(previousSessionState, configuration) {\n    persistInMemory(getExpiredSessionState(previousSessionState, configuration));\n}\n//# sourceMappingURL=sessionInMemory.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';\nimport { initMemorySessionStoreStrategy, selectMemorySessionStoreStrategy } from './storeStrategies/sessionInMemory';\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. When an array is provided, tries each persistence type in order until one\n * successfully initializes.\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    const { sessionPersistence } = initConfiguration;\n    const persistenceList = normalizePersistenceList(sessionPersistence, initConfiguration);\n    for (const persistence of persistenceList) {\n        const strategyType = selectStrategyForPersistence(persistence, initConfiguration);\n        if (strategyType !== undefined) {\n            return strategyType;\n        }\n    }\n    return undefined;\n}\nfunction normalizePersistenceList(sessionPersistence, initConfiguration) {\n    if (Array.isArray(sessionPersistence)) {\n        return sessionPersistence;\n    }\n    if (sessionPersistence !== undefined) {\n        return [sessionPersistence];\n    }\n    // Legacy default behavior: cookie first, with optional localStorage fallback\n    return initConfiguration.allowFallbackToLocalStorage\n        ? [SessionPersistence.COOKIE, SessionPersistence.LOCAL_STORAGE]\n        : [SessionPersistence.COOKIE];\n}\nfunction selectStrategyForPersistence(persistence, initConfiguration) {\n    switch (persistence) {\n        case SessionPersistence.COOKIE:\n            return selectCookieStrategy(initConfiguration);\n        case SessionPersistence.LOCAL_STORAGE:\n            return selectLocalStorageStrategy();\n        case SessionPersistence.MEMORY:\n            return selectMemorySessionStoreStrategy();\n        default:\n            display.error(`Invalid session persistence '${String(persistence)}'`);\n            return undefined;\n    }\n}\nexport function getSessionStoreStrategy(sessionStoreStrategyType, configuration) {\n    return sessionStoreStrategyType.type === SessionPersistence.COOKIE\n        ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)\n        : sessionStoreStrategyType.type === SessionPersistence.LOCAL_STORAGE\n            ? initLocalStorageStrategy(configuration)\n            : initMemorySessionStoreStrategy(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                    sessionState.anonymousId = generateUUID();\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        if (configuration.trackAnonymousUser && !sessionState.anonymousId) {\n            sessionState.anonymousId = generateUUID();\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: (hasConsent) => {\n            cancelExpandOrRenewSession();\n            if (hasConsent === false && sessionCache) {\n                delete sessionCache.anonymousId;\n            }\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                // Prevent stateful matching\n                item.lastIndex = 0;\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 { getGlobalObject } from '../tools/globalObject';\nimport { matchList } from '../tools/matchOption';\nimport { mockable } from '../tools/mockable';\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) {\n    const location = mockable(getGlobalObject().location);\n    const windowOrigin = location ? 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.33.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        flagEvaluationEndpointBuilder: createEndpointBuilder(initConfiguration, 'flagevaluation'),\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 { isPercentage } from '../../tools/utils/numberUtils';\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        betaEncodeCookieOptions: !!initConfiguration.betaEncodeCookieOptions,\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: Array.isArray(initConfiguration.sessionPersistence)\n            ? initConfiguration.sessionPersistence[0]\n            : 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        beta_encode_cookie_options: initConfiguration.betaEncodeCookieOptions,\n        source: initConfiguration.source,\n        sdk_version: initConfiguration.sdkVersion,\n        variant: initConfiguration.variant,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { isMatchOption, serializeConfiguration, DefaultPrivacyLevel, TraceContextInjection, display, objectHasValue, validateAndBuildConfiguration, isSampleRate, isNumber, isNonEmptyArray, isIndexableObject, } from '@datadog/browser-core';\nexport const DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'datadog'];\nexport const DEFAULT_TRACKED_RESOURCE_HEADERS = [\n    'cache-control',\n    'etag',\n    'age',\n    'expires',\n    'content-type',\n    'content-encoding',\n    'vary',\n    'content-length',\n    'server-timing',\n    'x-cache',\n];\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        betaTrackActionsInShadowDom: !!initConfiguration.betaTrackActionsInShadowDom,\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        trackResourceHeaders: validateAndBuildTrackResourceHeaders(initConfiguration),\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        const normalizedOption = normalizeTracingOption(option);\n        if (normalizedOption) {\n            tracingOptions.push(normalizedOption);\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            var _a;\n            (_a = normalizeTracingOption(option)) === null || _a === void 0 ? void 0 : _a.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));\n        });\n    }\n    return Array.from(usedTracingPropagators);\n}\nfunction normalizeTracingOption(option) {\n    if (isMatchOption(option)) {\n        return { match: option, propagatorTypes: DEFAULT_PROPAGATOR_TYPES };\n    }\n    if (isIndexableObject(option) &&\n        isMatchOption(option.match) &&\n        (option.propagatorTypes === null || option.propagatorTypes === undefined || Array.isArray(option.propagatorTypes))) {\n        return {\n            match: option.match,\n            propagatorTypes: option.propagatorTypes || DEFAULT_PROPAGATOR_TYPES,\n        };\n    }\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, trackResponseErrors: false });\n        }\n        else if (isIndexableObject(option) && isMatchOption(option.match)) {\n            graphQlOptions.push({\n                match: option.match,\n                trackPayload: !!option.trackPayload,\n                trackResponseErrors: !!option.trackResponseErrors,\n            });\n        }\n    });\n    return graphQlOptions;\n}\nconst VALID_HEADER_LOCATIONS = ['request', 'response', 'any'];\nfunction validateAndBuildTrackResourceHeaders(initConfiguration) {\n    const option = initConfiguration.trackResourceHeaders;\n    if (option === undefined || option === false) {\n        return [];\n    }\n    if (option === true) {\n        return DEFAULT_TRACKED_RESOURCE_HEADERS.map((name) => ({ name }));\n    }\n    if (!Array.isArray(option)) {\n        display.warn('trackResourceHeaders should be true or an array of MatchHeader');\n        return [];\n    }\n    if (option.length === 0) {\n        display.warn('trackResourceHeaders is an empty array, no headers will be captured');\n        return [];\n    }\n    const result = [];\n    option.forEach((item, index) => {\n        if (!isIndexableObject(item) || !isMatchOption(item.name)) {\n            display.warn(`trackResourceHeaders[${index}] should be a MatchHeader object with a 'name' property`);\n            return;\n        }\n        if (item.url !== undefined && !isMatchOption(item.url)) {\n            display.warn(`trackResourceHeaders[${index}].url should be a MatchOption`);\n            return;\n        }\n        if (item.extractor !== undefined && !(item.extractor instanceof RegExp)) {\n            display.warn(`trackResourceHeaders[${index}].extractor should be a RegExp`);\n            return;\n        }\n        if (item.location !== undefined && !VALID_HEADER_LOCATIONS.includes(item.location)) {\n            display.warn(`trackResourceHeaders[${index}].location should be 'request', 'response', or 'any'`);\n            return;\n        }\n        result.push({\n            ...item,\n            name: typeof item.name === 'string' ? item.name.toLowerCase() : item.name,\n        });\n    });\n    return result;\n}\nfunction hasGraphQlPayloadTracking(allowedGraphQlUrls) {\n    return (isNonEmptyArray(allowedGraphQlUrls) &&\n        allowedGraphQlUrls.some((option) => isIndexableObject(option) && option.trackPayload));\n}\nfunction hasGraphQlResponseErrorsTracking(allowedGraphQlUrls) {\n    return (isNonEmptyArray(allowedGraphQlUrls) &&\n        allowedGraphQlUrls.some((option) => isIndexableObject(option) && option.trackResponseErrors));\n}\nfunction getTrackResourceHeadersTelemetryValue(trackResourceHeaders) {\n    if (trackResourceHeaders === true) {\n        return 'default_headers';\n    }\n    if (Array.isArray(trackResourceHeaders)) {\n        return 'custom';\n    }\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a;\n    const baseSerializedConfiguration = serializeConfiguration(configuration);\n    // `use_` prefix is for telemetry options that track usage of a configuration option as a boolean to avoid capturing customer data\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        use_track_graph_ql_response_errors: hasGraphQlResponseErrorsTracking(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        track_resource_headers: getTrackResourceHeadersTelemetryValue(configuration.trackResourceHeaders),\n        ...baseSerializedConfiguration,\n    };\n}\n//# sourceMappingURL=configuration.js.map","/**\n * Executes a RegExp against a string and returns the first capture group, or the full match if\n * there is no capture group. Returns undefined when the pattern does not match.\n */\nexport function extractRegexMatch(candidate, extractor) {\n    // Prevent stateful matching when the RegExp has the global or sticky flag\n    extractor.lastIndex = 0;\n    const regexResult = extractor.exec(candidate);\n    if (!regexResult) {\n        return undefined;\n    }\n    const [match, capture] = regexResult;\n    return capture ? capture : match;\n}\n//# sourceMappingURL=extractRegexMatch.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, isIndexableObject, fetch, } from '@datadog/browser-core';\nimport { extractRegexMatch } from '../extractRegexMatch';\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 (isIndexableObject(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            case 'localStorage':\n                resolvedValue = resolveLocalStorageValue(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 resolveLocalStorageValue({ key }) {\n        let value;\n        try {\n            value = localStorage.getItem(key);\n        }\n        catch (_a) {\n            metrics.increment('localStorage', 'failure');\n            return;\n        }\n        metrics.increment('localStorage', value !== null ? 'success' : 'missing');\n        return value !== null && value !== void 0 ? value : undefined;\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 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    return extractRegexMatch(candidate, resolvedExtractor);\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, startTelemetry, mockable, } from '@datadog/browser-core';\nimport { createHooks } from '../domain/hooks';\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    let telemetry;\n    const hooks = createHooks();\n    const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);\n    const emptyContext = {};\n    function tryStartRum() {\n        if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        // Start telemetry only once, when we have consent and configuration\n        if (!telemetry) {\n            telemetry = mockable(startTelemetry)(\"browser-rum-sdk\" /* TelemetryService.RUM */, cachedConfiguration, hooks);\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, telemetry, hooks);\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        setLoadingTime: ((callTimestamp) => {\n            bufferApiCalls.add((startRumResult) => startRumResult.setLoadingTime(callTimestamp));\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        startAction(name, options) {\n            const startClocks = clocksNow();\n            bufferApiCalls.add((startRumResult) => startRumResult.startAction(name, options, startClocks));\n        },\n        stopAction(name, options) {\n            const stopClocks = clocksNow();\n            bufferApiCalls.add((startRumResult) => startRumResult.stopAction(name, options, stopClocks));\n        },\n        startResource(url, options) {\n            const startClocks = clocksNow();\n            bufferApiCalls.add((startRumResult) => startRumResult.startResource(url, options, startClocks));\n        },\n        stopResource(url, options) {\n            const stopClocks = clocksNow();\n            bufferApiCalls.add((startRumResult) => startRumResult.stopResource(url, options, stopClocks));\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 { 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 { generateUUID } from '../../tools/utils/stringUtils';\nexport const TAB_ID_STORAGE_KEY = '_dd_tab_id';\nlet cachedTabId;\n// Exported for test cleanup only — allows specs to reset the in-memory cache between tests.\nexport function resetCachedTabId() {\n    cachedTabId = undefined;\n}\nexport function startTabContext(hooks) {\n    const tabId = retrieveOrCreateTabId();\n    hooks.register(0 /* HookNames.Assemble */, () => ({\n        tab: {\n            id: tabId,\n        },\n    }));\n}\nfunction retrieveOrCreateTabId() {\n    var _a;\n    if (!cachedTabId) {\n        cachedTabId = (_a = getOrCreateIdInSessionStorage()) !== null && _a !== void 0 ? _a : generateUUID();\n    }\n    return cachedTabId;\n}\nfunction getOrCreateIdInSessionStorage() {\n    try {\n        const existingId = sessionStorage.getItem(TAB_ID_STORAGE_KEY);\n        if (existingId) {\n            return existingId;\n        }\n        const newId = generateUUID();\n        sessionStorage.setItem(TAB_ID_STORAGE_KEY, newId);\n        return newId;\n    }\n    catch (_a) {\n        // sessionStorage unavailable (e.g. Web Worker, sandboxed iframe, quota exceeded)\n        return undefined;\n    }\n}\n//# sourceMappingURL=tabContext.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 { 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.requestBody = 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        if (typeof xhr.response === 'string') {\n            completeContext.responseBody = xhr.response;\n        }\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/**\n * Reset the XHR observable global state. This is useful for testing to ensure clean state between tests.\n *\n * @internal\n */\nexport function resetXhrObservable() {\n    xhrObservable = undefined;\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 { 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, matchList, TraceContextInjection } from '@datadog/browser-core';\nimport { isSampled } from '../sampler/sampler';\nimport { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier';\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 { buildUrl, isNonEmptyArray, matchList, ONE_KIBI_BYTE, safeTruncate, tryJsonParse } from '@datadog/browser-core';\n/**\n * arbitrary value, byte precision not needed\n */\nconst GRAPHQL_PAYLOAD_LIMIT = 32 * ONE_KIBI_BYTE;\nexport function extractGraphQlMetadata(request, graphQlConfig) {\n    const metadata = extractGraphQlRequestMetadata(request, graphQlConfig.trackPayload);\n    if (!metadata) {\n        return;\n    }\n    if (graphQlConfig.trackResponseErrors && request.responseBody) {\n        const responseErrors = parseGraphQlResponse(request.responseBody);\n        if (responseErrors) {\n            metadata.error_count = responseErrors.length;\n            metadata.errors = responseErrors;\n        }\n    }\n    return metadata;\n}\nexport function parseGraphQlResponse(responseText) {\n    const response = tryJsonParse(responseText);\n    if (!response || typeof response !== 'object') {\n        return;\n    }\n    const responseObj = response;\n    if (!isNonEmptyArray(responseObj.errors)) {\n        return;\n    }\n    const errors = responseObj.errors.map((error) => {\n        var _a;\n        const graphqlError = {\n            message: error.message,\n            path: error.path,\n            locations: error.locations,\n            code: (_a = error.extensions) === null || _a === void 0 ? void 0 : _a.code,\n        };\n        return graphqlError;\n    });\n    return errors;\n}\nexport function findGraphQlConfiguration(url, configuration) {\n    return configuration.allowedGraphQlUrls.find((graphQlOption) => matchList([graphQlOption.match], url));\n}\nexport function extractGraphQlRequestMetadata(request, trackPayload = false) {\n    let rawMetadata;\n    if (request.method === 'POST') {\n        rawMetadata = extractFromBody(request.requestBody);\n    }\n    else if (request.method === 'GET') {\n        rawMetadata = extractFromUrlQueryParams(request.url);\n    }\n    if (!rawMetadata) {\n        return;\n    }\n    return sanitizeGraphQlMetadata(rawMetadata, trackPayload);\n}\nfunction extractFromBody(requestBody) {\n    if (!requestBody || typeof requestBody !== 'string') {\n        return;\n    }\n    const graphqlBody = tryJsonParse(requestBody);\n    if (!graphqlBody) {\n        return;\n    }\n    return {\n        query: graphqlBody.query,\n        operationName: graphqlBody.operationName,\n        variables: graphqlBody.variables ? JSON.stringify(graphqlBody.variables) : undefined,\n    };\n}\nfunction extractFromUrlQueryParams(url) {\n    const searchParams = buildUrl(url).searchParams;\n    const variablesParam = searchParams.get('variables');\n    const variables = variablesParam && tryJsonParse(variablesParam) !== undefined ? variablesParam : undefined;\n    return {\n        query: searchParams.get('query') || undefined,\n        operationName: searchParams.get('operationName') || undefined,\n        variables,\n    };\n}\nfunction sanitizeGraphQlMetadata(rawMetadata, trackPayload) {\n    let operationType;\n    let payload;\n    let variables;\n    if (rawMetadata.query) {\n        const trimmedQuery = rawMetadata.query.trim();\n        operationType = getOperationType(trimmedQuery);\n        if (trackPayload) {\n            payload = safeTruncate(trimmedQuery, GRAPHQL_PAYLOAD_LIMIT, '...');\n        }\n    }\n    if (rawMetadata.variables) {\n        variables = rawMetadata.variables;\n    }\n    return {\n        operationType,\n        operationName: rawMetadata.operationName,\n        variables,\n        payload,\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 { RequestType, elapsed, initFetchObservable, initXhrObservable, timeStampNow, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nimport { findGraphQlConfiguration } from './resource/graphql';\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, configuration, 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                    ...context,\n                    type: RequestType.XHR,\n                    isAbortedOnStart: false,\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nexport function trackFetch(lifeCycle, configuration, tracer) {\n    const subscription = initFetchObservable({\n        responseBodyAction: (context) => {\n            var _a;\n            if ((_a = findGraphQlConfiguration(context.url, configuration)) === null || _a === void 0 ? void 0 : _a.trackResponseErrors) {\n                return 2 /* ResponseBodyAction.COLLECT */;\n            }\n            return 1 /* ResponseBodyAction.WAIT */;\n        },\n    }).subscribe((rawContext) => {\n        var _a;\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                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                    ...context,\n                    duration: elapsed(context.startClocks.timeStamp, timeStampNow()),\n                    type: RequestType.FETCH,\n                    requestBody: (_a = context.init) === null || _a === void 0 ? void 0 : _a.body,\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nfunction getNextRequestIndex() {\n    const result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\n//# sourceMappingURL=requestCollection.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","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/**\n * Return the parent element, crossing shadow DOM boundaries.\n * If the element is a direct child of a shadow root, returns the shadow host.\n */\nexport function getParentElement(element) {\n    if (element.parentElement) {\n        return element.parentElement;\n    }\n    const parentNode = element.parentNode;\n    if (parentNode && isNodeShadowRoot(parentNode)) {\n        return parentNode.host;\n    }\n    return null;\n}\n//# sourceMappingURL=htmlDomUtils.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            interactionId: 0,\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}\nexport function resetManageResourceTimingBufferFull() {\n    if (resourceTimingBufferFullListener) {\n        resourceTimingBufferFullListener.stop();\n        resourceTimingBufferFullListener = undefined;\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","import { matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout, mockable } 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 = mockable(createPageActivityObservable)(lifeCycle, domMutationObservable, windowOpenObservable, configuration);\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 { isNodeShadowRoot } from '../browser/htmlDomUtils';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/actionNameConstants';\n/**\n * Marker used to indicate shadow DOM boundaries in selectors.\n * Named after the deprecated Shadow DOM v0 '::shadow' pseudo-element which served the same\n * purpose of marking entry into a shadow root.\n * Note: This is NOT a valid CSS selector, it's an internal marker that requires custom\n * parsing logic.\n */\nexport const SHADOW_DOM_MARKER = '::shadow ';\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    const subtrees = getAllSubtreeTargets(targetElement);\n    const selectorParts = [];\n    for (const { rootNode, target } of subtrees) {\n        const selector = getSelectorFromElementWithinSubtree(target, rootNode, actionNameAttribute);\n        if (!selector) {\n            return undefined;\n        }\n        selectorParts.push(selector);\n    }\n    return selectorParts.join(SHADOW_DOM_MARKER);\n}\n/**\n * Returns all (rootNode, target) pairs from the document down to the element.\n */\nfunction getAllSubtreeTargets(element) {\n    const result = [];\n    let currentTarget = element;\n    while (currentTarget) {\n        const rootNode = currentTarget.getRootNode();\n        result.push({ rootNode, target: currentTarget });\n        if (isNodeShadowRoot(rootNode)) {\n            currentTarget = rootNode.host;\n        }\n        else {\n            break;\n        }\n    }\n    return result.reverse();\n}\n/**\n * Computes a CSS selector for an element within a specific subtree (document or shadow root).\n */\nfunction getSelectorFromElementWithinSubtree(targetElement, rootNode, actionNameAttribute) {\n    let currentSelector;\n    let currentElement = targetElement;\n    while (currentElement && currentElement.nodeName !== 'HTML') {\n        const globallyUniqueSelector = findSelector(currentElement, rootNode, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueWithinRoot, actionNameAttribute, currentSelector);\n        if (globallyUniqueSelector) {\n            return combineSelector(globallyUniqueSelector, currentSelector);\n        }\n        const uniqueSelectorAmongChildren = findSelector(currentElement, rootNode, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, currentSelector);\n        const elementSelector = uniqueSelectorAmongChildren || getPositionSelector(currentElement);\n        currentSelector = combineSelector(elementSelector, currentSelector);\n        currentElement = currentElement.parentElement;\n    }\n    return currentSelector;\n}\nexport function 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}\nexport function 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}\nexport function 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)}${getAttributeValueSelector(attributeName, element.getAttribute(attributeName))}`;\n        }\n    }\n}\nexport function getAttributeValueSelector(attributeName, attributeValue) {\n    return `[${attributeName}=\"${CSS.escape(attributeValue)}\"]`;\n}\nfunction getPositionSelector(element) {\n    const nthOfType = getNthOfTypeSelector(element);\n    return `${CSS.escape(element.tagName)}:nth-of-type(${nthOfType})`;\n}\nexport function getNthOfTypeSelector(element) {\n    const parent = element.parentNode;\n    let sibling = parent.firstElementChild;\n    let nthOfType = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            nthOfType += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return nthOfType;\n}\nfunction findSelector(element, rootNode, 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, rootNode, elementSelector, childSelector)) {\n            return elementSelector;\n        }\n    }\n}\n/**\n * Check whether the selector is unique within the root node (document or shadow root).\n */\nfunction isSelectorUniqueWithinRoot(_element, rootNode, elementSelector, childSelector) {\n    return rootNode.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 _rootNode - the root node (document or shadow root) - unused but required for predicate signature.\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, _rootNode, 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    // Check siblings by iterating directly through previousElementSibling and nextElementSibling.\n    // This works even when parentElement is null (e.g., when parent is a DocumentFragment).\n    // Check previous siblings\n    let sibling = currentElement.previousElementSibling;\n    while (sibling) {\n        if (isSiblingMatching(sibling)) {\n            return false;\n        }\n        sibling = sibling.previousElementSibling;\n    }\n    // Check next siblings\n    sibling = currentElement.nextElementSibling;\n    while (sibling) {\n        if (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, PRIVACY_ATTR_NAME, } from './privacyConstants';\nimport { STABLE_ATTRIBUTES } from './getSelectorFromElement';\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}\nexport function shouldMaskAttribute(tagName, attributeName, attributeValue, nodePrivacyLevel, configuration) {\n    if (nodePrivacyLevel !== NodePrivacyLevel.MASK && nodePrivacyLevel !== NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED) {\n        return false;\n    }\n    if (attributeName === PRIVACY_ATTR_NAME ||\n        STABLE_ATTRIBUTES.includes(attributeName) ||\n        attributeName === configuration.actionNameAttribute) {\n        return false;\n    }\n    switch (attributeName) {\n        case 'title':\n        case 'alt':\n        case 'placeholder':\n        case 'aria-label':\n        case 'name':\n            return true;\n    }\n    if (tagName === 'A' && attributeName === 'href') {\n        return true;\n    }\n    if (tagName === 'IFRAME' && attributeName === 'srcdoc') {\n        return true;\n    }\n    if (attributeValue && attributeName.startsWith('data-')) {\n        return true;\n    }\n    if ((tagName === 'IMG' || tagName === 'SOURCE') && (attributeName === 'src' || attributeName === 'srcset')) {\n        return true;\n    }\n    return false;\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 */\nexport function censorText(text) {\n    return text.replace(/\\S/g, TEXT_MASKING_CHAR);\n}\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 {\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 { 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 { ONE_MINUTE, generateUUID, createValueHistory, elapsed, combine } from '@datadog/browser-core';\nimport { trackEventCounts } from './trackEventCounts';\nexport const EVENT_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function startEventTracker(lifeCycle) {\n    // Used by actions to associate events with actions.\n    const history = createValueHistory({ expireDelay: EVENT_CONTEXT_TIME_OUT_DELAY });\n    // Used by manual actions and resources that use named keys to match the start and stop calls.\n    const keyedEvents = new Map();\n    function cleanUpEvent(event) {\n        var _a;\n        keyedEvents.delete(event.key);\n        (_a = event.eventCounts) === null || _a === void 0 ? void 0 : _a.stop();\n    }\n    function discardAll() {\n        keyedEvents.forEach((event) => {\n            cleanUpEvent(event);\n        });\n        history.reset();\n    }\n    const sessionRenewalSubscription = lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, discardAll);\n    function start(key, startClocks, data, options) {\n        const id = generateUUID();\n        const historyEntry = history.add(id, startClocks.relative);\n        const existing = keyedEvents.get(key);\n        if (existing) {\n            cleanUpEvent(existing);\n        }\n        const eventCounts = (options === null || options === void 0 ? void 0 : options.isChildEvent)\n            ? trackEventCounts({\n                lifeCycle,\n                isChildEvent: options.isChildEvent(id),\n            })\n            : undefined;\n        const trackedEventData = {\n            id,\n            key,\n            startClocks,\n            data,\n            historyEntry,\n            eventCounts,\n        };\n        keyedEvents.set(key, trackedEventData);\n        return trackedEventData;\n    }\n    function stop(key, stopClocks, extraData) {\n        var _a;\n        const event = keyedEvents.get(key);\n        if (!event) {\n            return undefined;\n        }\n        const finalData = extraData ? combine(event.data, extraData) : event.data;\n        event.historyEntry.close(stopClocks.relative);\n        const duration = elapsed(event.startClocks.timeStamp, stopClocks.timeStamp);\n        const counts = (_a = event.eventCounts) === null || _a === void 0 ? void 0 : _a.eventCounts;\n        cleanUpEvent(event);\n        return {\n            ...finalData,\n            id: event.id,\n            startClocks: event.startClocks,\n            duration,\n            counts,\n        };\n    }\n    function discard(key) {\n        var _a;\n        const event = keyedEvents.get(key);\n        if (!event) {\n            return undefined;\n        }\n        const counts = (_a = event.eventCounts) === null || _a === void 0 ? void 0 : _a.eventCounts;\n        cleanUpEvent(event);\n        event.historyEntry.remove();\n        return {\n            ...event.data,\n            id: event.id,\n            startClocks: event.startClocks,\n            counts,\n        };\n    }\n    function findId(startTime) {\n        return history.findAll(startTime);\n    }\n    function getCounts(key) {\n        var _a, _b;\n        return (_b = (_a = keyedEvents.get(key)) === null || _a === void 0 ? void 0 : _a.eventCounts) === null || _b === void 0 ? void 0 : _b.eventCounts;\n    }\n    function stopTracker() {\n        sessionRenewalSubscription.unsubscribe();\n        discardAll();\n        history.stop();\n    }\n    return {\n        start,\n        stop,\n        discard,\n        getCounts,\n        findId,\n        stopAll: stopTracker,\n    };\n}\n//# sourceMappingURL=eventTracker.js.map","import { safeTruncate, ONE_KIBI_BYTE } from '@datadog/browser-core';\nimport { STABLE_ATTRIBUTES, isGeneratedValue, getIDSelector, getTagNameSelector, getNthOfTypeSelector, getAttributeValueSelector, } from './getSelectorFromElement';\nconst FILTERED_TAGNAMES = ['HTML', 'BODY'];\n/**\n * arbitrary value, we want to truncate the selector if it exceeds the limit\n */\nexport const CHARACTER_LIMIT = 2 * ONE_KIBI_BYTE;\n/**\n * Safe attributes that can be collected without PII concerns.\n * These are commonly used for testing, accessibility, and UI identification.\n */\nexport const SAFE_ATTRIBUTES = STABLE_ATTRIBUTES.concat([\n    'role',\n    'type',\n    'disabled',\n    'readonly',\n    'tabindex',\n    'draggable',\n    'target',\n    'rel',\n    'download',\n    'method',\n    'action',\n    'enctype',\n    'autocomplete',\n]);\n/**\n * Extracts a selector string from a MouseEvent composedPath.\n *\n * This function:\n * 1. Filters out non-Element items (Document, Window, ShadowRoot)\n * 2. Extracts a selector string from each element\n * 3. Truncates the selector string if it exceeds the character limit\n * 4. Returns the selector string\n *\n * @param composedPath - The composedPath from a MouseEvent\n * @returns A selector string\n */\nexport function getComposedPathSelector(composedPath, actionNameAttribute) {\n    // Filter to only include Element nodes\n    const elements = composedPath.filter((el) => el instanceof Element && !FILTERED_TAGNAMES.includes(el.tagName));\n    if (elements.length === 0) {\n        return '';\n    }\n    const allowedAttributes = actionNameAttribute ? [actionNameAttribute].concat(SAFE_ATTRIBUTES) : SAFE_ATTRIBUTES;\n    let result = '';\n    for (const element of elements) {\n        const part = getSelectorStringFromElement(element, allowedAttributes);\n        result += part;\n        if (result.length >= CHARACTER_LIMIT) {\n            return safeTruncate(result, CHARACTER_LIMIT);\n        }\n    }\n    return result;\n}\n/**\n * Extracts a selector string from an element.\n */\nfunction getSelectorStringFromElement(element, allowedAttributes) {\n    const tagName = getTagNameSelector(element);\n    const id = getIDSelector(element);\n    const classes = getElementClassesString(element);\n    const attributes = extractSafeAttributesString(element, allowedAttributes);\n    const positionData = computePositionDataString(element);\n    return `${tagName}${id || ''}${attributes}${classes}${positionData};`;\n}\nfunction getElementClassesString(element) {\n    return Array.from(element.classList)\n        .filter((c) => !isGeneratedValue(c))\n        .sort()\n        .map((c) => `.${CSS.escape(c)}`)\n        .join('');\n}\n/**\n * Computes the nthChild and nthOfType positions for an element.\n *\n * @param element - The element to compute the position data for\n * @returns A string of the form \":nth-child(1):nth-of-type(1)\"\n */\nfunction computePositionDataString(element) {\n    const siblings = Array.from(element.parentNode.children);\n    if (siblings.length <= 1) {\n        return '';\n    }\n    const sameTypeSiblings = siblings.filter((sibling) => sibling.tagName === element.tagName);\n    const nthChild = siblings.indexOf(element);\n    const nthOfType = getNthOfTypeSelector(element);\n    return `:nth-child(${nthChild + 1})${sameTypeSiblings.length > 1 ? `:nth-of-type(${nthOfType})` : ''}`;\n}\n/**\n * Extracts only the safe (allowlisted) attributes from an element.\n * The attributes are sorted alphabetically by name.\n */\nfunction extractSafeAttributesString(element, allowedAttributes) {\n    const result = [];\n    const attributes = Array.from(element.attributes);\n    for (const attribute of attributes) {\n        if (allowedAttributes.includes(attribute.name)) {\n            result.push(getAttributeValueSelector(attribute.name, attribute.value));\n        }\n    }\n    return result.sort().join('');\n}\n//# sourceMappingURL=getComposedPathSelector.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, maskDisallowedTextContent, shouldMaskNode, shouldMaskAttribute } from '../privacy';\nimport { isElementNode, getParentElement } from '../../browser/htmlDomUtils';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, ACTION_NAME_PLACEHOLDER, } from './actionNameConstants';\nexport function getActionNameFromElement(element, rumConfiguration, nodePrivacyLevel = NodePrivacyLevel.ALLOW) {\n    const nodePrivacyLevelCache = new Map();\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, nodePrivacyLevelCache) ||\n        getActionNameFromElementForStrategies(element, fallbackStrategies, rumConfiguration, nodePrivacyLevelCache) || {\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 = closestShadowAware(targetElement, `[${programmaticAttribute}]`);\n    if (!elementWithAttribute) {\n        return;\n    }\n    const name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nfunction closestShadowAware(element, selector) {\n    let current = element;\n    while (current) {\n        if (current.matches(selector)) {\n            return current;\n        }\n        current = getParentElement(current);\n    }\n    return null;\n}\nconst priorityStrategies = [\n    // associated LABEL text\n    (element, rumConfiguration, nodePrivacyLevelCache) => {\n        if ('labels' in element && element.labels && element.labels.length > 0) {\n            return getActionNameFromTextualContent(element.labels[0], rumConfiguration, nodePrivacyLevelCache);\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, nodePrivacyLevelCache) => {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getActionNameFromTextualContent(element, rumConfiguration, nodePrivacyLevelCache);\n        }\n    },\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromStandardAttribute(element, 'aria-label', rumConfiguration, nodePrivacyLevelCache),\n    // associated element text designated by the aria-labelledby attribute\n    (element, rumConfiguration, nodePrivacyLevelCache) => {\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, nodePrivacyLevelCache))\n                    .join(' '),\n                nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n            };\n        }\n    },\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromStandardAttribute(element, 'alt', rumConfiguration, nodePrivacyLevelCache),\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromStandardAttribute(element, 'name', rumConfiguration, nodePrivacyLevelCache),\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromStandardAttribute(element, 'title', rumConfiguration, nodePrivacyLevelCache),\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromStandardAttribute(element, 'placeholder', rumConfiguration, nodePrivacyLevelCache),\n    // SELECT first OPTION text\n    (element, rumConfiguration, nodePrivacyLevelCache) => {\n        if ('options' in element && element.options.length > 0) {\n            return getActionNameFromTextualContent(element.options[0], rumConfiguration, nodePrivacyLevelCache);\n        }\n    },\n];\nconst fallbackStrategies = [\n    (element, rumConfiguration, nodePrivacyLevelCache) => getActionNameFromTextualContent(element, rumConfiguration, nodePrivacyLevelCache),\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, nodePrivacyLevelCache) {\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, nodePrivacyLevelCache);\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 = getParentElement(element);\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    const rootNode = refElement.getRootNode();\n    if (rootNode instanceof ShadowRoot) {\n        const shadowElement = rootNode.getElementById(id);\n        if (shadowElement) {\n            return shadowElement;\n        }\n    }\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, rumConfiguration, nodePrivacyLevelCache) {\n    const { enablePrivacyForActionName, defaultPrivacyLevel } = rumConfiguration;\n    let attributeValue = element.getAttribute(attribute);\n    if (attributeValue && enablePrivacyForActionName) {\n        const nodePrivacyLevel = getNodePrivacyLevel(element, defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (shouldMaskAttribute(element.tagName, attribute, attributeValue, nodePrivacyLevel, rumConfiguration)) {\n            attributeValue = maskDisallowedTextContent(attributeValue, ACTION_NAME_PLACEHOLDER);\n        }\n    }\n    else if (!attributeValue) {\n        attributeValue = '';\n    }\n    return {\n        name: attributeValue,\n        nameSource: \"standard_attribute\" /* ActionNameSource.STANDARD_ATTRIBUTE */,\n    };\n}\nfunction getActionNameFromTextualContent(element, rumConfiguration, nodePrivacyLevelCache) {\n    return {\n        name: getTextualContent(element, rumConfiguration, nodePrivacyLevelCache) || '',\n        nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n    };\n}\nfunction getTextualContent(element, rumConfiguration, nodePrivacyLevelCache) {\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, nodePrivacyLevelCache);\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, nodePrivacyLevelCache) {\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","export function isActionChildEvent(id) {\n    return (event) => event.action !== undefined && event.action.id !== undefined && event.action.id.includes(id);\n}\n//# sourceMappingURL=isActionChildEvent.js.map","import { timeStampNow, Observable, timeStampToClocks, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { isNodeShadowHost } from '../../browser/htmlDomUtils';\nimport { ActionType } from '../../rawRumEvent.types';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../waitPageActivityEnd';\nimport { getSelectorFromElement } from '../getSelectorFromElement';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { NodePrivacyLevel } from '../privacyConstants';\nimport { startEventTracker } from '../eventTracker';\nimport { getComposedPathSelector } from '../getComposedPathSelector';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\nimport { CLICK_ACTION_MAX_DURATION, updateInteractionSelector } from './interactionSelectorCache';\nimport { isActionChildEvent } from './isActionChildEvent';\nexport function trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    const actionTracker = startEventTracker(lifeCycle);\n    const stopObservable = new Observable();\n    let currentClickChain;\n    lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, stopClickChain);\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, actionTracker, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    });\n    return {\n        stop: () => {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n            actionTracker.stopAll();\n        },\n        findActionId: actionTracker.findId,\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                // Clear the reference to allow garbage collection. Without this, the finalize callback\n                // retains a closure reference to the old click chain, preventing it from being cleaned up\n                // and causing a memory leak as click chains accumulate over time.\n                currentClickChain = undefined;\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable) {\n    const targetForPrivacy = configuration.betaTrackActionsInShadowDom\n        ? getEventTarget(pointerDownEvent)\n        : pointerDownEvent.target;\n    let nodePrivacyLevel;\n    if (configuration.enablePrivacyForActionName) {\n        nodePrivacyLevel = getNodePrivacyLevel(targetForPrivacy, 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, actionTracker, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var _a;\n    const click = newClick(lifeCycle, actionTracker, 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 pageMayExitSubscription = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, () => {\n        click.stop(timeStampNow());\n    });\n    const stopSubscription = stopObservable.subscribe(() => {\n        click.stop();\n    });\n    click.stopObservable.subscribe(() => {\n        pageMayExitSubscription.unsubscribe();\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, nodePrivacyLevel, configuration) {\n    const target = configuration.betaTrackActionsInShadowDom ? getEventTarget(event) : event.target;\n    const rect = target.getBoundingClientRect();\n    const selector = getSelectorFromElement(target, configuration.actionNameAttribute);\n    const composedPathSelector = getComposedPathSelector(event.composedPath(), configuration.actionNameAttribute);\n    if (selector) {\n        updateInteractionSelector(event.timeStamp, selector);\n    }\n    const { name, nameSource } = getActionNameFromElement(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            composedPathSelector: composedPathSelector || undefined,\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 getEventTarget(event) {\n    if (event.composed && isNodeShadowHost(event.target) && typeof event.composedPath === 'function') {\n        const composedPath = event.composedPath();\n        if (composedPath.length > 0 && composedPath[0] instanceof Element) {\n            return composedPath[0];\n        }\n    }\n    return event.target;\n}\nfunction newClick(lifeCycle, actionTracker, getUserActivity, clickActionBase, startEvent) {\n    const clickKey = generateUUID();\n    const startClocks = relativeToClocks(startEvent.timeStamp);\n    const startedClickAction = actionTracker.start(clickKey, startClocks, clickActionBase, {\n        isChildEvent: isActionChildEvent,\n    });\n    lifeCycle.notify(15 /* LifeCycleEventType.ACTION_STARTED */, startedClickAction);\n    let status = 0 /* ClickStatus.ONGOING */;\n    let actionTrackerFinishedEvent;\n    const frustrationTypes = [];\n    const stopObservable = new Observable();\n    function stop(activityEndTime) {\n        if (status !== 0 /* ClickStatus.ONGOING */) {\n            return;\n        }\n        status = 1 /* ClickStatus.STOPPED */;\n        actionTrackerFinishedEvent = activityEndTime\n            ? actionTracker.stop(clickKey, timeStampToClocks(activityEndTime))\n            : actionTracker.discard(clickKey);\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop,\n        stopObservable,\n        get hasError() {\n            var _a;\n            const currentCounts = (_a = actionTrackerFinishedEvent === null || actionTrackerFinishedEvent === void 0 ? void 0 : actionTrackerFinishedEvent.counts) !== null && _a !== void 0 ? _a : actionTracker.getCounts(clickKey);\n            return currentCounts ? currentCounts.errorCount > 0 : false;\n        },\n        get hasPageActivity() {\n            return actionTrackerFinishedEvent && 'duration' in actionTrackerFinishedEvent;\n        },\n        getUserActivity,\n        addFrustration: (frustrationType) => {\n            frustrationTypes.push(frustrationType);\n        },\n        get startClocks() {\n            return startClocks;\n        },\n        isStopped: () => status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */,\n        clone: () => newClick(lifeCycle, actionTracker, getUserActivity, clickActionBase, startEvent),\n        validate: (domEvents) => {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            if (!actionTrackerFinishedEvent) {\n                return;\n            }\n            const clickAction = {\n                frustrationTypes,\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n                ...actionTrackerFinishedEvent,\n                counts: actionTrackerFinishedEvent.counts, // This is needed to satisfy the type checker\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, toServerDuration, SKIPPED, addDuration } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { trackClickActions } from './trackClickActions';\nimport { trackManualActions } from './trackManualActions';\nexport const LONG_TASK_START_TIME_CORRECTION = 1;\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    const stopClickActions = noop;\n    let clickActions;\n    if (configuration.trackUserInteractions) {\n        clickActions = trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration);\n    }\n    const manualActions = trackManualActions(lifeCycle, (action) => {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action));\n    });\n    const actionContexts = {\n        findActionId: (startTime) => {\n            var _a;\n            const manualActionId = manualActions.findActionId(startTime);\n            const clickActionId = (_a = clickActions === null || clickActions === void 0 ? void 0 : clickActions.findActionId(startTime)) !== null && _a !== void 0 ? _a : [];\n            return manualActionId.concat(clickActionId);\n        },\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        // Long tasks triggered by interaction handlers (pointerup, click, etc.)\n        // can have a start time slightly before the interaction timestamp (long_task.start_time < action.start_time).\n        // This likely happens because the interaction timestamp is recorded during the event dispatch,\n        // not at the beginning of the rendering frame. I observed a difference of < 1 ms in my tests.\n        // Fixes flakiness in test: \"associates long tasks to interaction actions\"\n        const correctedStartTime = eventType === RumEventType.LONG_TASK ? addDuration(startTime, LONG_TASK_START_TIME_CORRECTION) : startTime;\n        const actionId = actionContexts.findActionId(correctedStartTime);\n        if (!actionId.length) {\n            return SKIPPED;\n        }\n        return {\n            type: eventType,\n            action: { id: actionId },\n        };\n    });\n    hooks.register(1 /* HookNames.AssembleTelemetry */, ({ startTime }) => ({\n        // todo: fix telemetry event type\n        action: { id: actionContexts.findActionId(startTime) },\n    }));\n    return {\n        addAction: manualActions.addAction,\n        startAction: manualActions.startAction,\n        stopAction: manualActions.stopAction,\n        actionContexts,\n        stop: () => {\n            unsubscribeAutoAction();\n            stopClickActions();\n            manualActions.stop();\n            clickActions === null || clickActions === void 0 ? void 0 : clickActions.stop();\n        },\n    };\n}\nfunction processAction(action) {\n    var _a, _b, _c, _d;\n    const isAuto = isAutoAction(action);\n    const loadingTime = discardNegativeDuration(toServerDuration(action.duration));\n    return {\n        rawRumEvent: {\n            type: RumEventType.ACTION,\n            date: action.startClocks.timeStamp,\n            action: {\n                id: action.id,\n                target: { name: action.name },\n                type: action.type,\n                ...(loadingTime !== undefined && { loading_time: loadingTime }),\n                ...(action.counts && {\n                    error: { count: action.counts.errorCount },\n                    long_task: { count: action.counts.longTaskCount },\n                    resource: { count: action.counts.resourceCount },\n                }),\n                frustration: { type: action.frustrationTypes },\n            },\n            ...(isAuto\n                ? {\n                    _dd: {\n                        action: {\n                            target: {\n                                selector: ((_a = action.target) === null || _a === void 0 ? void 0 : _a.selector) || undefined,\n                                width: ((_b = action.target) === null || _b === void 0 ? void 0 : _b.width) || undefined,\n                                height: ((_c = action.target) === null || _c === void 0 ? void 0 : _c.height) || undefined,\n                                composed_path_selector: (_d = action.target) === null || _d === void 0 ? void 0 : _d.composedPathSelector,\n                            },\n                            position: action.position,\n                            name_source: action.nameSource,\n                        },\n                    },\n                }\n                : { context: action.context }),\n        },\n        duration: action.duration,\n        startClocks: action.startClocks,\n        domainContext: isAuto ? { events: action.events } : { handlingStack: action.handlingStack },\n    };\n}\nfunction isAutoAction(action) {\n    return 'events' in action;\n}\n//# sourceMappingURL=actionCollection.js.map","import { clocksNow, generateUUID } from '@datadog/browser-core';\nimport { ActionType as ActionTypeEnum, FrustrationType as FrustrationTypeEnum } from '../../rawRumEvent.types';\nimport { startEventTracker } from '../eventTracker';\nimport { isActionChildEvent } from './isActionChildEvent';\nexport function trackManualActions(lifeCycle, onManualActionCompleted) {\n    const actionTracker = startEventTracker(lifeCycle);\n    function startManualAction(name, options = {}, startClocks = clocksNow()) {\n        var _a;\n        const lookupKey = (_a = options.actionKey) !== null && _a !== void 0 ? _a : name;\n        const startedManualAction = actionTracker.start(lookupKey, startClocks, {\n            name,\n            ...options,\n        }, { isChildEvent: isActionChildEvent });\n        lifeCycle.notify(15 /* LifeCycleEventType.ACTION_STARTED */, startedManualAction);\n    }\n    function stopManualAction(name, options = {}, stopClocks = clocksNow()) {\n        var _a;\n        const lookupKey = (_a = options.actionKey) !== null && _a !== void 0 ? _a : name;\n        const stopped = actionTracker.stop(lookupKey, stopClocks, options);\n        if (!stopped) {\n            return;\n        }\n        const frustrationTypes = [];\n        if (stopped.counts && stopped.counts.errorCount > 0) {\n            frustrationTypes.push(FrustrationTypeEnum.ERROR_CLICK);\n        }\n        const manualAction = {\n            ...stopped,\n            type: stopped.type || ActionTypeEnum.CUSTOM,\n            frustrationTypes,\n        };\n        onManualActionCompleted(manualAction);\n    }\n    function addInstantAction(action) {\n        onManualActionCompleted({ id: generateUUID(), frustrationTypes: [], ...action });\n    }\n    return {\n        addAction: addInstantAction,\n        startAction: startManualAction,\n        stopAction: stopManualAction,\n        findActionId: actionTracker.findId,\n        stop: actionTracker.stopAll,\n    };\n}\n//# sourceMappingURL=trackManualActions.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        startClocks: error.startClocks,\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        // `deadline` can be null when `requestIdleCallback` is replaced by a page-injected polyfill\n        // (e.g. `setTimeout(cb, 0)` in some WKWebViews) that invokes the callback with no argument.\n        if (!deadline || 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 { findLast, getRelativeTime, isNumber, relativeNow } 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}\nexport function sanitizeFirstByte(entry) {\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    return entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined;\n}\nexport function getResourceEntries() {\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.RESOURCE)) {\n        return performance.getEntriesByType(RumPerformanceEntryType.RESOURCE);\n    }\n    return undefined;\n}\n/**\n * Find the most relevant resource entry for an LCP element.\n *\n * Resource entries persist for the entire page lifetime and can include multiple requests\n * for the same URL (preloads, cache-busting reloads, SPA route changes, etc.).\n * This function returns the most recent matching entry that started before the LCP time,\n * which is most likely the one that triggered the LCP paint.\n */\nexport function findLcpResourceEntry(resourceUrl, lcpStartTime) {\n    const entries = getResourceEntries();\n    if (!entries) {\n        return undefined;\n    }\n    return findLast(entries, (entry) => entry.name === resourceUrl && entry.startTime <= lcpStartTime);\n}\n//# sourceMappingURL=performanceUtils.js.map","import { mockable, 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) {\n    runOnReadyState(configuration, 'interactive', () => {\n        const navigationEntry = mockable(getNavigationEntry)();\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 { combine, generateUUID, RequestType, ResourceType, toServerDuration, relativeToClocks, createTaskQueue, mockable, isExperimentalFeatureEnabled, ExperimentalFeature, matchList, safeTruncate, display, addTelemetryDebug, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, createPerformanceObservable } from '../../browser/performanceObservable';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { createSpanIdentifier } from '../tracing/identifier';\nimport { startEventTracker } from '../eventTracker';\nimport { extractRegexMatch } from '../extractRegexMatch';\nimport { matchRequestResourceEntry } from './matchRequestResourceEntry';\nimport { computeResourceEntryDetails, computeResourceEntryDuration, computeResourceEntryType, computeResourceEntrySize, computeResourceEntryProtocol, computeResourceEntryDeliveryType, isResourceEntryRequestType, sanitizeIfLongDataUrl, } from './resourceUtils';\nimport { retrieveInitialDocumentResourceTiming } from './retrieveInitialDocumentResourceTiming';\nimport { createRequestRegistry } from './requestRegistry';\nimport { extractGraphQlMetadata, findGraphQlConfiguration } from './graphql';\nimport { trackManualResources } from './trackManualResources';\nexport function startResourceCollection(lifeCycle, configuration, pageStateHistory) {\n    const taskQueue = mockable(createTaskQueue)();\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    mockable(retrieveInitialDocumentResourceTiming)(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    const resourceTracker = startEventTracker(lifeCycle);\n    const manualResources = trackManualResources(lifeCycle, resourceTracker);\n    return {\n        startResource: manualResources.startResource,\n        stopResource: manualResources.stopResource,\n        stop: () => {\n            taskQueue.stop();\n            performanceResourceSubscription.unsubscribe();\n            resourceTracker.stopAll();\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 networkHeaders = isExperimentalFeatureEnabled(ExperimentalFeature.TRACK_RESOURCE_HEADERS)\n        ? computeNetworkHeaders(request, configuration)\n        : undefined;\n    const graphql = request && computeGraphQlMetaData(request, configuration);\n    const contentTypeFromPerformanceEntry = entry && computeContentTypeFromPerformanceEntry(entry);\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), contentTypeFromPerformanceEntry, networkHeaders);\n    return {\n        startClocks,\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, graphQlConfig);\n}\nfunction computeContentTypeFromPerformanceEntry(entry) {\n    const contentType = entry.contentType;\n    if (contentType) {\n        return {\n            resource: {\n                response: {\n                    headers: {\n                        'content-type': contentType,\n                    },\n                },\n            },\n        };\n    }\n    return undefined;\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}\nfunction computeNetworkHeaders(request, configuration) {\n    const matchers = configuration.trackResourceHeaders;\n    if (matchers.length === 0 || !request) {\n        return undefined;\n    }\n    const urlMatchers = matchers.filter((m) => (m.url !== undefined ? matchList([m.url], request.url, true) : true));\n    if (urlMatchers.length === 0) {\n        return undefined;\n    }\n    const responseMatchers = urlMatchers.filter((m) => m.location === undefined || m.location === 'any' || m.location === 'response');\n    const requestMatchers = urlMatchers.filter((m) => m.location === undefined || m.location === 'any' || m.location === 'request');\n    const responseHeaders = responseMatchers.length > 0 ? getResponseHeaders(request, responseMatchers) : undefined;\n    const requestHeaders = requestMatchers.length > 0 ? getRequestHeaders(request, requestMatchers) : undefined;\n    if (!responseHeaders && !requestHeaders) {\n        return undefined;\n    }\n    return {\n        resource: {\n            request: requestHeaders ? { headers: requestHeaders } : undefined,\n            response: responseHeaders ? { headers: responseHeaders } : undefined,\n        },\n    };\n}\nfunction getResponseHeaders(request, matchers) {\n    if (request.type === RequestType.FETCH && request.response) {\n        return filterHeaders(request.response.headers, matchers);\n    }\n    if (request.type === RequestType.XHR && request.xhr) {\n        const rawXhrHeaders = request.xhr.getAllResponseHeaders();\n        if (rawXhrHeaders) {\n            try {\n                return filterHeaders(new Headers(parseRawXhrHeaders(rawXhrHeaders)), matchers);\n            }\n            catch (_a) {\n                // Ignore parsing errors\n            }\n        }\n    }\n    return undefined;\n}\nfunction getRequestHeaders(request, matchers) {\n    var _a;\n    if (request.type !== RequestType.FETCH) {\n        return undefined;\n    }\n    let headers;\n    if ((_a = request.init) === null || _a === void 0 ? void 0 : _a.headers) {\n        headers = new Headers(request.init.headers);\n    }\n    else if (request.input instanceof Request) {\n        headers = request.input.headers;\n    }\n    return headers ? filterHeaders(headers, matchers) : undefined;\n}\nconst FORBIDDEN_HEADER_PATTERN = /(token|cookie|secret|authorization|(api|secret|access|app).?key|(client|connecting|real).?ip|forwarded)/;\nconst MAX_HEADER_COUNT = 100;\nconst MAX_HEADER_VALUE_LENGTH = 128;\nfunction filterHeaders(headers, matchers) {\n    const result = {};\n    let collectedHeaderCount = 0;\n    let totalHeaderCount = 0;\n    let hasReachedMaxHeaderCount = false;\n    headers.forEach((value, name) => {\n        totalHeaderCount++;\n        if (collectedHeaderCount >= MAX_HEADER_COUNT) {\n            if (!hasReachedMaxHeaderCount) {\n                display.warn(`Maximum number of headers (${MAX_HEADER_COUNT}) has been reached. Further headers are dropped.`);\n                hasReachedMaxHeaderCount = true;\n            }\n            return;\n        }\n        const lowerName = name.toLowerCase();\n        if (FORBIDDEN_HEADER_PATTERN.test(lowerName)) {\n            return;\n        }\n        const matchHeader = matchers.find((m) => matchList([m.name], lowerName));\n        if (!matchHeader) {\n            return;\n        }\n        const { extractor } = matchHeader;\n        const capturedValue = extractor ? extractRegexMatch(value, extractor) : value;\n        if (capturedValue === undefined) {\n            return;\n        }\n        if (capturedValue.length > MAX_HEADER_VALUE_LENGTH) {\n            display.warn(`Header \"${lowerName}\" value was truncated from ${capturedValue.length} to ${MAX_HEADER_VALUE_LENGTH} characters.`);\n            // monitor-until: 2026-05-23\n            addTelemetryDebug('Resource header value was truncated', {\n                header_name: lowerName,\n                original_length: capturedValue.length,\n                limit: MAX_HEADER_VALUE_LENGTH,\n            });\n        }\n        result[lowerName] = safeTruncate(capturedValue, MAX_HEADER_VALUE_LENGTH);\n        collectedHeaderCount++;\n    });\n    if (hasReachedMaxHeaderCount) {\n        // monitor-until: 2026-05-23\n        addTelemetryDebug('Maximum number of resource headers reached', {\n            collectedHeaderCount,\n            totalHeaderCount,\n        });\n    }\n    return collectedHeaderCount > 0 ? result : undefined;\n}\n// Input:  \"content-type: application/json\\r\\ncache-control: no-cache\"\n// Output: [[\"content-type\", \"application/json\"], [\"cache-control\", \"no-cache\"]]\nfunction parseRawXhrHeaders(rawXhrheaders) {\n    const pairs = [];\n    const lines = rawXhrheaders.trim().split(/\\r\\n/);\n    for (const line of lines) {\n        const colonIndex = line.indexOf(':');\n        if (colonIndex > 0) {\n            pairs.push([line.substring(0, colonIndex).trim(), line.substring(colonIndex + 1).trim()]);\n        }\n    }\n    return pairs;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { addTelemetryDebug, ExperimentalFeature, isExperimentalFeatureEnabled, RequestType, timeStampNow, } 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    let tooManyRequestsReported = false;\n    const subscription = lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, (request) => {\n        requests.add(request);\n        if (requests.size > MAX_REQUESTS) {\n            const oldestRequest = requests.values().next().value;\n            if (!tooManyRequestsReported) {\n                tooManyRequestsReported = true;\n                let debugContext;\n                if (isExperimentalFeatureEnabled(ExperimentalFeature.TOO_MANY_REQUESTS_INVESTIGATION)) {\n                    let abortedCount = 0;\n                    let abortedOnStartCount = 0;\n                    let xhrCount = 0;\n                    let withoutMatchingEntryCount = 0;\n                    for (const r of requests) {\n                        if (r.isAborted) {\n                            abortedCount++;\n                        }\n                        if (r.isAbortedOnStart) {\n                            abortedOnStartCount++;\n                        }\n                        if (r.type === RequestType.XHR) {\n                            xhrCount++;\n                        }\n                        const entries = performance.getEntriesByName(r.url, 'resource');\n                        const hasMatchingEntry = entries.some((e) => e.startTime >= r.startClocks.relative);\n                        if (!hasMatchingEntry) {\n                            withoutMatchingEntryCount++;\n                        }\n                    }\n                    const oldestRequestAge = timeStampNow() - oldestRequest.startClocks.timeStamp;\n                    debugContext = {\n                        abortedCount,\n                        abortedOnStartCount,\n                        xhrCount,\n                        fetchCount: requests.size - xhrCount,\n                        oldestRequestAge,\n                        oldestRequestEndAge: oldestRequestAge - oldestRequest.duration,\n                        withoutMatchingEntryCount,\n                    };\n                }\n                // monitor-until: 2026-06-01, after early request collection is the default in v7\n                addTelemetryDebug('Too many requests', debugContext);\n            }\n            requests.delete(oldestRequest);\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 { clocksNow, elapsed, ResourceType as ResourceTypeEnum, toServerDuration } from '@datadog/browser-core';\nimport { RumEventType } from '../../rawRumEvent.types';\nimport { sanitizeIfLongDataUrl } from './resourceUtils';\nexport function trackManualResources(lifeCycle, resourceTracker) {\n    function startManualResource(url, options = {}, startClocks = clocksNow()) {\n        var _a;\n        const lookupKey = (_a = options.resourceKey) !== null && _a !== void 0 ? _a : url;\n        resourceTracker.start(lookupKey, startClocks, {\n            url,\n            ...options,\n        });\n    }\n    function stopManualResource(url, options = {}, stopClocks = clocksNow()) {\n        var _a;\n        const lookupKey = (_a = options.resourceKey) !== null && _a !== void 0 ? _a : url;\n        const stopped = resourceTracker.stop(lookupKey, stopClocks, {\n            context: options.context,\n            type: options.type,\n        });\n        if (!stopped) {\n            return;\n        }\n        const duration = elapsed(stopped.startClocks.relative, stopClocks.relative);\n        const rawRumEvent = {\n            date: stopped.startClocks.timeStamp,\n            type: RumEventType.RESOURCE,\n            resource: {\n                id: stopped.id,\n                type: stopped.type || ResourceTypeEnum.OTHER,\n                url: sanitizeIfLongDataUrl(stopped.url),\n                duration: toServerDuration(duration),\n                method: stopped.method,\n                status_code: options.statusCode,\n                size: options.size,\n            },\n            _dd: {},\n            context: stopped.context,\n        };\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n            rawRumEvent,\n            startClocks: stopped.startClocks,\n            duration,\n            domainContext: { isManual: true },\n        });\n    }\n    return {\n        startResource: startManualResource,\n        stopResource: stopManualResource,\n    };\n}\n//# sourceMappingURL=trackManualResources.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, runOnReadyState, clearTimeout, mockable } from '@datadog/browser-core';\nimport { getNavigationEntry, sanitizeFirstByte } from '../../../browser/performanceUtils';\nexport function trackNavigationTimings(configuration, callback) {\n    return waitAfterLoadEvent(configuration, () => {\n        const entry = mockable(getNavigationEntry)();\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        firstByte: sanitizeFirstByte(entry),\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 { findLcpResourceEntry, getNavigationEntry, sanitizeFirstByte } from '../../../browser/performanceUtils';\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            const resourceUrl = computeLcpEntryUrl(lcpEntry);\n            const lcpValue = lcpEntry.startTime;\n            const subParts = computeLcpSubParts(resourceUrl, lcpValue);\n            callback({\n                value: lcpValue,\n                targetSelector: lcpTargetSelector,\n                resourceUrl,\n                subParts,\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/**\n * Compute the LCP sub-parts breakdown (loadDelay, loadTime, renderDelay).\n * Returns undefined if navigation timing data or TTFB is unavailable.\n */\nfunction computeLcpSubParts(resourceUrl, lcpValue) {\n    const firstByte = sanitizeFirstByte(getNavigationEntry());\n    if (firstByte === undefined) {\n        return undefined;\n    }\n    const lcpResourceEntry = resourceUrl ? findLcpResourceEntry(resourceUrl, lcpValue) : undefined;\n    const lcpRequestStart = lcpResourceEntry\n        ? Math.max(firstByte, lcpResourceEntry.requestStart || lcpResourceEntry.startTime)\n        : firstByte;\n    // Cap at LCP time to handle resources that continue downloading after LCP (e.g., videos)\n    const lcpResponseEnd = Math.min(lcpValue, Math.max(lcpRequestStart, (lcpResourceEntry === null || lcpResourceEntry === void 0 ? void 0 : lcpResourceEntry.responseEnd) || 0));\n    return {\n        loadDelay: (lcpRequestStart - firstByte),\n        loadTime: (lcpResponseEnd - lcpRequestStart),\n        renderDelay: (lcpValue - lcpResponseEnd),\n    };\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;\nexport function resetInteractionCountPolyfill() {\n    if (observer) {\n        observer.disconnect();\n        observer = undefined;\n        interactionCountEstimate = 0;\n        minKnownInteractionId = Infinity;\n        maxKnownInteractionId = 0;\n    }\n}\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// Event Timing API rounds duration values to the nearest 8 ms\nconst RENDER_TIME_GROUPING_THRESHOLD = 8;\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    let viewEnd = Infinity;\n    let currentInp;\n    const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);\n    const longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    const subPartsTracker = createSubPartsTracker(longestInteractions);\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    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                subPartsTracker.process(entry);\n            }\n        }\n        subPartsTracker.pruneUntracked();\n        const candidate = longestInteractions.estimateP98Interaction();\n        if (candidate) {\n            updateCurrentInp(candidate);\n        }\n    }\n    function updateCurrentInp(candidate) {\n        const newStartTime = elapsed(viewStart, candidate.startTime);\n        // startTime catches identity changes when the p98 switches to a different interaction with the same duration,\n        // ensuring targetSelector and subParts always describe the same interaction.\n        if (!currentInp || candidate.duration !== currentInp.duration || newStartTime !== currentInp.startTime) {\n            let targetSelector = getInteractionSelector(candidate.startTime);\n            if (!targetSelector && candidate.target && isElementNode(candidate.target)) {\n                targetSelector = getSelectorFromElement(candidate.target, configuration.actionNameAttribute);\n            }\n            currentInp = {\n                duration: candidate.duration,\n                startTime: newStartTime,\n                targetSelector,\n            };\n        }\n        // Recomputed on every batch: the group for the p98 interaction may have been updated\n        // with new min/max timing even when the p98 identity (duration, startTime) is unchanged.\n        currentInp.subParts = subPartsTracker.computeSubParts(candidate, sanitizeInpValue(currentInp.duration));\n    }\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 (currentInp) {\n                return {\n                    value: sanitizeInpValue(currentInp.duration),\n                    targetSelector: currentInp.targetSelector,\n                    time: currentInp.startTime,\n                    subParts: currentInp.subParts,\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            subPartsTracker.stop();\n        },\n    };\n}\n/**\n * Maintains a bounded list of the slowest interactions seen so far, used to estimate the p98\n * interaction duration without keeping every entry in memory.\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        isTracked(interactionId) {\n            return longestInteractions.some((i) => i.interactionId === interactionId);\n        },\n    };\n}\n/**\n * Tracks the number of interactions that occurred during the current view. Freezes the count\n * when the view ends so that the p98 estimate remains stable after `setViewEnd` is called.\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}\n/**\n * Groups performance entries by interaction and render time to compute INP subparts\n * (input delay, processing duration, presentation delay). Entries sharing the same\n * interactionId, or whose render time falls within the 8 ms Event Timing rounding window,\n * are merged into a single group so that subparts always sum to the reported INP duration.\n */\nfunction createSubPartsTracker(longestInteractions) {\n    const groupsByInteractionId = new Map();\n    function updateGroupWithEntry(group, entry) {\n        group.startTime = Math.min(entry.startTime, group.startTime);\n        // For each group, we keep the biggest interval possible between processingStart and processingEnd\n        group.processingStart = Math.min(entry.processingStart, group.processingStart);\n        group.processingEnd = Math.max(entry.processingEnd, group.processingEnd);\n    }\n    return {\n        process(entry) {\n            if (entry.interactionId === undefined || !entry.processingStart || !entry.processingEnd) {\n                return;\n            }\n            const renderTime = (entry.startTime + entry.duration);\n            const existingGroup = groupsByInteractionId.get(entry.interactionId);\n            if (existingGroup) {\n                // Update existing group with MIN/MAX values (keep original referenceRenderTime)\n                updateGroupWithEntry(existingGroup, entry);\n                return;\n            }\n            // Try to find a group within 8ms window to merge with (different interactionId, same frame)\n            for (const [, group] of groupsByInteractionId.entries()) {\n                if (Math.abs(renderTime - group.referenceRenderTime) <= RENDER_TIME_GROUPING_THRESHOLD) {\n                    updateGroupWithEntry(group, entry);\n                    // Also store under this entry's interactionId for easy lookup\n                    groupsByInteractionId.set(entry.interactionId, group);\n                    return;\n                }\n            }\n            // Create new group\n            groupsByInteractionId.set(entry.interactionId, {\n                startTime: entry.startTime,\n                processingStart: entry.processingStart,\n                processingEnd: entry.processingEnd,\n                referenceRenderTime: renderTime,\n            });\n        },\n        // Prune after all entries are grouped: groups not in longestInteractions can never affect p98 subparts.\n        // Keeps groupsByInteractionId capped at MAX_INTERACTION_ENTRIES\n        pruneUntracked() {\n            for (const [interactionId] of groupsByInteractionId) {\n                if (!longestInteractions.isTracked(interactionId)) {\n                    groupsByInteractionId.delete(interactionId);\n                }\n            }\n        },\n        computeSubParts(entry, inpDuration) {\n            if (!entry.processingStart || !entry.processingEnd || entry.interactionId === undefined) {\n                return undefined;\n            }\n            const group = groupsByInteractionId.get(entry.interactionId);\n            // Shouldn't happen since entries are grouped before p98 calculation.\n            if (!group) {\n                return undefined;\n            }\n            // Use group.startTime consistently to ensure subparts sum to inpDuration\n            // Math.max prevents nextPaintTime from being before processingStart (Chrome implementation)\n            const nextPaintTime = Math.max((group.startTime + inpDuration), group.processingStart);\n            // Clamp processingEnd to not exceed nextPaintTime\n            const processingEnd = Math.min(group.processingEnd, nextPaintTime);\n            return {\n                inputDelay: elapsed(group.startTime, group.processingStart),\n                processingDuration: elapsed(group.processingStart, processingEnd),\n                presentationDelay: elapsed(processingEnd, nextPaintTime),\n            };\n        },\n        stop() {\n            groupsByInteractionId.clear();\n        },\n    };\n}\nexport function isInteractionToNextPaintSupported() {\n    return (supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n        window.PerformanceEventTiming &&\n        'interactionId' in PerformanceEventTiming.prototype);\n}\nfunction sanitizeInpValue(inpValue) {\n    return Math.min(inpValue, MAX_INP_VALUE);\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 { elapsed, timeStampNow } from '@datadog/browser-core';\nimport { 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    let hasManualLoadingTime = false;\n    let viewEnded = false;\n    const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {\n        if (!hasManualLoadingTime) {\n            commonViewMetrics.loadingTime = newLoadingTime;\n            scheduleViewUpdate();\n        }\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: setINPViewEnd, } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType);\n    return {\n        stop: () => {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        stopINPTracking,\n        setLoadEvent,\n        setViewEnd: (viewEndTime) => {\n            viewEnded = true;\n            setINPViewEnd(viewEndTime);\n        },\n        getCommonViewMetrics: () => {\n            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();\n            return commonViewMetrics;\n        },\n        setLoadingTime: (callTimestamp) => {\n            if (viewEnded) {\n                return;\n            }\n            const loadingTime = elapsed(viewStart.timeStamp, callTimestamp !== null && callTimestamp !== void 0 ? callTimestamp : timeStampNow());\n            if (!hasManualLoadingTime) {\n                stopLoadingTimeTracking();\n            }\n            hasManualLoadingTime = true;\n            commonViewMetrics.loadingTime = loadingTime;\n            scheduleViewUpdate();\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, mockable, } 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(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, 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        setLoadingTime: (callTimestamp) => currentView.setLoadingTime(callTimestamp),\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, 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(mockable(window.location));\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    const handlingStack = viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.handlingStack;\n    if (context) {\n        contextManager.setContext(context);\n    }\n    const viewCreatedEvent = {\n        id,\n        name,\n        startClocks,\n        service,\n        version,\n        context,\n        url: viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.url,\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, setLoadingTime, } = 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            handlingStack,\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        setLoadingTime,\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, 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(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        startClocks: view.startClocks,\n        duration: view.duration,\n        domainContext: {\n            location: view.location,\n            handlingStack: view.handlingStack,\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            sub_parts: interactionToNextPaint.subParts\n                ? {\n                    input_delay: toServerDuration(interactionToNextPaint.subParts.inputDelay),\n                    processing_duration: toServerDuration(interactionToNextPaint.subParts.processingDuration),\n                    presentation_delay: toServerDuration(interactionToNextPaint.subParts.presentationDelay),\n                }\n                : undefined,\n        },\n        lcp: largestContentfulPaint && {\n            timestamp: toServerDuration(largestContentfulPaint.value),\n            target_selector: largestContentfulPaint.targetSelector,\n            resource_url: largestContentfulPaint.resourceUrl,\n            sub_parts: largestContentfulPaint.subParts\n                ? {\n                    load_delay: toServerDuration(largestContentfulPaint.subParts.loadDelay),\n                    load_time: toServerDuration(largestContentfulPaint.subParts.loadTime),\n                    render_delay: toServerDuration(largestContentfulPaint.subParts.renderDelay),\n                }\n                : undefined,\n        },\n    };\n}\n//# sourceMappingURL=viewCollection.js.map","import { Observable } from '../../tools/observable';\nimport { createValueHistory } from '../../tools/valueHistory';\nimport { clocksOrigin, 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 { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY, SessionPersistence } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nimport { retrieveSessionCookie } from './storeStrategies/sessionInCookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { retrieveSessionFromLocalStorage } from './storeStrategies/sessionInLocalStorage';\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    trackingConsentState.observable.subscribe(() => {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n        else {\n            sessionStore.expire(false);\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(configuration).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(configuration) {\n    const sessionStoreStrategyType = configuration.sessionStoreStrategyType;\n    if (!sessionStoreStrategyType) {\n        return;\n    }\n    let rawSession;\n    let cookieContext;\n    if (sessionStoreStrategyType.type === SessionPersistence.COOKIE) {\n        rawSession = retrieveSessionCookie(sessionStoreStrategyType.cookieOptions, configuration);\n        cookieContext = {\n            cookie: await getSessionCookies(),\n            currentDomain: `${window.location.protocol}//${window.location.hostname}`,\n        };\n    }\n    else {\n        rawSession = retrieveSessionFromLocalStorage();\n    }\n    // monitor-until: forever, could be handy to troubleshoot issues until session manager rework\n    addTelemetryDebug('Unexpected session state', {\n        sessionStoreStrategyType: sessionStoreStrategyType.type,\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        ...cookieContext,\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, mockable, buildUrl, } 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) {\n    const urlContextHistory = createValueHistory({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY });\n    let previousViewUrl;\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, ({ startClocks, url }) => {\n        const locationHref = mockable(location).href;\n        const viewUrl = url !== undefined ? buildUrl(url, locationHref).href : locationHref;\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) {\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    let previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n    const watchCookieIntervalId = setInterval(() => {\n        const cookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n        if (cookieValue !== previousCookieValue) {\n            previousCookieValue = cookieValue;\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 { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types';\nimport { createPerformanceObservable, RumPerformanceEntryType, supportPerformanceTimingEvent, } from '../../browser/performanceObservable';\nexport function startLongTaskCollection(lifeCycle, configuration) {\n    const entryType = supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME)\n        ? RumPerformanceEntryType.LONG_ANIMATION_FRAME\n        : RumPerformanceEntryType.LONG_TASK;\n    const subscription = createPerformanceObservable(configuration, {\n        type: entryType,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            if (!configuration.trackLongTasks) {\n                break;\n            }\n            const startClocks = relativeToClocks(entry.startTime);\n            const rawRumEvent = processEntry(entry, startClocks);\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent,\n                startClocks,\n                duration: entry.duration,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return {\n        stop: () => subscription.unsubscribe(),\n    };\n}\nfunction processEntry(entry, startClocks) {\n    const id = generateUUID();\n    const duration = toServerDuration(entry.duration);\n    const baseEvent = {\n        date: startClocks.timeStamp,\n        type: RumEventType.LONG_TASK,\n        _dd: { discarded: false },\n    };\n    if (entry.entryType === RumPerformanceEntryType.LONG_TASK) {\n        return {\n            ...baseEvent,\n            long_task: {\n                id,\n                entry_type: RumLongTaskEntryType.LONG_TASK,\n                duration,\n            },\n        };\n    }\n    return {\n        ...baseEvent,\n        long_task: {\n            id,\n            entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,\n            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    };\n}\n//# sourceMappingURL=longTaskCollection.js.map","import { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\n// Limit the maximum number of actions, errors and logs per minutes\nconst EVENT_RATE_LIMIT = 3000;\nexport function createEventRateLimiter(eventType, onLimitReached, limit = EVENT_RATE_LIMIT) {\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 *\n * Modifications of the object are sanitized only if the field was actually changed by the modifier function (i.e., value is different).\n * This ensures consistent SDK behavior regardless of whether limitModification is called.\n * Only string fields are handled this way, object fields are sanitized regardless of whether the modifier function was called or not.\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    if (object[field] === value) {\n        return;\n    }\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, eventRateLimit) {\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.handling_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            'resource.graphql.variables': 'string',\n            'resource.request.headers': 'object',\n            'resource.response.headers': 'object',\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, reportError, eventRateLimit),\n        [RumEventType.ACTION]: createEventRateLimiter(RumEventType.ACTION, reportError, eventRateLimit),\n        [RumEventType.VITAL]: createEventRateLimiter(RumEventType.VITAL, reportError, eventRateLimit),\n    };\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ startClocks, duration, rawRumEvent, domainContext }) => {\n        const defaultRumEventAttributes = hooks.triggerHook(0 /* HookNames.Assemble */, {\n            eventType: rawRumEvent.type,\n            rawRumEvent,\n            domainContext,\n            startTime: startClocks.relative,\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 { relativeToClocks } from '@datadog/browser-core';\nimport { 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                startClocks: relativeToClocks(startTime),\n                rawRumEvent: event,\n                domainContext,\n                duration,\n            });\n        },\n    };\n}\n//# sourceMappingURL=eventCollection.js.map","import { SKIPPED, computeStackTrace, objectEntries, addTelemetryError } from '@datadog/browser-core';\nexport function startSourceCodeContext(hooks) {\n    const browserWindow = window;\n    const contextByFile = new Map();\n    function buildContextByFile() {\n        if (!browserWindow.DD_SOURCE_CODE_CONTEXT) {\n            return;\n        }\n        objectEntries(browserWindow.DD_SOURCE_CODE_CONTEXT).forEach(([stack, context]) => {\n            const stackTrace = computeStackTrace({ stack });\n            const firstFrame = stackTrace.stack[0];\n            if (!firstFrame.url) {\n                addTelemetryError('Source code context: missing frame url', { stack });\n                return;\n            }\n            // don't overwrite existing context\n            if (!contextByFile.has(firstFrame.url)) {\n                contextByFile.set(firstFrame.url, context);\n            }\n        });\n        browserWindow.DD_SOURCE_CODE_CONTEXT = {};\n    }\n    buildContextByFile();\n    hooks.register(0 /* HookNames.Assemble */, ({ domainContext, rawRumEvent }) => {\n        buildContextByFile();\n        if (contextByFile.size === 0) {\n            return SKIPPED;\n        }\n        const url = getSourceUrl(domainContext, rawRumEvent);\n        const context = url && contextByFile.get(url);\n        if (!context) {\n            return SKIPPED;\n        }\n        return {\n            type: rawRumEvent.type,\n            service: context.service,\n            version: context.version,\n        };\n    });\n}\nfunction getSourceUrl(domainContext, rawRumEvent) {\n    var _a, _b;\n    if (rawRumEvent.type === 'long_task' && rawRumEvent.long_task.entry_type === 'long-animation-frame') {\n        return (_a = rawRumEvent.long_task.scripts[0]) === null || _a === void 0 ? void 0 : _a.source_url;\n    }\n    let stack;\n    if ('handlingStack' in domainContext) {\n        stack = domainContext.handlingStack;\n    }\n    if (rawRumEvent.type === 'error' && rawRumEvent.error.stack) {\n        stack = rawRumEvent.error.stack;\n    }\n    const stackTrace = computeStackTrace({ stack });\n    return (_b = stackTrace.stack[0]) === null || _b === void 0 ? void 0 : _b.url;\n}\n//# sourceMappingURL=sourceCodeContext.js.map","import { sendToExtension, createPageMayExitObservable, canUseEventBridge, addTelemetryDebug, startAccountContext, startGlobalContext, startUserContext, startTabContext, } 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 { 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 { startEventCollection } from '../domain/event/eventCollection';\nimport { startInitialViewMetricsTelemetry } from '../domain/view/viewMetrics/startInitialViewMetricsTelemetry';\nimport { startSourceCodeContext } from '../domain/contexts/sourceCodeContext';\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, telemetry, hooks, sdkName) {\n    const cleanupTasks = [];\n    const lifeCycle = new LifeCycle();\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 session = !canUseEventBridge()\n        ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n        : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        const batch = startRumBatch(configuration, lifeCycle, reportError, pageMayExitObservable, session.expireObservable, createEncoder);\n        const preparePageExitSubscription = batch.flushController.preparePageExitFlushObservable.subscribe((reason) => {\n            lifeCycle.notify(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, { reason });\n        });\n        cleanupTasks.push(() => preparePageExitSubscription.unsubscribe());\n        cleanupTasks.push(() => batch.stop());\n        startCustomerDataTelemetry(telemetry, lifeCycle, batch.flushController.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n        const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n            lifeCycle.notify(11 /* LifeCycleEventType.PAGE_MAY_EXIT */, event);\n        });\n        cleanupTasks.push(() => pageMayExitSubscription.unsubscribe());\n    }\n    startTrackingConsentContext(hooks, trackingConsentState);\n    const { stop: stopInitialViewMetricsTelemetry } = startInitialViewMetricsTelemetry(lifeCycle, telemetry);\n    cleanupTasks.push(stopInitialViewMetricsTelemetry);\n    const { stop: stopRumEventCollection, ...startRumEventCollectionResult } = startRumEventCollection(lifeCycle, hooks, configuration, session, recorderApi, initialViewOptions, customVitalsState, bufferedDataObservable, sdkName, reportError);\n    cleanupTasks.push(stopRumEventCollection);\n    bufferedDataObservable.unbuffer();\n    // Add Clean-up tasks for Profiler API.\n    cleanupTasks.push(() => profilerApi.stop());\n    return {\n        ...startRumEventCollectionResult,\n        lifeCycle,\n        session,\n        stopSession: () => session.expire(),\n        telemetry,\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n        hooks,\n    };\n}\nexport function startRumEventCollection(lifeCycle, hooks, configuration, session, recorderApi, initialViewOptions, customVitalsState, bufferedDataObservable, sdkName, reportError) {\n    const cleanupTasks = [];\n    const domMutationObservable = createDOMMutationObservable();\n    const locationChangeObservable = createLocationChangeObservable(configuration);\n    const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable();\n    cleanupTasks.push(stopWindowOpen);\n    startDefaultContext(hooks, configuration, sdkName);\n    const pageStateHistory = startPageStateHistory(hooks, configuration);\n    cleanupTasks.push(() => pageStateHistory.stop());\n    const viewHistory = startViewHistory(lifeCycle);\n    cleanupTasks.push(() => viewHistory.stop());\n    const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable);\n    cleanupTasks.push(() => urlContexts.stop());\n    const featureFlagContexts = startFeatureFlagContexts(lifeCycle, hooks, configuration);\n    startSessionContext(hooks, session, recorderApi, viewHistory);\n    startConnectivityContext(hooks);\n    startTabContext(hooks);\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 actionCollection = startActionCollection(lifeCycle, hooks, domMutationObservable, windowOpenObservable, configuration);\n    cleanupTasks.push(actionCollection.stop);\n    const eventCollection = startEventCollection(lifeCycle);\n    const displayContext = startDisplayContext(hooks, configuration);\n    cleanupTasks.push(displayContext.stop);\n    const ciVisibilityContext = startCiVisibilityContext(configuration, hooks);\n    cleanupTasks.push(ciVisibilityContext.stop);\n    startSyntheticsContext(hooks);\n    startRumAssembly(configuration, lifeCycle, hooks, reportError);\n    const { addTiming, setLoadingTime, startView, setViewName, setViewContext, setViewContextProperty, getViewContext, stop: stopViewCollection, } = startViewCollection(lifeCycle, hooks, configuration, domMutationObservable, windowOpenObservable, locationChangeObservable, recorderApi, viewHistory, initialViewOptions);\n    startSourceCodeContext(hooks);\n    cleanupTasks.push(stopViewCollection);\n    const resourceCollection = startResourceCollection(lifeCycle, configuration, pageStateHistory);\n    cleanupTasks.push(resourceCollection.stop);\n    const { stop: stopLongTaskCollection } = startLongTaskCollection(lifeCycle, configuration);\n    cleanupTasks.push(stopLongTaskCollection);\n    const { addError } = startErrorCollection(lifeCycle, configuration, bufferedDataObservable);\n    startRequestCollection(lifeCycle, configuration, session, userContext, accountContext);\n    const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState);\n    const internalContext = startInternalContext(configuration.applicationId, session, viewHistory, actionCollection.actionContexts, urlContexts);\n    return {\n        addAction: actionCollection.addAction,\n        startAction: actionCollection.startAction,\n        stopAction: actionCollection.stopAction,\n        startResource: resourceCollection.startResource,\n        stopResource: resourceCollection.stopResource,\n        addEvent: eventCollection.addEvent,\n        addError,\n        addTiming,\n        setLoadingTime,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView,\n        setViewContext,\n        setViewContextProperty,\n        getViewContext,\n        setViewName,\n        viewHistory,\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        stop: () => cleanupTasks.forEach((task) => task()),\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, reportError),\n        flushController: createFlushController({\n            pageMayExitObservable,\n            sessionExpireObservable,\n        }),\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 { 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 { 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 { 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                    trace_sample_rate: round(configuration.traceSampleRate, 3),\n                    beta_encode_cookie_options: configuration.betaEncodeCookieOptions,\n                },\n                browser_sdk_version: canUseEventBridge() ? \"6.33.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 { 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, getSyntheticsContext, 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        return {\n            type: eventType,\n            session: {\n                type: \"synthetics\" /* SessionType.SYNTHETICS */,\n            },\n            synthetics: {\n                ...getSyntheticsContext(),\n                injected: willSyntheticsInjectRum(),\n            },\n        };\n    });\n}\n//# sourceMappingURL=syntheticsContext.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 { ContextManagerMethod, addTelemetryUsage, deepClone, makePublicApi, monitor, clocksNow, callMonitored, createHandlingStack, sanitize, createIdentityEncoder, displayAlreadyInitializedError, createTrackingConsentState, timeStampToClocks, CustomerContextKey, defineContextMethod, startBufferingData, isExperimentalFeatureEnabled, ExperimentalFeature, mockable, generateUUID, timeStampNow, } 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';\nimport { startRum } from './startRum';\nexport function makeRumPublicApi(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, telemetry, hooks) => {\n        const createEncoder = deflateWorker && options.createDeflateEncoder\n            ? (streamId) => options.createDeflateEncoder(configuration, deflateWorker, streamId)\n            : createIdentityEncoder;\n        const startRumResult = mockable(startRum)(configuration, recorderApi, profilerApi, initialViewOptions, createEncoder, trackingConsentState, customVitalsState, bufferedDataObservable, telemetry, hooks, 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            addError: startRumResult.addError,\n        });\n        return startRumResult;\n    });\n    const getStrategy = () => strategy;\n    const startView = (options) => {\n        const handlingStack = createHandlingStack('view');\n        callMonitored(() => {\n            const sanitizedOptions = typeof options === 'object' ? options : { name: options };\n            strategy.startView({ ...sanitizedOptions, handlingStack });\n            addTelemetryUsage({ feature: 'start-view' });\n        });\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        startAction: monitor((name, options) => {\n            // Check feature flag only after init; pre-init calls should be buffered\n            if (strategy.initConfiguration && !isExperimentalFeatureEnabled(ExperimentalFeature.START_STOP_ACTION)) {\n                return;\n            }\n            // addTelemetryUsage({ feature: 'start-action' })\n            strategy.startAction(sanitize(name), {\n                type: sanitize(options && options.type),\n                context: sanitize(options && options.context),\n                actionKey: options && options.actionKey,\n            });\n        }),\n        stopAction: monitor((name, options) => {\n            if (strategy.initConfiguration && !isExperimentalFeatureEnabled(ExperimentalFeature.START_STOP_ACTION)) {\n                return;\n            }\n            // addTelemetryUsage({ feature: 'stop-action' })\n            strategy.stopAction(sanitize(name), {\n                type: sanitize(options && options.type),\n                context: sanitize(options && options.context),\n                actionKey: options && options.actionKey,\n            });\n        }),\n        startResource: monitor((url, options) => {\n            // Check feature flag only after init; pre-init calls should be buffered\n            if (strategy.initConfiguration && !isExperimentalFeatureEnabled(ExperimentalFeature.START_STOP_RESOURCE)) {\n                return;\n            }\n            // addTelemetryUsage({ feature: 'start-resource' })\n            strategy.startResource(sanitize(url), {\n                type: sanitize(options && options.type),\n                method: sanitize(options && options.method),\n                context: sanitize(options && options.context),\n                resourceKey: options && options.resourceKey,\n            });\n        }),\n        stopResource: monitor((url, options) => {\n            if (strategy.initConfiguration && !isExperimentalFeatureEnabled(ExperimentalFeature.START_STOP_RESOURCE)) {\n                return;\n            }\n            // addTelemetryUsage({ feature: 'stop-resource' })\n            strategy.stopResource(sanitize(url), {\n                type: sanitize(options && options.type),\n                statusCode: options && options.statusCode,\n                size: options && options.size,\n                context: sanitize(options && options.context),\n                resourceKey: options && options.resourceKey,\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        setViewLoadingTime: monitor(() => {\n            const callTimestamp = timeStampNow();\n            strategy.setLoadingTime(callTimestamp);\n            addTelemetryUsage({\n                feature: 'addViewLoadingTime',\n            });\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: (name, options) => {\n            const handlingStack = createHandlingStack('vital');\n            callMonitored(() => {\n                addTelemetryUsage({ feature: 'add-duration-vital' });\n                strategy.addDurationVital({\n                    id: generateUUID(),\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                    handlingStack,\n                });\n            });\n        },\n        startDurationVital: (name, options) => {\n            const handlingStack = createHandlingStack('vital');\n            return callMonitored(() => {\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                    handlingStack,\n                });\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: (name, options) => {\n            const handlingStack = createHandlingStack('vital');\n            callMonitored(() => {\n                addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'start' });\n                strategy.addOperationStepVital(name, 'start', { ...options, handlingStack });\n            });\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 { BufferedObservable } from '../tools/observable';\nimport { mockable } from '../tools/mockable';\nimport { trackRuntimeError } from './error/trackRuntimeError';\nconst BUFFER_LIMIT = 500;\nexport function startBufferingData() {\n    const observable = new BufferedObservable(BUFFER_LIMIT);\n    const runtimeErrorSubscription = mockable(trackRuntimeError)().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 { 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], 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","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    Change: 12,\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 ChangeType = {\n    AddString: 0,\n    AddNode: 1,\n    RemoveNode: 2,\n    Attribute: 3,\n    Text: 4,\n    Size: 5,\n    ScrollPosition: 6,\n    AddStyleSheet: 7,\n    AttachedStyleSheets: 8,\n    MediaPlaybackState: 9,\n    VisualViewport: 10,\n};\nexport const PlaybackState = {\n    Playing: 0,\n    Paused: 1,\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};\nexport const SnapshotFormat = {\n    V1: 0,\n    Change: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","import { ExperimentalFeature, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nexport function isFullSnapshotChangeRecordsEnabled() {\n    // We don't want to have to support the case where full snapshots use the old format and\n    // incremental snapshots use the new one, so we should generate full snapshot Change\n    // records if either feature flag is enabled.\n    return (isExperimentalFeatureEnabled(ExperimentalFeature.USE_CHANGE_RECORDS) ||\n        isExperimentalFeatureEnabled(ExperimentalFeature.USE_INCREMENTAL_CHANGE_RECORDS));\n}\nexport function isIncrementalSnapshotChangeRecordsEnabled() {\n    return isExperimentalFeatureEnabled(ExperimentalFeature.USE_INCREMENTAL_CHANGE_RECORDS);\n}\n//# sourceMappingURL=experimentalFeatures.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}\n/**\n * Returns the tag name of the given element, normalized to ensure a consistent lowercase\n * representation regardless of whether the element is HTML, XHTML, or SVG.\n */\nexport function normalizedTagName(element) {\n    return element.tagName.toLowerCase();\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, transaction) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    const serializeStylesheet = (cssStyleSheet) => {\n        const rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        const cssRules = Array.from(rules, (cssRule) => cssRule.cssText);\n        transaction.addMetric('cssText', cssRules.reduce((totalLength, rule) => totalLength + rule.length, 0));\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    // Safari iOS 16.x implements adoptedStyleSheets as a FrozenArray that:\n    // - can't be iterated over through map or for...of\n    // - can't be converted to regular array with Array.from\n    // - can't be detected with Array.isArray or Object.isFrozen\n    // Use index access to avoid the issue\n    const styleSheets = [];\n    for (let index = 0; index < cssStyleSheets.length; index++) {\n        styleSheets.push(serializeStylesheet(cssStyleSheets[index]));\n    }\n    return styleSheets;\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { NodePrivacyLevel, CENSORED_STRING_MARK, CENSORED_IMG_MARK, sanitizeIfLongDataUrl, shouldMaskAttribute, } 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    const tagName = element.tagName;\n    if (shouldMaskAttribute(tagName, attributeName, attributeValue, nodePrivacyLevel, configuration)) {\n        // mask image URLs\n        if (tagName === 'IMG') {\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        if (tagName === 'SOURCE') {\n            return CENSORED_IMG_MARK;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (!attributeValue) {\n        return attributeValue;\n    }\n    return sanitizeIfLongDataUrl(attributeValue, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH);\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { isSafari } from '@datadog/browser-core';\nimport { getElementInputValue, normalizedTagName, switchToAbsoluteUrl } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, transaction) {\n    return {\n        ...serializeDOMAttributes(element, nodePrivacyLevel, transaction),\n        ...serializeVirtualAttributes(element, nodePrivacyLevel, transaction),\n    };\n}\nexport function serializeDOMAttributes(element, nodePrivacyLevel, transaction) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    const attrs = {};\n    const tagName = normalizedTagName(element);\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, transaction.scope.configuration);\n        if (attributeValue !== null) {\n            attrs[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            attrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option') {\n        const optionElement = element;\n        if (optionElement.selected && !shouldMaskNode(optionElement, nodePrivacyLevel)) {\n            attrs.selected = '';\n        }\n        else {\n            delete attrs.selected;\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 (inputElement.checked && !shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            attrs.checked = '';\n        }\n        else {\n            delete attrs.checked;\n        }\n    }\n    return attrs;\n}\nexport function serializeVirtualAttributes(element, nodePrivacyLevel, transaction) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    const attrs = {};\n    const doc = element.ownerDocument;\n    const tagName = normalizedTagName(element);\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            transaction.addMetric('cssText', cssText.length);\n            attrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        const cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            transaction.addMetric('cssText', cssText.length);\n            attrs._cssText = cssText;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        const mediaElement = element;\n        attrs.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    switch (transaction.kind) {\n        case 0 /* SerializationKind.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                transaction.scope.elementsScrollPositions.set(element, { scrollTop, scrollLeft });\n            }\n            break;\n        case 1 /* SerializationKind.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (transaction.scope.elementsScrollPositions.has(element)) {\n                ;\n                ({ scrollTop, scrollLeft } = transaction.scope.elementsScrollPositions.get(element));\n            }\n            break;\n    }\n    if (scrollLeft) {\n        attrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        attrs.rr_scrollTop = scrollTop;\n    }\n    return attrs;\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 serializeNode(node, parentNodePrivacyLevel, transaction) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, parentNodePrivacyLevel, transaction);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, parentNodePrivacyLevel, transaction);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node, transaction);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, parentNodePrivacyLevel, transaction);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, parentNodePrivacyLevel, transaction);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode(node, transaction);\n        default:\n            return null;\n    }\n}\nexport function serializeChildNodes(node, parentNodePrivacyLevel, transaction) {\n    const result = [];\n    forEachChildNodes(node, (childNode) => {\n        const serializedChildNode = serializeNode(childNode, parentNodePrivacyLevel, transaction);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nexport function serializeDocumentNode(document, parentNodePrivacyLevel, transaction) {\n    return {\n        type: NodeType.Document,\n        id: transaction.assignId(document),\n        childNodes: serializeChildNodes(document, parentNodePrivacyLevel, transaction),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets, transaction),\n    };\n}\nfunction serializeDocumentFragmentNode(element, parentNodePrivacyLevel, transaction) {\n    const isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        transaction.scope.shadowRootsController.addShadowRoot(element, transaction.scope);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        id: transaction.assignId(element),\n        childNodes: serializeChildNodes(element, parentNodePrivacyLevel, transaction),\n        isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets, transaction) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType, transaction) {\n    return {\n        type: NodeType.DocumentType,\n        id: transaction.assignId(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, transaction) {\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            id: transaction.assignId(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 null;\n    }\n    const id = transaction.assignId(element);\n    const attributes = serializeAttributes(element, nodePrivacyLevel, transaction);\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, transaction);\n    }\n    return {\n        type: NodeType.Element,\n        id,\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, transaction) {\n    const textContent = getTextContent(textNode, parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return null;\n    }\n    return {\n        type: NodeType.Text,\n        id: transaction.assignId(textNode),\n        textContent,\n    };\n}\nfunction serializeCDataNode(node, transaction) {\n    return {\n        type: NodeType.CDATA,\n        id: transaction.assignId(node),\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.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 { elapsed, timeStampNow } from '@datadog/browser-core';\nimport { ChangeType, RecordType, SnapshotFormat } from '../../../types';\nimport { createSerializationStats, updateSerializationStats } from './serializationStats';\nimport { createChangeEncoder } from './changeEncoder';\n/**\n * Perform serialization within a transaction. At the end of the transaction, the\n * generated records and statistics will be emitted.\n */\nexport function serializeInTransaction(kind, emitRecord, emitStats, scope, serialize) {\n    const records = [];\n    const stats = createSerializationStats();\n    const transaction = {\n        add(record) {\n            records.push(record);\n        },\n        addMetric(metric, value) {\n            updateSerializationStats(stats, metric, value);\n        },\n        assignId(node) {\n            const id = scope.nodeIds.getOrInsert(node);\n            if (transaction.serializedNodeIds) {\n                transaction.serializedNodeIds.add(id);\n            }\n            return id;\n        },\n        kind,\n        scope,\n    };\n    const start = timeStampNow();\n    serialize(transaction);\n    updateSerializationStats(stats, 'serializationDuration', elapsed(start, timeStampNow()));\n    for (const record of records) {\n        emitRecord(record);\n    }\n    emitStats(stats);\n}\nexport function serializeChangesInTransaction(kind, emitRecord, emitStats, scope, timestamp, serialize) {\n    const encoder = createChangeEncoder(scope.stringIds);\n    const stats = createSerializationStats();\n    const transaction = {\n        addMetric(metric, value) {\n            updateSerializationStats(stats, metric, value);\n        },\n        addNode(...change) {\n            encoder.add(ChangeType.AddNode, change);\n        },\n        addStyleSheet(rules, mediaList, disabled) {\n            if (disabled) {\n                encoder.add(ChangeType.AddStyleSheet, [rules, mediaList || [], disabled]);\n            }\n            else if (mediaList) {\n                encoder.add(ChangeType.AddStyleSheet, [rules, mediaList]);\n            }\n            else {\n                encoder.add(ChangeType.AddStyleSheet, [rules]);\n            }\n        },\n        attachStyleSheets(nodeId, sheetIds) {\n            const change = [nodeId];\n            for (const sheetId of sheetIds) {\n                change.push(sheetId);\n            }\n            encoder.add(ChangeType.AttachedStyleSheets, change);\n        },\n        removeNode(nodeId) {\n            encoder.add(ChangeType.RemoveNode, nodeId);\n        },\n        setAttributes(change) {\n            encoder.add(ChangeType.Attribute, change);\n        },\n        setMediaPlaybackState(nodeId, state) {\n            encoder.add(ChangeType.MediaPlaybackState, [nodeId, state]);\n        },\n        setScrollPosition(nodeId, x, y) {\n            encoder.add(ChangeType.ScrollPosition, [nodeId, x, y]);\n        },\n        setSize(nodeId, width, height) {\n            encoder.add(ChangeType.Size, [nodeId, width, height]);\n        },\n        setText(nodeId, content) {\n            encoder.add(ChangeType.Text, [nodeId, content]);\n        },\n        kind,\n        scope,\n    };\n    const start = timeStampNow();\n    serialize(transaction);\n    updateSerializationStats(stats, 'serializationDuration', elapsed(start, timeStampNow()));\n    const changes = encoder.flush();\n    if (changes.length > 0) {\n        if (kind === 0 /* SerializationKind.INITIAL_FULL_SNAPSHOT */ || kind === 1 /* SerializationKind.SUBSEQUENT_FULL_SNAPSHOT */) {\n            emitRecord({\n                data: changes,\n                format: SnapshotFormat.Change,\n                type: RecordType.FullSnapshot,\n                timestamp,\n            });\n        }\n        else {\n            emitRecord({\n                data: changes,\n                type: RecordType.Change,\n                timestamp,\n            });\n        }\n    }\n    emitStats(stats);\n}\n//# sourceMappingURL=serializationTransaction.js.map","import { ChangeType } from '../../../types';\nexport function createChangeEncoder(stringIds) {\n    let pendingChanges = {};\n    // A helper that searches for strings in arbitrarily-nested arrays, inserts any strings\n    // it finds into the string table, and replaces the strings with string table\n    // references.\n    const convertStringsToStringReferences = (array) => {\n        for (let index = 0, length = array.length; index < length; index++) {\n            const item = array[index];\n            if (typeof item === 'string') {\n                const previousSize = stringIds.size;\n                array[index] = stringIds.getOrInsert(item);\n                if (stringIds.size > previousSize) {\n                    add(ChangeType.AddString, item);\n                }\n            }\n            else if (Array.isArray(item)) {\n                convertStringsToStringReferences(item);\n            }\n        }\n    };\n    const add = (type, data) => {\n        if (!(type in pendingChanges)) {\n            pendingChanges[type] = [type];\n        }\n        if (type !== ChangeType.AddString && Array.isArray(data)) {\n            convertStringsToStringReferences(data);\n        }\n        pendingChanges[type].push(data);\n    };\n    const flush = () => {\n        const changes = [];\n        [\n            ChangeType.AddString,\n            ChangeType.AddNode,\n            ChangeType.RemoveNode,\n            ChangeType.Attribute,\n            ChangeType.Text,\n            ChangeType.Size,\n            ChangeType.ScrollPosition,\n            ChangeType.AddStyleSheet,\n            ChangeType.AttachedStyleSheets,\n            ChangeType.MediaPlaybackState,\n            ChangeType.VisualViewport,\n        ].forEach((changeType) => {\n            const change = pendingChanges[changeType];\n            if (change) {\n                changes.push(change);\n            }\n        });\n        pendingChanges = {};\n        return changes;\n    };\n    return { add, flush };\n}\n//# sourceMappingURL=changeEncoder.js.map","import { getScrollX, getScrollY } from '@datadog/browser-rum-core';\nimport { RecordType, SnapshotFormat } from '../../../types';\nimport { serializeNode } from './serializeNode';\nimport { serializeInTransaction } from './serializationTransaction';\nexport function serializeFullSnapshot(timestamp, kind, document, emitRecord, emitStats, scope) {\n    serializeInTransaction(kind, emitRecord, emitStats, scope, (transaction) => {\n        const defaultPrivacyLevel = transaction.scope.configuration.defaultPrivacyLevel;\n        // We are sure that Documents are never ignored, so this function never returns null.\n        const node = serializeNode(document, defaultPrivacyLevel, transaction);\n        const record = {\n            data: {\n                node,\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            format: SnapshotFormat.V1,\n            type: RecordType.FullSnapshot,\n            timestamp,\n        };\n        transaction.add(record);\n        scope.serializeObservable.notify({\n            type: 'full',\n            kind,\n            target: document,\n            timestamp,\n            v1: record,\n        });\n    });\n}\n//# sourceMappingURL=serializeFullSnapshot.js.map","import { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isNodeShadowRoot, forEachChildNodes, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, getScrollX, getScrollY, isElementNode, } from '@datadog/browser-rum-core';\nimport { MediaInteractionType } from '../../../types';\nimport { serializeDOMAttributes, serializeVirtualAttributes } from './serializeAttributes';\nexport function serializeNodeAsChange(cursor, node, parentPrivacyLevel, transaction) {\n    var _a;\n    // Ignore the children of <style> elements; the CSS rules they contain are already\n    // serialized as StyleSheetSnapshots.\n    if (((_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.nodeName) === 'STYLE') {\n        return;\n    }\n    // Never serialize the descendants of HIDDEN or IGNORE'd elements.\n    if (parentPrivacyLevel === NodePrivacyLevel.HIDDEN || parentPrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    let privacyLevel;\n    const selfPrivacyLevel = getNodeSelfPrivacyLevel(node);\n    if (selfPrivacyLevel) {\n        privacyLevel = reducePrivacyLevel(selfPrivacyLevel, parentPrivacyLevel);\n    }\n    else {\n        privacyLevel = parentPrivacyLevel;\n    }\n    if (privacyLevel === NodePrivacyLevel.HIDDEN) {\n        serializeHiddenNodePlaceholder(cursor, node, transaction);\n        return;\n    }\n    // Totally ignore risky or unwanted elements. (e.g. <script>, some <link> and <meta> elements)\n    if (privacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    switch (node.nodeType) {\n        case node.CDATA_SECTION_NODE:\n            serializeCDataNodeAsChange(cursor, node, transaction);\n            break;\n        case node.DOCUMENT_NODE:\n            serializeDocumentNodeAsChange(cursor, node, transaction);\n            break;\n        case node.DOCUMENT_FRAGMENT_NODE:\n            serializeDocumentFragmentNodeAsChange(cursor, node, transaction);\n            break;\n        case node.DOCUMENT_TYPE_NODE:\n            serializeDocumentTypeNodeAsChange(cursor, node, transaction);\n            break;\n        case node.ELEMENT_NODE:\n            serializeElementNodeAsChange(cursor, node, privacyLevel, transaction);\n            break;\n        case node.TEXT_NODE:\n            serializeTextNodeAsChange(cursor, node, privacyLevel, transaction);\n            break;\n        default:\n            return;\n    }\n    // If this node can't have children, we're done.\n    switch (node.nodeType) {\n        case node.CDATA_SECTION_NODE:\n        case node.DOCUMENT_TYPE_NODE:\n        case node.TEXT_NODE:\n            return;\n    }\n    cursor.descend();\n    forEachChildNodes(node, (childNode) => {\n        serializeNodeAsChange(cursor, childNode, privacyLevel, transaction);\n    });\n    cursor.ascend();\n}\nfunction serializeDocumentNodeAsChange(cursor, document, transaction) {\n    const { nodeId, insertionPoint } = cursor.advance(document);\n    transaction.addNode(insertionPoint, '#document');\n    transaction.setScrollPosition(nodeId, getScrollX(), getScrollY());\n    serializeStyleSheetsAsChange(document.adoptedStyleSheets, nodeId, transaction);\n}\nfunction serializeDocumentFragmentNodeAsChange(cursor, documentFragment, transaction) {\n    const { nodeId, insertionPoint } = cursor.advance(documentFragment);\n    const isShadowRoot = isNodeShadowRoot(documentFragment);\n    if (!isShadowRoot) {\n        transaction.addNode(insertionPoint, '#document-fragment');\n        return;\n    }\n    transaction.addNode(insertionPoint, '#shadow-root');\n    transaction.scope.shadowRootsController.addShadowRoot(documentFragment, transaction.scope);\n    serializeStyleSheetsAsChange(documentFragment.adoptedStyleSheets, nodeId, transaction);\n}\nfunction serializeDocumentTypeNodeAsChange(cursor, documentType, transaction) {\n    const { insertionPoint } = cursor.advance(documentType);\n    transaction.addNode(insertionPoint, '#doctype', documentType.name, documentType.publicId, documentType.systemId);\n}\nfunction serializeElementNodeAsChange(cursor, element, privacyLevel, transaction) {\n    const { nodeId, insertionPoint } = cursor.advance(element);\n    const domAttributes = Object.entries(serializeDOMAttributes(element, privacyLevel, transaction));\n    transaction.addNode(insertionPoint, encodedElementName(element), ...domAttributes);\n    const { _cssText: cssText, rr_mediaState: mediaState, rr_scrollLeft: scrollLeft, rr_scrollTop: scrollTop, } = serializeVirtualAttributes(element, privacyLevel, transaction);\n    const linkOrStyle = element;\n    if (cssText !== undefined && linkOrStyle.sheet) {\n        const sheetId = transaction.scope.styleSheetIds.getOrInsert(linkOrStyle.sheet);\n        transaction.addStyleSheet(cssText);\n        transaction.attachStyleSheets(nodeId, [sheetId]);\n    }\n    if (mediaState === 'played') {\n        transaction.setMediaPlaybackState(nodeId, MediaInteractionType.Play);\n    }\n    else if (mediaState === 'paused') {\n        transaction.setMediaPlaybackState(nodeId, MediaInteractionType.Pause);\n    }\n    if (scrollLeft !== undefined || scrollTop !== undefined) {\n        transaction.setScrollPosition(nodeId, scrollLeft || 0, scrollTop || 0);\n    }\n}\nfunction serializeTextNodeAsChange(cursor, textNode, privacyLevel, transaction) {\n    const textContent = getTextContent(textNode, privacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    const { insertionPoint } = cursor.advance(textNode);\n    transaction.addNode(insertionPoint, '#text', textContent);\n}\nfunction serializeCDataNodeAsChange(cursor, cdataNode, transaction) {\n    const { insertionPoint } = cursor.advance(cdataNode);\n    transaction.addNode(insertionPoint, '#cdata-section');\n}\nfunction serializeHiddenNodePlaceholder(cursor, node, transaction) {\n    // We only generate placeholders for element nodes; other hidden nodes are simply not\n    // serialized.\n    if (!isElementNode(node)) {\n        return;\n    }\n    const { nodeId, insertionPoint } = cursor.advance(node);\n    transaction.addNode(insertionPoint, encodedElementName(node), [PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN]);\n    const { width, height } = node.getBoundingClientRect();\n    transaction.setSize(nodeId, width, height);\n}\nfunction serializeStyleSheetsAsChange(sheets, nodeId, transaction) {\n    if (!sheets || sheets.length === 0) {\n        return undefined;\n    }\n    transaction.attachStyleSheets(nodeId, sheets.map((sheet) => serializeStyleSheetAsChange(sheet, transaction)));\n}\nfunction serializeStyleSheetAsChange(sheet, transaction) {\n    const rules = Array.from(sheet.cssRules || sheet.rules, (rule) => rule.cssText);\n    const mediaList = sheet.media.length > 0 ? Array.from(sheet.media) : undefined;\n    transaction.addMetric('cssText', rules.reduce((totalLength, rule) => totalLength + rule.length, 0));\n    transaction.addStyleSheet(rules, mediaList, sheet.disabled);\n    return transaction.scope.styleSheetIds.getOrInsert(sheet);\n}\nfunction encodedElementName(element) {\n    const nodeName = element.nodeName;\n    if (isSVGElement(element)) {\n        return `svg>${nodeName}`;\n    }\n    return nodeName;\n}\nfunction isSVGElement(element) {\n    return element.namespaceURI === 'http://www.w3.org/2000/svg';\n}\n//# sourceMappingURL=serializeNodeAsChange.js.map","/** Returns an InsertionCursor which starts positioned at the root of the document. */\nexport function createRootInsertionCursor(nodeIds) {\n    return createInsertionCursor(undefined, undefined, nodeIds);\n}\n/**\n * Returns an InsertionCursor which starts positioned in the child list of the given\n * parent node. If a next sibling is provided, the cursor points to the position\n * immediately before the next sibling; otherwise, the cursor points to the end of the\n * child list.\n */\nexport function createChildInsertionCursor(parentId, nextSiblingId, nodeIds) {\n    return createInsertionCursor(parentId, nextSiblingId, nodeIds);\n}\nfunction createInsertionCursor(parentId, nextSiblingId, nodeIds) {\n    let cursor = {\n        container: undefined,\n        parentId,\n        previousSiblingId: undefined,\n        nextSiblingId,\n    };\n    const computeInsertionPoint = (nodeId) => {\n        if (cursor.previousSiblingId === nodeId - 1) {\n            // Use an AppendAfterPreviousInsertionPoint. (i.e., 0)\n            return 0;\n        }\n        if (cursor.nextSiblingId !== undefined) {\n            // Use an InsertBeforeInsertionPoint. We identify the next sibling using a\n            // negative integer indicating the difference between the new node's id and its next\n            // sibling's id.\n            return cursor.nextSiblingId - nodeId;\n        }\n        if (cursor.parentId !== undefined) {\n            // Use an AppendChildInsertionPoint. We identify the parent node using a positive\n            // integer indicating the difference between the new node's id and its parent's id.\n            return nodeId - cursor.parentId;\n        }\n        // There's no parent. Use a RootInsertionPoint. (i.e., null)\n        return null;\n    };\n    return {\n        advance(node) {\n            const nodeId = nodeIds.getOrInsert(node);\n            const insertionPoint = computeInsertionPoint(nodeId);\n            cursor.previousSiblingId = nodeId;\n            return { nodeId, insertionPoint };\n        },\n        ascend() {\n            if (cursor.container) {\n                cursor = cursor.container;\n            }\n        },\n        descend() {\n            if (cursor.previousSiblingId !== undefined) {\n                cursor = {\n                    container: cursor,\n                    parentId: cursor.previousSiblingId,\n                    previousSiblingId: undefined,\n                    nextSiblingId: undefined,\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=insertionCursor.js.map","import { serializeChangesInTransaction } from './serializationTransaction';\nimport { serializeNodeAsChange } from './serializeNodeAsChange';\nimport { createRootInsertionCursor } from './insertionCursor';\nexport function serializeFullSnapshotAsChange(timestamp, kind, document, emitRecord, emitStats, scope) {\n    scope.resetIds();\n    serializeChangesInTransaction(kind, emitRecord, emitStats, scope, timestamp, (transaction) => {\n        serializeNodeAsChange(createRootInsertionCursor(scope.nodeIds), document, scope.configuration.defaultPrivacyLevel, transaction);\n    });\n}\n//# sourceMappingURL=serializeFullSnapshotAsChange.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data, timestamp = timeStampNow()) {\n    return {\n        data: {\n            source,\n            ...data,\n        },\n        type: RecordType.IncrementalSnapshot,\n        timestamp,\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { isNodeShadowHost, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, isNodeShadowRoot, } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { serializeInTransaction } from './serializationTransaction';\nimport { serializeNode } from './serializeNode';\nimport { serializeAttribute } from './serializeAttribute';\nimport { getElementInputValue } from './serializationUtils';\nexport function serializeMutations(timestamp, mutations, emitRecord, emitStats, scope) {\n    serializeInTransaction(2 /* SerializationKind.INCREMENTAL_SNAPSHOT */, emitRecord, emitStats, scope, (transaction) => processMutations(timestamp, mutations, transaction));\n}\nfunction processMutations(timestamp, mutations, transaction) {\n    const nodePrivacyLevelCache = new Map();\n    mutations\n        .filter((mutation) => mutation.type === 'childList')\n        .forEach((mutation) => {\n        mutation.removedNodes.forEach((removedNode) => {\n            traverseRemovedShadowDom(removedNode, transaction.scope.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        idsAreAssignedForNodeAndAncestors(mutation.target, transaction.scope.nodeIds) &&\n        getNodePrivacyLevel(mutation.target, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !== NodePrivacyLevel.HIDDEN);\n    const { adds, removes, hasBeenSerialized } = processChildListMutations(filteredMutations.filter((mutation) => mutation.type === 'childList'), nodePrivacyLevelCache, transaction);\n    const texts = processCharacterDataMutations(filteredMutations.filter((mutation) => mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)), nodePrivacyLevelCache, transaction);\n    const attributes = processAttributesMutations(filteredMutations.filter((mutation) => mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)), nodePrivacyLevelCache, transaction);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    const record = assembleIncrementalSnapshot(IncrementalSource.Mutation, {\n        adds,\n        removes,\n        texts,\n        attributes,\n    }, timestamp);\n    transaction.add(record);\n    transaction.scope.serializeObservable.notify({\n        type: 'incremental',\n        target: mutations,\n        timestamp,\n        v1: record,\n    });\n}\nfunction processChildListMutations(mutations, nodePrivacyLevelCache, transaction) {\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    transaction.serializedNodeIds = new Set();\n    const addedNodeMutations = [];\n    for (const node of sortedAddedAndMovedNodes) {\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        const serializedNode = serializeNode(node, parentNodePrivacyLevel, transaction);\n        if (!serializedNode) {\n            continue;\n        }\n        const parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: transaction.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 = transaction.scope.nodeIds.get(parent);\n        const id = transaction.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        var _a;\n        const id = transaction.scope.nodeIds.get(node);\n        return id !== undefined && ((_a = transaction.serializedNodeIds) === null || _a === void 0 ? void 0 : _a.has(id));\n    }\n    function getNextSibling(node) {\n        let nextSibling = node.nextSibling;\n        while (nextSibling) {\n            const id = transaction.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, nodePrivacyLevelCache, transaction) {\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 = transaction.scope.nodeIds.get(mutation.target);\n        if (id === undefined) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), transaction.scope.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, nodePrivacyLevelCache, transaction) {\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 = transaction.scope.nodeIds.get(mutation.target);\n        if (id === undefined) {\n            continue;\n        }\n        const privacyLevel = getNodePrivacyLevel(mutation.target, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        const attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, transaction.scope.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}\nexport function idsAreAssignedForNodeAndAncestors(node, nodeIds) {\n    let current = node;\n    while (current) {\n        if (nodeIds.get(current) === undefined && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\n    }\n    return true;\n}\n//# sourceMappingURL=serializeMutations.js.map","import { isNodeShadowHost, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, } from '@datadog/browser-rum-core';\nimport { serializeChangesInTransaction } from './serializationTransaction';\nimport { serializeNodeAsChange } from './serializeNodeAsChange';\nimport { createChildInsertionCursor } from './insertionCursor';\nimport { getElementInputValue } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeMutationsAsChange(timestamp, mutations, emitRecord, emitStats, scope) {\n    serializeChangesInTransaction(2 /* SerializationKind.INCREMENTAL_SNAPSHOT */, emitRecord, emitStats, scope, timestamp, (transaction) => processMutations(mutations, transaction));\n}\nfunction processMutations(mutations, transaction) {\n    const addedNodes = new Set();\n    const attributeMutations = new Map();\n    const characterDataMutations = new Map();\n    const removedNodes = new Set();\n    // Collect the changes made by this sequence of mutations. It's important to think of\n    // the mutations as telling us which parts of the tree are dirty, but not necessarily as\n    // specifying exactly which changes have occurred; trying to be too clever will result\n    // in incorrect behavior. For example, if we see a sequence of mutations where a node is\n    // removed and then added back in the same position, one might be tempted to \"cancel\n    // out\" these two changes and ignore both mutations, but that could cause us to miss\n    // changes to the node that occurred while it was detached.\n    for (const mutation of mutations) {\n        switch (mutation.type) {\n            case 'attributes': {\n                const node = mutation.target;\n                let attributes = attributeMutations.get(node);\n                if (!attributes) {\n                    attributes = new Map();\n                    attributeMutations.set(node, attributes);\n                }\n                const attributeName = mutation.attributeName;\n                if (!attributes.has(attributeName)) {\n                    attributes.set(attributeName, mutation.oldValue);\n                }\n                break;\n            }\n            case 'characterData':\n                if (!characterDataMutations.has(mutation.target)) {\n                    characterDataMutations.set(mutation.target, mutation.oldValue);\n                }\n                break;\n            case 'childList':\n                for (let index = 0; index < mutation.addedNodes.length; index++) {\n                    addedNodes.add(mutation.addedNodes[index]);\n                }\n                for (let index = 0; index < mutation.removedNodes.length; index++) {\n                    removedNodes.add(mutation.removedNodes[index]);\n                }\n                break;\n        }\n    }\n    // Before we process any mutations, snapshot the id that the next newly-added node will\n    // receive. We know that any node with an id greater than or equal to this one is new\n    // and will have been serialized in its entirety in processAddedNodes(), so we can skip\n    // processing more fine-grained mutations for these nodes.\n    const firstNewNodeId = transaction.scope.nodeIds.nextId;\n    // Because we process incremental mutations synchronously, we know that privacy levels\n    // cannot change during the process, so we use a single, shared privacy level cache.\n    const nodePrivacyLevelCache = new Map();\n    processRemovedNodes(removedNodes, transaction);\n    processAddedNodes(addedNodes, nodePrivacyLevelCache, transaction);\n    processCharacterDataMutations(characterDataMutations, firstNewNodeId, nodePrivacyLevelCache, transaction);\n    processAttributeMutations(attributeMutations, firstNewNodeId, nodePrivacyLevelCache, transaction);\n}\nfunction processRemovedNodes(nodes, transaction) {\n    const nodeIds = transaction.scope.nodeIds;\n    for (const node of nodes) {\n        const nodeId = nodeIds.get(node);\n        if (nodeId === undefined) {\n            continue; // This node wasn't serialized.\n        }\n        forNodeAndDescendants(node, (node) => {\n            if (isNodeShadowHost(node)) {\n                transaction.scope.shadowRootsController.removeShadowRoot(node.shadowRoot);\n            }\n            // Forget this node's identity. If it's added to the DOM again in another mutation,\n            // we'll treat it as a new node. This reduces the number of edge cases that we need\n            // to deal with; for example, changes in privacy level as a result of the different\n            // ancestor chain in the new position are handled without any special effort on our\n            // part.\n            nodeIds.delete(node);\n        });\n        transaction.removeNode(nodeId);\n    }\n}\nfunction processAddedNodes(nodes, nodePrivacyLevelCache, transaction) {\n    const nodeIds = transaction.scope.nodeIds;\n    for (const node of nodes) {\n        if (!node.isConnected) {\n            continue; // This node is not in the DOM.\n        }\n        const existingNodeId = nodeIds.get(node);\n        if (existingNodeId !== undefined) {\n            continue; // This node has already been serialized.\n        }\n        const parentNode = getParentNode(node);\n        if (!parentNode) {\n            continue; // This node has no parent.\n        }\n        const parentId = nodeIds.get(parentNode);\n        if (parentId === undefined) {\n            // This node's parent hasn't been serialized (e.g. because it has privacy level\n            // HIDDEN), so we shouldn't serialize this node either.\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(parentNode, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        const nextSiblingId = getNextSiblingId(node, nodeIds);\n        serializeNodeAsChange(createChildInsertionCursor(parentId, nextSiblingId, nodeIds), node, parentNodePrivacyLevel, transaction);\n    }\n}\nfunction processCharacterDataMutations(mutations, firstNewNodeId, nodePrivacyLevelCache, transaction) {\n    var _a;\n    const nodeIds = transaction.scope.nodeIds;\n    for (const [node, oldValue] of mutations) {\n        if (node.textContent === oldValue) {\n            continue; // No change since the last snapshot.\n        }\n        if (!node.isConnected) {\n            continue; // This node is not in the DOM.\n        }\n        const nodeId = nodeIds.get(node);\n        if (nodeId === undefined) {\n            continue; // This node was never serialized.\n        }\n        if (nodeId >= firstNewNodeId) {\n            // This node was just serialized, so we've already got an up-to-date copy of its\n            // text content.\n            continue;\n        }\n        const parentNode = getParentNode(node);\n        if (!parentNode) {\n            continue; // This node has no parent.\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(parentNode, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue; // Mutations to this node should be ignored.\n        }\n        const content = (_a = getTextContent(node, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : '';\n        transaction.setText(nodeId, content);\n    }\n}\nfunction processAttributeMutations(mutations, firstNewNodeId, nodePrivacyLevelCache, transaction) {\n    const nodeIds = transaction.scope.nodeIds;\n    for (const [node, attributeNames] of mutations) {\n        if (!node.isConnected) {\n            continue; // This node is not in the DOM.\n        }\n        const nodeId = nodeIds.get(node);\n        if (nodeId === undefined) {\n            continue; // This node was never serialized.\n        }\n        if (nodeId >= firstNewNodeId) {\n            // This node was just serialized, so we've already got an up-to-date copy of its\n            // attributes.\n            continue;\n        }\n        const privacyLevel = getNodePrivacyLevel(node, transaction.scope.configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (privacyLevel === NodePrivacyLevel.HIDDEN || privacyLevel === NodePrivacyLevel.IGNORE) {\n            continue; // Mutations to this node should be ignored.\n        }\n        const change = [nodeId];\n        for (const [attributeName, oldValue] of attributeNames) {\n            if (node.getAttribute(attributeName) === oldValue) {\n                continue; // No change since the last snapshot.\n            }\n            if (attributeName === 'value') {\n                const attributeValue = getElementInputValue(node, privacyLevel);\n                if (attributeValue !== undefined) {\n                    change.push([attributeName, attributeValue]);\n                }\n                continue;\n            }\n            const attributeValue = serializeAttribute(node, privacyLevel, attributeName, transaction.scope.configuration);\n            if (attributeValue === null) {\n                change.push([attributeName]);\n            }\n            else {\n                change.push([attributeName, attributeValue]);\n            }\n        }\n        if (change.length > 1) {\n            transaction.setAttributes(change);\n        }\n    }\n}\nfunction getNextSiblingId(node, nodeIds) {\n    let nextSibling = node.nextSibling;\n    while (nextSibling) {\n        const id = nodeIds.get(nextSibling);\n        if (id !== undefined) {\n            return id;\n        }\n        nextSibling = nextSibling.nextSibling;\n    }\n    return undefined;\n}\nfunction forNodeAndDescendants(node, action) {\n    action(node);\n    forEachChildNodes(node, (childNode) => forNodeAndDescendants(childNode, action));\n}\n//# sourceMappingURL=serializeMutationsAsChange.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 { getViewportDimension } from '@datadog/browser-rum-core';\nimport { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { isFullSnapshotChangeRecordsEnabled, serializeFullSnapshotAsChange, serializeFullSnapshot, } from './serialization';\nimport { getVisualViewport } from './viewports';\nexport function startFullSnapshots(lifeCycle, emitRecord, emitStats, flushMutations, scope, serialize = defaultSerializeFullSnapshotCallback()) {\n    takeFullSnapshot(timeStampNow(), 0 /* SerializationKind.INITIAL_FULL_SNAPSHOT */, emitRecord, emitStats, scope, serialize);\n    const { unsubscribe } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, (view) => {\n        flushMutations();\n        takeFullSnapshot(view.startClocks.timeStamp, 1 /* SerializationKind.SUBSEQUENT_FULL_SNAPSHOT */, emitRecord, emitStats, scope, serialize);\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\nexport function takeFullSnapshot(timestamp, kind, emitRecord, emitStats, scope, serialize = defaultSerializeFullSnapshotCallback()) {\n    const { width, height } = getViewportDimension();\n    emitRecord({\n        data: {\n            height,\n            href: window.location.href,\n            width,\n        },\n        type: RecordType.Meta,\n        timestamp,\n    });\n    emitRecord({\n        data: {\n            has_focus: document.hasFocus(),\n        },\n        type: RecordType.Focus,\n        timestamp,\n    });\n    serialize(timestamp, kind, document, emitRecord, emitStats, scope);\n    if (window.visualViewport) {\n        emitRecord({\n            data: getVisualViewport(window.visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp,\n        });\n    }\n}\nfunction defaultSerializeFullSnapshotCallback() {\n    return isFullSnapshotChangeRecordsEnabled() ? serializeFullSnapshotAsChange : serializeFullSnapshot;\n}\n//# sourceMappingURL=startFullSnapshots.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","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(emitRecord, scope) {\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        emitRecord(assembleIncrementalSnapshot(isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove, { positions: [position] }));\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(scope.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(emitRecord, scope) {\n    const handler = (event) => {\n        const target = getEventTarget(event);\n        const id = scope.nodeIds.get(target);\n        if (id === undefined ||\n            getNodePrivacyLevel(target, scope.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        emitRecord({\n            id: scope.eventIds.getOrInsert(event),\n            ...assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction),\n        });\n    };\n    return addEventListeners(scope.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(target, emitRecord, scope) {\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, scope.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        scope.elementsScrollPositions.set(target, scrollPositions);\n        emitRecord(assembleIncrementalSnapshot(IncrementalSource.Scroll, {\n            id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD);\n    const { stop: removeListener } = addEventListener(scope.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(emitRecord, scope) {\n    const viewportResizeSubscription = initViewportObservable(scope.configuration).subscribe((data) => {\n        emitRecord(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: () => {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function trackVisualViewportResize(emitRecord, scope) {\n    const visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    const { throttled: updateDimension, cancel: cancelThrottle } = throttle(() => {\n        emitRecord({\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(scope.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(emitRecord, scope) {\n    return addEventListeners(scope.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, scope.configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        emitRecord(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(emitRecord, scope) {\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) => emitRecord(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                adds: [{ rule, index }],\n            })));\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => emitRecord(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                    emitRecord(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                    emitRecord(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(emitRecord, scope) {\n    return addEventListeners(scope.configuration, window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], () => {\n        emitRecord({\n            data: { has_focus: document.hasFocus() },\n            type: RecordType.Focus,\n            timestamp: timeStampNow(),\n        });\n    });\n}\n//# sourceMappingURL=trackFocus.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackViewEnd(lifeCycle, emitRecord, flushMutations) {\n    const viewEndSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, () => {\n        flushMutations();\n        emitRecord({\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 { 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(target, emitRecord, scope) {\n    const defaultPrivacyLevel = scope.configuration.defaultPrivacyLevel;\n    const lastInputStateMap = new WeakMap();\n    const isShadowRoot = target !== document;\n    const { stop: stopEventListeners } = addEventListeners(scope.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        createRecordIfStateChanged(target, inputState);\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                    createRecordIfStateChanged(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function createRecordIfStateChanged(target, inputState) {\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            emitRecord(assembleIncrementalSnapshot(IncrementalSource.Input, {\n                id,\n                ...inputState,\n            }));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.js.map","import { monitor, noop, timeStampNow } from '@datadog/browser-core';\nimport { getMutationObserverConstructor } from '@datadog/browser-rum-core';\nimport { createMutationBatch } from '../mutationBatch';\nimport { isIncrementalSnapshotChangeRecordsEnabled, serializeMutations, serializeMutationsAsChange, } from '../serialization';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function trackMutation(target, emitRecord, emitStats, scope, serialize = defaultSerializeMutationsCallback()) {\n    const MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    const mutationBatch = createMutationBatch((mutations) => {\n        serialize(timeStampNow(), mutations.concat(observer.takeRecords()), emitRecord, emitStats, scope);\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 defaultSerializeMutationsCallback() {\n    return isIncrementalSnapshotChangeRecordsEnabled() ? serializeMutationsAsChange : serializeMutations;\n}\n//# sourceMappingURL=trackMutation.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","export function createEventIds() {\n    return createWeakIdMap(1 /* EventIdConstants.FIRST_ID */);\n}\nexport function createNodeIds() {\n    return createWeakIdMap(0 /* NodeIdConstants.FIRST_ID */);\n}\nexport function createStringIds() {\n    return createIdMap(0 /* StringIdConstants.FIRST_ID */);\n}\nexport function createStyleSheetIds() {\n    return createWeakIdMap(0 /* StyleSheetIdConstants.FIRST_ID */);\n}\nfunction createIdMap(firstId) {\n    return createItemIds(() => new Map(), firstId);\n}\nfunction createWeakIdMap(firstId) {\n    return createItemIds(() => new WeakMap(), firstId);\n}\nfunction createItemIds(createMap, firstId) {\n    let map = createMap();\n    let nextId = firstId;\n    const get = (object) => map.get(object);\n    return {\n        clear() {\n            if (nextId === firstId) {\n                return;\n            }\n            map = createMap();\n            nextId = firstId;\n        },\n        delete(object) {\n            map.delete(object);\n        },\n        get,\n        getOrInsert(object) {\n            // Try to reuse any existing id.\n            let id = get(object);\n            if (id === undefined) {\n                id = nextId++;\n                map.set(object, id);\n            }\n            return id;\n        },\n        get nextId() {\n            return nextId;\n        },\n        get size() {\n            return nextId - firstId;\n        },\n    };\n}\n//# sourceMappingURL=itemIds.js.map","import { Observable } from '@datadog/browser-core';\nimport { createEventIds, createNodeIds, createStringIds, createStyleSheetIds } from './itemIds';\nexport function createRecordingScope(configuration, elementsScrollPositions, shadowRootsController) {\n    const eventIds = createEventIds();\n    const nodeIds = createNodeIds();\n    const stringIds = createStringIds();\n    const styleSheetIds = createStyleSheetIds();\n    const scope = {\n        resetIds() {\n            scope.eventIds.clear();\n            scope.nodeIds.clear();\n            scope.stringIds.clear();\n            scope.styleSheetIds.clear();\n        },\n        configuration,\n        elementsScrollPositions,\n        eventIds,\n        nodeIds,\n        serializeObservable: new Observable(),\n        shadowRootsController,\n        stringIds,\n        styleSheetIds,\n    };\n    return scope;\n}\n//# sourceMappingURL=recordingScope.js.map","import { sendToExtension } from '@datadog/browser-core';\nimport * as replayStats from '../replayStats';\nimport { trackFocus, 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 { createRecordingScope } from './recordingScope';\nexport function record(options) {\n    const { emitRecord, emitStats, configuration, lifeCycle } = options;\n    // runtime checks for user options\n    if (!emitRecord || !emitStats) {\n        throw new Error('emit functions are required');\n    }\n    const processRecord = (record) => {\n        emitRecord(record);\n        sendToExtension('record', { record });\n        const view = options.viewHistory.findView();\n        replayStats.addRecord(view.id);\n    };\n    const shadowRootsController = initShadowRootsController(processRecord, emitStats);\n    const scope = createRecordingScope(configuration, createElementsScrollPositions(), shadowRootsController);\n    const { stop: stopFullSnapshots } = startFullSnapshots(lifeCycle, processRecord, emitStats, flushMutations, scope);\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    const mutationTracker = trackMutation(document, processRecord, emitStats, scope);\n    const trackers = [\n        mutationTracker,\n        trackMove(processRecord, scope),\n        trackMouseInteraction(processRecord, scope),\n        trackScroll(document, processRecord, scope),\n        trackViewportResize(processRecord, scope),\n        trackInput(document, processRecord, scope),\n        trackMediaInteraction(processRecord, scope),\n        trackStyleSheet(processRecord, scope),\n        trackFocus(processRecord, scope),\n        trackVisualViewportResize(processRecord, scope),\n        trackViewEnd(lifeCycle, processRecord, flushMutations),\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","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport const initShadowRootsController = (emitRecord, emitStats) => {\n    const controllerByShadowRoot = new Map();\n    const shadowRootsController = {\n        addShadowRoot: (shadowRoot, scope) => {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            const mutationTracker = trackMutation(shadowRoot, emitRecord, emitStats, scope);\n            // The change event does not bubble up across the shadow root, we have to listen on the shadow root\n            const inputTracker = trackInput(shadowRoot, emitRecord, scope);\n            // The scroll event does not bubble up across the shadow root, we have to listen on the shadow root\n            const scrollTracker = trackScroll(shadowRoot, emitRecord, scope);\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","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","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, 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 || (record.type === RecordType.Change && metadata.index_in_view === 0));\n        const prefix = encoder.isEmpty ? '{\"records\":[' : ',';\n        encoder.write(prefix + JSON.stringify(record), (additionalEncodedBytesCount) => {\n            encodedBytesCount += additionalEncodedBytesCount;\n            callback(encodedBytesCount);\n        });\n    }\n    function addStats(stats) {\n        aggregateSerializationStats(serializationStats, stats);\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, addStats, 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) => {\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, (encodedBytesCount) => {\n                if (encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        addStats: (stats) => {\n            if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n                state.segment.addStats(stats);\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 { addTelemetryMetrics, noop } from '@datadog/browser-core';\nimport { isFullSnapshotChangeRecordsEnabled, isIncrementalSnapshotChangeRecordsEnabled } from '../record';\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        encoding: {\n            fullSnapshot: isFullSnapshotChangeRecordsEnabled() ? 'change' : 'v1',\n            incrementalSnapshot: isIncrementalSnapshotChangeRecordsEnabled() ? 'change' : 'v1',\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","import { createHttpRequest, addTelemetryDebug, canUseEventBridge, noop } 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], reportError, SEGMENT_BYTES_LIMIT);\n    let addRecord;\n    let addStats;\n    if (!canUseEventBridge()) {\n        const segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);\n        addRecord = segmentCollection.addRecord;\n        addStats = segmentCollection.addStats;\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        addStats = noop;\n    }\n    const { stop: stopRecording } = record({\n        emitRecord: addRecord,\n        emitStats: addStats,\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","// 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    var _a, _b;\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    const longTaskIds = profilerTrace.longTasks.map((longTask) => longTask.id).filter((id) => id !== undefined);\n    const actionIds = (_b = (_a = profilerTrace.actions) === null || _a === void 0 ? void 0 : _a.map((longTask) => longTask.id).filter((id) => id !== undefined)) !== null && _b !== void 0 ? _b : [];\n    const { ids: vitalIds, labels: vitalLabels } = extractVitalIdsAndLabels(profilerTrace.vitals);\n    const attributes = { application: { id: applicationId } };\n    if (sessionId) {\n        attributes.session = { id: sessionId };\n    }\n    if (ids.length) {\n        attributes.view = { id: ids, name: names };\n    }\n    if (longTaskIds.length) {\n        attributes.long_task = { id: longTaskIds };\n    }\n    if (actionIds.length) {\n        attributes.action = { id: actionIds, label: [] };\n    }\n    if (vitalIds.length) {\n        attributes.vital = { id: vitalIds, label: vitalLabels };\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}\nfunction extractVitalIdsAndLabels(vitals) {\n    const result = { ids: [], labels: [] };\n    if (!vitals) {\n        return result;\n    }\n    for (const vital of vitals) {\n        result.ids.push(vital.id);\n        result.labels.push(vital.label);\n    }\n    // Remove duplicates\n    result.labels = Array.from(new Set(result.labels));\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 { addDuration, createValueHistory, SESSION_TIME_OUT_DELAY } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, RumLongTaskEntryType } from '@datadog/browser-rum-core';\nexport const LONG_TASK_ID_HISTORY_EXPIRE_DELAY = SESSION_TIME_OUT_DELAY;\nexport function createLongTaskHistory(lifeCycle) {\n    const history = createValueHistory({\n        expireDelay: LONG_TASK_ID_HISTORY_EXPIRE_DELAY,\n    });\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ rawRumEvent, startClocks, duration }) => {\n        if (rawRumEvent.type === 'long_task') {\n            history\n                .add({\n                id: rawRumEvent.long_task.id,\n                startClocks,\n                duration: duration,\n                entryType: rawRumEvent.long_task.entry_type === RumLongTaskEntryType.LONG_TASK\n                    ? RumPerformanceEntryType.LONG_TASK\n                    : RumPerformanceEntryType.LONG_ANIMATION_FRAME,\n            }, startClocks.relative)\n                .close(addDuration(startClocks.relative, duration));\n        }\n    });\n    return history;\n}\n//# sourceMappingURL=longTaskHistory.js.map","import { addDuration, createValueHistory, SESSION_TIME_OUT_DELAY } from '@datadog/browser-core';\nexport const ACTION_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function createActionHistory(lifeCycle) {\n    const history = createValueHistory({\n        expireDelay: ACTION_ID_HISTORY_TIME_OUT_DELAY,\n    });\n    lifeCycle.subscribe(15 /* LifeCycleEventType.ACTION_STARTED */, (actionStart) => {\n        history.add({\n            id: actionStart.id,\n            // The label is temporarily empty since we need to account for customers that might\n            // redact the action name in the beforeSend callback. We will either try to do patch this\n            // behavior, or remove the label field entirely.\n            label: '',\n            startClocks: actionStart.startClocks,\n            duration: undefined,\n        }, actionStart.startClocks.relative);\n    });\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ rawRumEvent, startClocks, duration }) => {\n        if (rawRumEvent.type === 'action') {\n            const historyEntry = history\n                .getEntries(startClocks.relative)\n                .find((entry) => entry.value.id === rawRumEvent.action.id);\n            const durationForEntry = duration !== null && duration !== void 0 ? duration : 0;\n            if (historyEntry) {\n                historyEntry.value.duration = durationForEntry;\n                historyEntry.close(addDuration(startClocks.relative, durationForEntry));\n            }\n            else {\n                history\n                    .add({\n                    id: rawRumEvent.action.id,\n                    // The label is temporarily empty since we need to account for customers that might\n                    // redact the action name in the beforeSend callback. We will either try to do patch this\n                    // behavior, or remove the label field entirely.\n                    label: '',\n                    startClocks,\n                    duration,\n                }, startClocks.relative)\n                    .close(addDuration(startClocks.relative, durationForEntry));\n            }\n        }\n    });\n    return history;\n}\n//# sourceMappingURL=actionHistory.js.map","import { addDuration, createValueHistory, SESSION_TIME_OUT_DELAY } from '@datadog/browser-core';\nexport const VITAL_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function createVitalHistory(lifeCycle) {\n    const history = createValueHistory({\n        expireDelay: VITAL_ID_HISTORY_TIME_OUT_DELAY,\n    });\n    lifeCycle.subscribe(16 /* LifeCycleEventType.VITAL_STARTED */, (vitalStart) => {\n        history.add({\n            id: vitalStart.id,\n            startClocks: vitalStart.startClocks,\n            duration: undefined,\n            label: vitalStart.name,\n        }, vitalStart.startClocks.relative);\n    });\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ rawRumEvent, startClocks, duration }) => {\n        if (rawRumEvent.type === 'vital') {\n            const historyEntry = history\n                .getEntries(startClocks.relative)\n                .find((entry) => entry.value.id === rawRumEvent.vital.id);\n            if (historyEntry) {\n                historyEntry.value.duration = duration;\n                historyEntry.close(addDuration(startClocks.relative, duration));\n            }\n            else {\n                history\n                    .add({\n                    id: rawRumEvent.vital.id,\n                    startClocks,\n                    duration,\n                    label: rawRumEvent.vital.name,\n                }, startClocks.relative)\n                    .close(addDuration(startClocks.relative, duration));\n            }\n        }\n    });\n    return history;\n}\n//# sourceMappingURL=vitalHistory.js.map","import { addEventListener, clearTimeout, setTimeout, monitorError, display, getGlobalObject, clocksOrigin, clocksNow, elapsed, mockable, } from '@datadog/browser-core';\nimport { createFormDataTransport } from '@datadog/browser-rum-core';\nimport { getNumberOfSamples } from './utils/getNumberOfSamples';\nimport { getCustomOrDefaultViewName } from './utils/getCustomOrDefaultViewName';\nimport { assembleProfilingPayload } from './transport/assembly';\nimport { createLongTaskHistory } from './longTaskHistory';\nimport { createActionHistory } from './actionHistory';\nimport { createVitalHistory } from './vitalHistory';\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, viewHistory, profilerConfiguration = DEFAULT_RUM_PROFILER_CONFIGURATION) {\n    const transport = createFormDataTransport(configuration, lifeCycle, createEncoder, 6 /* DeflateEncoderStreamId.PROFILING */);\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    const longTaskHistory = mockable(createLongTaskHistory)(lifeCycle);\n    const actionHistory = mockable(createActionHistory)(lifeCycle);\n    const vitalHistory = mockable(createVitalHistory)(lifeCycle);\n    let instance = { state: 'stopped', stateReason: 'initializing' };\n    // Stops the profiler when session expires\n    lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_EXPIRED */, () => {\n        stopProfiling('session-expired');\n    });\n    // Start the profiler again when session is renewed\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        if (instance.state === 'stopped' && instance.stateReason === 'session-expired') {\n            start();\n        }\n    });\n    // Public API to start the profiler.\n    function start() {\n        if (instance.state === 'running') {\n            return;\n        }\n        const viewEntry = viewHistory.findView();\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    // Public API to manually stop the profiler.\n    function stop() {\n        stopProfiling('stopped-by-user');\n    }\n    function stopProfiling(reason) {\n        // Stop current profiler instance (data collection happens async in background)\n        stopProfilerInstance(reason);\n        // Cleanup global listeners and reset the array to prevent accumulation across start/stop cycles\n        globalCleanupTasks.forEach((task) => task());\n        globalCleanupTasks.length = 0;\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            };\n        }\n        // Store clean-up tasks for this instance (tasks to be executed when the Profiler is stopped or paused.)\n        const cleanupTasks = [];\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        };\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        // Collect data from previous running instance (fire-and-forget)\n        if (instance.state === 'running') {\n            collectProfilerInstance(instance);\n        }\n        const { cleanupTasks } = 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            views: [],\n            cleanupTasks,\n            longTasks: [],\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    function collectProfilerInstance(runningInstance) {\n        // Cleanup instance\n        clearTimeout(runningInstance.timeoutId);\n        runningInstance.profiler.removeEventListener('samplebufferfull', handleSampleBufferFull);\n        // Store instance data snapshot in local variables to use in async callback\n        const { startClocks, views } = runningInstance;\n        // Stop current profiler to get trace\n        runningInstance.profiler\n            .stop()\n            .then((trace) => {\n            const endClocks = clocksNow();\n            const duration = elapsed(startClocks.relative, endClocks.relative);\n            const longTasks = longTaskHistory.findAll(startClocks.relative, duration);\n            const actions = actionHistory.findAll(startClocks.relative, duration);\n            const vitals = vitalHistory.findAll(startClocks.relative, duration);\n            const isBelowDurationThreshold = duration < profilerConfiguration.minProfileDurationMs;\n            const isBelowSampleThreshold = getNumberOfSamples(trace.samples) < profilerConfiguration.minNumberOfSamples;\n            if (longTasks.length === 0 && (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                actions,\n                vitals,\n                views,\n                sampleInterval: profilerConfiguration.sampleIntervalMs,\n            }));\n        })\n            .catch(monitorError);\n    }\n    function stopProfilerInstance(stateReason) {\n        if (instance.state !== 'running') {\n            if (\n            // If paused, profiler data was already collected during pause, just update state\n            instance.state === 'paused' ||\n                // Update stateReason when already stopped and the user explicitly stops the profiler,\n                // so that SESSION_RENEWED does not override the user's intent.\n                (instance.state === 'stopped' && stateReason === 'stopped-by-user')) {\n                instance = { state: 'stopped', stateReason };\n            }\n            return;\n        }\n        // Capture the running instance before changing state\n        const runningInstance = instance;\n        // Update state synchronously so SESSION_RENEWED check works immediately\n        instance = { state: 'stopped', stateReason };\n        // Cleanup instance-specific tasks (e.g., view listener)\n        runningInstance.cleanupTasks.forEach((cleanupTask) => cleanupTask());\n        // Collect and send profile data in background - doesn't block state transitions\n        collectProfilerInstance(runningInstance);\n    }\n    function pauseProfilerInstance() {\n        if (instance.state !== 'running') {\n            return;\n        }\n        // Capture the running instance before changing state\n        const runningInstance = instance;\n        // Update state synchronously\n        instance = { state: 'paused' };\n        // Cleanup instance-specific tasks\n        runningInstance.cleanupTasks.forEach((cleanupTask) => cleanupTask());\n        // Collect and send profile data in background\n        collectProfilerInstance(runningInstance);\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 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            pauseProfilerInstance();\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 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","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","\"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","/*!\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","// 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, mockable } from '@datadog/browser-core';\nimport { reportScriptLoadingError } from '../scriptLoadingError';\nexport const INITIALIZATION_TIME_OUT_DELAY = 30 * ONE_SECOND;\nexport function createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"(()=>{function t(t){if(1===t.length)return t[0];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.33.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) {\n    if (state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n        doStartDeflateWorker(configuration, source);\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) {\n    try {\n        const worker = mockable(createDeflateWorker)(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 { mockable } from '@datadog/browser-core';\nimport { reportScriptLoadingError } from '../domain/scriptLoadingError';\nexport async function lazyLoadRecorder() {\n    try {\n        return await mockable(importRecorder)();\n    }\n    catch (error) {\n        reportScriptLoadingError({\n            error,\n            source: 'Recorder',\n            scriptType: 'module',\n        });\n    }\n}\nexport async function importRecorder() {\n    const module = await import(/* webpackChunkName: \"recorder\" */ './startRecording');\n    return module.startRecording;\n}\n//# sourceMappingURL=lazyLoadRecorder.js.map","import { asyncRunOnReadyState, monitorError, Observable } from '@datadog/browser-core';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { startRecorderInitTelemetry } from '../domain/startRecorderInitTelemetry';\nimport { lazyLoadRecorder } from './lazyLoadRecorder';\nexport function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, 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' }, lazyLoadRecorder()),\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 { mockable } from '@datadog/browser-core';\nimport { reportScriptLoadingError } from '../domain/scriptLoadingError';\nexport async function lazyLoadProfiler() {\n    try {\n        return await mockable(importProfiler)();\n    }\n    catch (error) {\n        reportScriptLoadingError({\n            error,\n            source: 'Profiler',\n            scriptType: 'module',\n        });\n    }\n}\nexport async 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 } from '@datadog/browser-rum-core';\nimport { makeRecorderApi } from '../boot/recorderApi';\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate';\nimport { makeProfilerApi } from '../boot/profilerApi';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport { DEFAULT_TRACKED_RESOURCE_HEADERS } from '@datadog/browser-rum-core';\nconst recorderApi = makeRecorderApi();\nconst profilerApi = makeProfilerApi();\n/**\n * The global RUM instance. Use this to call RUM methods.\n *\n * @category Main\n * @see {@link DatadogRum}\n * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)\n */\nexport const datadogRum = makeRumPublicApi(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() {\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', () => strategy.stop()));\n                if (worker) {\n                    cachedDeflateEncoder = createDeflateEncoder(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */);\n                }\n            }\n            return cachedDeflateEncoder;\n        }\n        strategy = createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, 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 { 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                profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' });\n                return;\n            }\n            profiler = createRumProfiler(configuration, lifeCycle, sessionManager, profilingContextManager, createEncoder, viewHistory, undefined);\n            profiler.start();\n        })\n            .catch(monitorError);\n    }\n    return {\n        onRumStart,\n        stop: () => {\n            profiler === null || profiler === void 0 ? void 0 : profiler.stop();\n        },\n    };\n}\n//# sourceMappingURL=profilerApi.js.map","import { SKIPPED } from '@datadog/browser-core';\nimport { RumEventType } from '@datadog/browser-rum-core';\nexport function startProfilingContext(hooks) {\n    let currentContext = {\n        status: 'starting',\n    };\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        if (eventType !== RumEventType.VIEW &&\n            eventType !== RumEventType.LONG_TASK &&\n            eventType !== RumEventType.ACTION &&\n            eventType !== RumEventType.VITAL) {\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":["makePublicApi","stub","publicApi","version","onReady","callback","Object","defineProperty","get","enumerable","defineGlobal","global","name","api","existingGlobalVariable","q","warn","forEach","fn","addEventListener","configuration","eventTarget","eventName","listener","options","addEventListeners","eventNames","once","capture","passive","listenerWithMonitor","event","isTrusted","__ddIsTrusted","allowUntrustedEvents","stop","listenerTarget","window","EventTarget","prototype","add","remove","call","fetch","input","init","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","createPageMayExitObservable","observable","stopListeners","type","document","visibilityState","notify","reason","stopBeforeUnloadListener","isPageExitReason","includes","runOnReadyState","expectedReadyState","readyState","asyncRunOnReadyState","Promise","resolve","getConnectivity","_a","navigator","status","onLine","interfaces","connection","undefined","effective_type","effectiveType","NO_ERROR_STACK_PRESENT_MESSAGE","computeErrorBase","originalError","stackTrace","source","useFallbackStack","nonErrorPrefix","isErrorInstance","isError","message","computeMessage","stack","computeRawError","handlingStack","componentStack","startClocks","handling","causes","flattenErrorCauses","fingerprint","tryToGetFingerprint","context","tryToGetErrorContext","String","dd_fingerprint","dd_context","error","Error","toString","parentSource","currentCause","cause","length","causeBase","push","ErrorSource","AGENT","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_US1_FED","INTAKE_SITE_US2_FED","PCI_INTAKE_HOST_US1","INTAKE_URL_PARAMETERS","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_COOKIE_EXPIRATION_DELAY","SESSION_NOT_TRACKED","SessionPersistence","COOKIE","MEMORY","LOCAL_STORAGE","buildTags","env","service","datacenter","sdkVersion","variant","tags","buildTag","key","rawValue","tag","RegExp","supportUnicodePropertyEscapes","test","hasForbiddenCharacters","replace","sanitizeTag","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryObservable","getTelemetryObservable","startTelemetry","telemetryService","hooks","enabled","metricsEnabled","metricSampleRate","maxTelemetryEventsPerPage","alreadySentEventsByKind","telemetryEnabled","site","telemetrySampleRate","telemetryEnabledPerType","telemetryConfigurationSampleRate","telemetryUsageSampleRate","metric","runtimeEnvInfo","is_local_file","globalObject","location","protocol","is_worker","subscribe","rawEvent","metricName","kind","alreadySentEvents","Set","size","stringifiedEvent","jsonStringify","has","defaultTelemetryEventAttributes","triggerHook","startTime","relative","toTelemetryEvent","sendToExtension","unbuffer","addTelemetryError","date","timeStamp","_dd","format_version","telemetry","runtime_env","connectivity","sdk_setup","ddtags","join","experimental_features","Array","from","startTelemetryCollection","cleanupTasks","bridge","telemetrySubscription","send","unsubscribe","endpoints","rumEndpointBuilder","replica","isTelemetryReplicationAllowed","telemetryBatch","encoder","request","flushController","pageMayExitObservable","sessionExpireObservable","task","startTelemetryTransport","addTelemetryDebug","debug","e","formatError","addTelemetryConfiguration","addTelemetryMetrics","addTelemetryUsage","usage","computeStackTrace","scrubCustomerFrames","filter","frame","url","some","allowedFrameUrl","startsWith","TrackingConsent","GRANTED","NOT_GRANTED","createTrackingConsentState","currentConsent","tryToInit","trackingConsent","update","isGranted","DISCARDED","SKIPPED","abstractHooks","callbacks","register","hookName","unregister","cb","param","hookCallbacks","results","result","catchUserErrors","errorMsg","args","err","ConsoleApiName","log","info","globalConsole","console","originalConsoleMethods","keys","PREFIX","display","bind","DOCS_ORIGIN","DOCS_TROUBLESHOOTING","MORE_DETAILS","createIdentityEncoder","output","outputBytesCount","isAsync","isEmpty","write","data","additionalEncodedBytesCount","finish","this","finishSync","rawBytesCount","pendingData","estimateEncodedBytesCount","ExperimentalFeature","enabledExperimentalFeatures","initFeatureFlags","enableExperimentalFeatures","isArray","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","getZoneJsOriginalValue","target","browserWindow","original","Zone","__symbol__","getGlobalObject","globalThis","configurable","_dd_temp_","self","isWorkerEnvironment","instrumentMethod","targetPrototype","method","onPreCall","computeHandlingStack","stopped","instrumentation","apply","arguments","parameters","postCallCallback","onPostCall","instrumentSetter","property","after","originalDescriptor","getOwnPropertyDescriptor","set","stoppedInstrumentation","value","instrumentationWrapper","mergeInto","destination","circularReferenceChecker","WeakSet","hasAlreadyBeenSeen","array","indexOf","createCircularReferenceChecker","Date","getTime","flags","ignoreCase","multiline","sticky","unicode","merged","i","hasOwnProperty","deepClone","combine","sources","Map","mockable","onMonitorErrorCollected","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","monitor","callMonitored","monitorError","displayIfDebugEnabled","queueMicrotask","nativeImplementation","then","Observable","constructor","onFirstSubscribe","observers","observer","addObserver","removeObserver","onLastUnsubscribe","other","mergeObservables","observables","globalObservable","subscriptions","map","subscription","BufferedObservable","maxBufferSize","super","buffer","shift","closed","requestIdleCallback","opts","cancelIdleCallback","id","start","timeoutId","didTimeout","timeRemaining","Math","max","requestIdleCallbackShim","payload","__ddBrowserSdkExtensionCallback","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","object","objectToJson","toJSON","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","serializedSanitizedData","accumulatedCharacterCount","containerToProcess","separatorLength","targetData","path","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","description","sanitizePrimitivesAndFunctions","sanitizedSource","sanitizeObjects","sourceAsObject","currentPath","Event","currentTarget","match","changeType","UNKNOWN_FUNCTION","ex","_b","stackProperty","tryToGetString","exString","slice","split","line","stackFrame","parts","CHROME_LINE_RE","exec","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","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","candidate","computeStackTraceFromOnErrorMessage","messageObj","ERROR_TYPES_RE","tryToParseMessage","createHandlingStack","formattedStack","toStackTraceString","formatErrorMessage","setTimeout","delay","clearTimeout","setInterval","clearInterval","removeItem","item","index","splice","isNonEmptyArray","isChromium","detectBrowserCached","isSafari","browserCache","userAgent","chrome","vendor","detectBrowser","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","TextEncoder","encode","Blob","concatBuffers","buffers","reduce","total","Uint8Array","offset","throttle","wait","needLeadingExecution","leading","needTrailingExecution","trailing","pendingExecutionWithParameters","pendingTimeoutId","inWaitPeriod","throttled","cancel","noop","performDraw","threshold","random","round","num","decimals","toFixed","isPercentage","isNumber","tryJsonParse","text","parse","shallowClone","objectHasValue","isEmptyObject","mapValues","newObject","findLast","predicate","objectValues","values","objectEntries","entries","isServerError","tryToClone","response","clone","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","getCorrectedTimeStamp","timeStampToClocks","getRelativeTime","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","addDuration","getTimeStamp","currentDrift","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","end","a","b","timestamp","looksLikeRelativeTime","time","navigationStart","timing","timeOrigin","getType","isIndexableObject","normalizeUrl","buildUrl","href","isValidUrl","getPathName","pathname","base","URL","getPristineGlobalObjectCache","iframe","pristineWindow","createElement","style","body","appendChild","contentWindow","getPristineWindow","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","cleanupHistoriesInterval","createValueHistory","expireDelay","maxEntries","clearExpiredValues","oldTimeThreshold","endTime","pop","entry","close","unshift","find","returnInactive","closeActive","latestEntry","findAll","getEntries","reset","delete","MESSAGE_BYTES_LIMIT","createBatch","upsertBuffer","flushSubscription","flushObservable","upsertMessages","pageMightExit","sendOnExit","encoderResult","formatPayloadFromEncoder","pendingMessages","Boolean","bytesCount","flush","addOrUpdate","serializedMessage","estimatedMessageBytesCount","hasMessageFor","removedMessage","messageBytesCount","notifyAfterRemoveMessage","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","upsert","encoding","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","getPrivacyLevel","getAllowedWebViewHosts","eventType","viewId","view","bridgeSupports","capability","canUseEventBridge","currentHost","hostname","allowedHost","endsWith","FLUSH_DURATION_LIMIT","MESSAGES_LIMIT","createFlushController","forcedFlushReason","preparePageExitFlushObservable","pageMayExitSubscription","sessionExpireSubscription","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","flushReason","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","MAX_ONGOING_BYTES_COUNT","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","state","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","previousQueue","newPayloadQueue","RECOMMENDED_REQUEST_BYTES_LIMIT","createHttpRequest","endpointBuilders","bytesLimit","retryState","ongoingByteCount","endpointBuilder","onResponse","fetchStrategy","sendBeaconStrategy","sendBeacon","beaconUrl","build","hasReportedBeaconError","reportBeaconError","fetchUrl","mode","catch","trackRuntimeError","handleRuntimeError","rawError","stopInstrumentingOnError","errorObj","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","defineContextMethod","getStrategy","contextName","methodName","feature","CustomerContextKey","ContextManagerMethod","generateUUID","placeholder","parseInt","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","RumEventType","ACTION","ERROR","LONG_TASK","VIEW","RESOURCE","VITAL","RumLongTaskEntryType","LONG_ANIMATION_FRAME","ViewLoadingType","ActionType","FrustrationType","VitalType","startVitalCollection","lifeCycle","pageStateHistory","customVitalsState","addDurationVital","vital","wasInPageStateDuringPeriod","isValid","processVital","addOperationStepVital","stepType","failureReason","FEATURE_OPERATION_VITAL","operationKey","startDurationVital","ref","vitalState","vitalsByReference","stopDurationVital","nameOrRef","vitalsByName","reference","__dd_vital_reference","stopCallback","vitalStart","stopOptions","stopClocks","buildDurationVital","vitalId","vitalData","step_type","operation_key","failure_reason","rawRumEvent","domainContext","callPluginsMethod","plugins","parameter","plugin","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","contextManager","productKey","customerDataType","storageKey","buildStorageKey","setContext","getFromStorage","changeObservable","localStorage","setItem","getContext","contextFromStorage","rawContext","getItem","ensureProperties","propertiesConfig","newContext","required","isDefined","createContextManager","maybeContext","checkContext","clearContext","setContextProperty","removeContextProperty","buildGlobalContextManager","buildUserContextManager","email","buildAccountContextManager","fetchObservable","responseBodyActionGetters","initFetchObservable","responseBodyAction","methodFromParams","Request","toUpperCase","isAbortedOnStart","signal","aborted","responsePromise","async","startContext","isAborted","DOMException","code","ABORT_ERR","responseType","responseBodyCondition","action","getter","clonedResponse","bytes","stream","reader","getReader","chunks","read","done","collectStreamBody","readBytesFromStream","responseBody","TextDecoder","decode","_c","afterSend","beforeSend","setCookie","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","partitioned","cookie","getCookie","getCookies","findAllCommaSeparatedValues","initCookieParsed","getCurrentSiteCache","getInitCookie","findCommaSeparatedValues","deleteCookie","getCurrentSite","referrer","defaultHostName","getCookieDefaultHostName","testCookieName","testCookieValue","domainLevels","candidateDomain","cookieNamePrefix","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","SYNTHETICS_CONTEXT_COOKIE_NAME","willSyntheticsInjectRum","_DATADOG_SYNTHETICS_INJECTS_RUM","getSyntheticsContext","raw","rawGlobal","_DATADOG_SYNTHETICS_RUM_CONTEXT","rawCookie","decodeURIComponent","test_id","_DATADOG_SYNTHETICS_PUBLIC_ID","result_id","_DATADOG_SYNTHETICS_RESULT_ID","getRawSyntheticsContext","isSyntheticsTest","createHooks","SESSION_STORE_KEY","SESSION_ENTRY_REGEXP","getExpiredSessionState","previousSessionState","expiredSessionState","isExpired","trackAnonymousUser","anonymousId","isSessionInNotStartedState","session","isSessionStarted","isSessionInExpiredState","sessionState","created","Number","expire","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","matches","selectCookieStrategy","cookieOptions","useSecureSessionCookie","usePartitionedCrossSiteSessionCookie","trackSessionAcrossSubdomains","currentSite","buildCookieOptions","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","isLockEnabled","persistSession","storeSessionCookie","retrieveSession","retrieveSessionCookie","expireSession","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","defaultTimeout","sessionStateString","betaEncodeCookieOptions","c","encodeCookieOptions","cookies","reverse","retrieveSessionCookieFromEncodedCookie","byte","SESSION_COOKIE_VERSION","initLocalStorageStrategy","persistInLocalStorage","retrieveSessionFromLocalStorage","expireSessionFromLocalStorage","LOCK_EXPIRATION_DELAY","LOCK_SEPARATOR","bufferedOperations","ongoingOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","persistWithLock","lock","currentLock","retrieveStore","isLockExpired","next","currentStore","retryLater","processedSession","process","sessionStore","currentNumberOfRetries","nextOperations","MEMORY_SESSION_STORE_KEY","initMemorySessionStoreStrategy","persistInMemory","expireSessionFromMemory","retrieveFromMemory","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionPersistence","persistenceList","allowFallbackToLocalStorage","normalizePersistenceList","persistence","strategyType","selectStrategyForPersistence","testKey","retrievedId","selectLocalStorageStrategy","startSessionStore","sessionStoreStrategyType","computeTrackingType","getSessionStoreStrategy","renewObservable","expireObservable","sessionStateUpdateObservable","watchSessionTimeoutId","synchronizeSession","sessionCache","startSession","throttledExpandOrRenewSession","cancelExpandOrRenewSession","synchronizedSession","trackingType","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","isSessionInCacheOutdated","previousState","newState","expandOrRenewSession","expandSession","getSession","restartSession","hasConsent","updateSessionState","partialSessionState","isMatchOption","itemType","matchList","list","useStartsWith","EXTENSION_PREFIXES","containsExtensionUrl","str","prefix","isAllowedTrackingOrigins","errorStack","windowOrigin","origin","allowedTrackingOrigins","windowLocation","trimmedLine","trim","isUnsupportedExtensionEnvironment","isAllowed","createEndpointBuilder","extraParameters","buildUrlWithParameters","proxy","normalizedProxyUrl","encodeURIComponent","host","buildEndpointHost","createEndpointUrlWithParametersBuilder","clientToken","internalAnalyticsSubdomain","concat","buildEndpointParameters","usePciIntake","domainParts","extension","computeTransportConfiguration","validateSource","logsEndpointBuilder","profilingEndpointBuilder","sessionReplayEndpointBuilder","exposuresEndpointBuilder","flagEvaluationEndpointBuilder","computeEndpointBuilders","replicaConfiguration","applicationId","computeReplicaConfiguration","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","MASK_UNLESS_ALLOWLISTED","TraceContextInjection","ALL","SAMPLED","isString","tagName","isSampleRate","sampleRate","validateAndBuildConfiguration","_d","_e","_f","_g","_h","_j","_k","sessionSampleRate","storeContextsAcrossPages","DEFAULT_PROPAGATOR_TYPES","DEFAULT_TRACKED_RESOURCE_HEADERS","validateAndBuildRumConfiguration","trackFeatureFlagsForEvents","sessionReplaySampleRate","traceSampleRate","excludedActivityUrls","allowedTracingUrls","tracingOptions","option","normalizedOption","normalizeTracingOption","validateAndBuildTracingOptions","baseConfiguration","allowedGraphQlUrls","graphQlOptions","trackPayload","trackResponseErrors","validateAndBuildGraphQlOptions","actionNameAttribute","betaTrackActionsInShadowDom","startSessionReplayRecordingManually","rulePsr","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackResourceHeaders","validateAndBuildTrackResourceHeaders","trackLongTasks","trackBfcacheViews","trackEarlyRequests","subdomain","defaultPrivacyLevel","enablePrivacyForActionName","traceContextInjection","profilingSampleRate","propagateTraceBaggage","getSelectedTracingPropagators","usedTracingPropagators","propagatorTypes","propagatorType","VALID_HEADER_LOCATIONS","extractor","toLowerCase","hasGraphQlResponseErrorsTracking","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","beta_encode_cookie_options","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","use_track_graph_ql_response_errors","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","track_resource_headers","extractRegexMatch","regexResult","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","f","n","r","t","resolveEscapeSequence","fromCharCode","SUPPORTED_FIELDS","fetchAndApplyRemoteConfiguration","supportedContextManagers","rumInitConfiguration","metrics","increment","initMetrics","fetchResult","buildEndpoint","ok","remoteConfiguration","json","rum","fetchRemoteConfiguration","rumRemoteConfiguration","appliedConfiguration","resolveConfigurationProperty","resolveContextProperty","rcSerializedType","resolveRegex","resolveDynamicOption","contextItems","strategy","resolvedValue","resolveCookieValue","resolveDomValue","resolveJsValue","resolveLocalStorageValue","resolvedExtractor","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","globalContext","userContext","accountContext","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","trackingConsentStateSubscription","tryStartRum","emptyContext","initialViewOptions","startRumResult","doInit","eventBridgeAvailable","overrideInitConfigurationForBridge","user","getInternalContext","stopSession","addTiming","setLoadingTime","callTimestamp","startView","setViewName","setViewContext","setViewContextProperty","getViewContext","addAction","startAction","stopAction","startResource","stopResource","addError","providedError","addFeatureFlagEvaluation","preStartContextManager","TAB_ID_STORAGE_KEY","cachedTabId","startTabContext","tabId","existingId","sessionStorage","newId","getOrCreateIdInSessionStorage","retrieveOrCreateTabId","tab","getMutationObserverConstructor","MutationObserver","patchedInstance","originalInstance","LifeCycle","eventCallbacks","VIEW_CONTEXT_TIME_OUT_DELAY","xhrObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","xhr","requestBody","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","ResourceType","RequestType","FETCH","XHR","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","sanitizeIfLongDataUrl","lengthLimit","dataUrlMatchArray","substring","sampleDecisionCache","isSampled","sessionId","cachedDecision","decision","BigInt","identifier","knuthFactor","twoPow64","sampleUsingKnuthFactor","createSpanIdentifier","createIdentifier","bits","crypto","getRandomValues","Uint32Array","radix","high","low","mod","floor","toPaddedHexadecimalString","padStart","clearTracingIfNeeded","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","findTrackedSession","tracingOption","tracingHeaders","assign","traceparent","tracestate","b3","baggageItems","userId","accountId","baggageHeader","makeTracingHeaders","GRAPHQL_PAYLOAD_LIMIT","extractGraphQlMetadata","graphQlConfig","metadata","rawMetadata","graphqlBody","query","operationName","variables","extractFromBody","searchParams","variablesParam","extractFromUrlQueryParams","operationType","trimmedQuery","sanitizeGraphQlMetadata","extractGraphQlRequestMetadata","responseErrors","responseText","responseObj","errors","locations","extensions","parseGraphQlResponse","error_count","findGraphQlConfiguration","graphQlOption","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","Headers","header","traceXhr","setRequestHeader","startTracer","requestIndex","getNextRequestIndex","trackXhr","trackFetch","discardNegativeDuration","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","hasChildNodes","childNodes","forEachChildNodes","child","firstChild","nextSibling","getParentNode","parentNode","getParentElement","parentElement","retrieveFirstInputTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","entryType","processingStart","processingEnd","interactionId","sendTiming","sendTimingIfPointerIsNotCancelled","RumPerformanceEntryType","createPerformanceObservable","PerformanceObserver","handlePerformanceEntries","rumPerformanceEntries","isForbiddenResource","filterRumPerformanceEntries","isObserverInitializing","observe","NAVIGATION","PAINT","buffered","getEntriesByType","entryTypes","stopFirstInputTiming","resourceTimingBufferFullListener","clearResourceTimings","manageResourceTimingBufferFull","supportPerformanceTimingEvent","FIRST_INPUT","disconnect","supportedEntryTypes","EXCLUDED_MUTATIONS_ATTRIBUTE","waitPageActivityEnd","domMutationObservable","windowOpenObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","isBusy","lastChangeTime","firstRequestIndex","pendingRequestsCount","mutations","isExcludedMutation","notifyPageActivity","isExcludedUrl","startEvent","s","requestUrl","mutation","targetElement","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","ACTION_NAME_PLACEHOLDER","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","getIDSelector","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","className","isGeneratedValue","CSS","escape","getTagNameSelector","getSelectorFromElement","isConnected","subtrees","rootNode","getRootNode","getAllSubtreeTargets","selectorParts","getSelectorFromElementWithinSubtree","currentElement","nodeName","globallyUniqueSelector","findSelector","isSelectorUniqueWithinRoot","combineSelector","isSelectorUniqueAmongSiblings","getPositionSelector","getAttributeSelector","attributeName","hasAttribute","getAttributeValueSelector","attributeValue","nthOfType","getNthOfTypeSelector","sibling","firstElementChild","nextElementSibling","selectorGetters","childSelector","selectorGetter","elementSelector","_element","querySelectorAll","_rootNode","currentElementSelector","isSiblingMatching","scopedSelector","previousElementSibling","parent","NodePrivacyLevel","IGNORE","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","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","shouldIgnoreElement","shouldMaskNode","isFormElement","isAllowlisted","shouldMaskAttribute","censorText","getTextContent","textNode","parentTagName","$DD_ALLOW","toLocaleLowerCase","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","EVENT_CONTEXT_TIME_OUT_DELAY","startEventTracker","history","keyedEvents","cleanUpEvent","discardAll","sessionRenewalSubscription","historyEntry","existing","trackedEventData","extraData","finalData","counts","discard","getCounts","findId","stopAll","FILTERED_TAGNAMES","CHARACTER_LIMIT","SAFE_ATTRIBUTES","getSelectorStringFromElement","allowedAttributes","classes","sort","getElementClassesString","attributes","extractSafeAttributesString","positionData","siblings","children","sameTypeSiblings","nthChild","computePositionDataString","MAX_DURATION_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","bufferedClicks","maxDurationBetweenClicksTimeoutId","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","isStopped","tryAppend","second","sqrt","pow","clientX","clientY","getActionNameFromElementProgrammatically","programmaticAttribute","elementWithAttribute","closestShadowAware","truncate","normalizeWhitespace","priorityStrategies","rumConfiguration","nodePrivacyLevelCache","labels","getActionNameFromTextualContent","nameSource","getActionNameFromStandardAttribute","labelledByAttribute","refElement","ShadowRoot","shadowElement","getElementById","ownerDocument","label","getTextualContent","fallbackStrategies","getActionNameFromElementForStrategies","strategies","recursionCounter","actionName","trimmedName","fixedMask","isContentEditable","userProgrammaticAttribute","USE_TREE_WALKER_FOR_ACTION_NAME","privacyEnabledActionName","walker","createTreeWalker","NodeFilter","SHOW_ELEMENT","SHOW_TEXT","rejectInvisibleOrMaskedElementsFilter","nextNode","currentNode","getComputedStyle","nodeSelfPrivacyLevel","FILTER_REJECT","visibility","contentVisibility","FILTER_ACCEPT","getTextualContentWithTreeWalker","innerText","removeTextFromElements","textToReplace","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","computeFrustration","clicks","rageClick","getUserActivity","scroll","isRage","addFrustration","isDead","hasError","hasSelectionChanged","hasPageActivity","CLICK_ACTION_MAX_DURATION","interactionSelectorCache","updateInteractionSelector","relativeTimestamp","isActionChildEvent","trackClickActions","actionTracker","currentClickChain","stopClickChain","stopActionEventsListener","onPointerDown","onPointerUp","selectionEmptyAtPointerDown","clickContext","userActivity","listeners","localUserActivity","listenActionEvents","pointerDownEvent","targetForPrivacy","getEventTarget","clickActionBase","rect","getBoundingClientRect","composedPathSelector","composedPath","elements","el","getComposedPathSelector","defaultActionName","getActionNameFromElement","width","height","position","x","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","viewEndedSubscription","endClocks","stopSubscription","startClickAction","findActionId","validate","finalizeClicks","composed","clickKey","startedClickAction","actionTrackerFinishedEvent","frustrationTypes","activityEndTime","currentCounts","frustrationType","domEvents","clickAction","events","startActionCollection","unsubscribeAutoAction","processAction","stopClickActions","clickActions","manualActions","onManualActionCompleted","lookupKey","actionKey","startedManualAction","manualAction","trackManualActions","actionContexts","manualActionId","clickActionId","correctedStartTime","actionId","isAuto","isAutoAction","loadingTime","loading_time","long_task","resource","composed_path_selector","name_source","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","RawReportType","initReportObservable","blockedURI","effectiveDirective","buildRawReportError","csp","disposition","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportErrorFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportErrorFromReport","types","createReportObservable","partial","startErrorCollection","bufferedDataObservable","errorObservable","bufferedData","consoleLog","trackConsoleError","trackReportError","handling_stack","component_stack","source_type","processError","doStartErrorCollection","IDLE_CALLBACK_TIMEOUT","createTaskQueue","pendingTasks","run","deadline","executionTimeRemaining","scheduleNextRun","timeout","alreadyMatchedEntries","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","sanitizeFirstByte","findLcpResourceEntry","resourceUrl","lcpStartTime","getResourceEntries","retrieveInitialDocumentResourceTiming","startResourceCollection","taskQueue","requestRegistry","isEarlyRequestCollectionEnabled","requests","tooManyRequestsReported","oldestRequest","debugContext","TOO_MANY_REQUESTS_INVESTIGATION","abortedCount","abortedOnStartCount","xhrCount","withoutMatchingEntryCount","oldestRequestAge","fetchCount","oldestRequestEndAge","getMatchingRequest","closestRequest","minTimeDifference","timeDifference","abs","createRequestRegistry","handleResource","matchingTiming","assembleResource","processRequest","performanceResourceSubscription","processResourceEntry","computeRawEvent","resourceTracker","manualResources","resourceKey","status_code","statusCode","isManual","trackManualResources","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","computeRequestTracingInfo","computeResourceEntryTracingInfo","computeResourceEntryDuration","computeRequestDuration","networkHeaders","TRACK_RESOURCE_HEADERS","matchers","urlMatchers","m","responseMatchers","requestMatchers","responseHeaders","filterHeaders","rawXhrHeaders","getAllResponseHeaders","rawXhrheaders","pairs","lines","colonIndex","parseRawXhrHeaders","getResponseHeaders","requestHeaders","getRequestHeaders","computeNetworkHeaders","graphql","computeGraphQlMetaData","contentTypeFromPerformanceEntry","contentType","computeContentTypeFromPerformanceEntry","resourceEvent","responseStatus","delivery_type","renderBlockingStatus","render_blocking_status","computeResourceEntryMetrics","getResourceDomainContext","baseDomainContext","performanceEntry","requestInput","requestInit","FORBIDDEN_HEADER_PATTERN","MAX_HEADER_VALUE_LENGTH","collectedHeaderCount","totalHeaderCount","hasReachedMaxHeaderCount","lowerName","matchHeader","capturedValue","header_name","original_length","limit","getTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","FCP_MAXIMUM_DELAY","trackNavigationTimings","stopOnReadyState","waitAfterLoadEvent","isIncompleteNavigation","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","processNavigationEntry","LCP_MAXIMUM_DELAY","trackLargestContentfulPaint","firstHidden","firstInteractionTimestamp","stopEventListener","biggestLcpSize","performanceLcpSubscription","LARGEST_CONTENTFUL_PAINT","lcpEntry","lcpTargetSelector","lcpValue","subParts","lcpResourceEntry","lcpRequestStart","lcpResponseEnd","loadDelay","loadTime","renderDelay","computeLcpSubParts","targetSelector","trackFirstHidden","viewStart","VISIBILITY_STATE","firstHiddenEntry","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","navigationTimings","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","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","WeakRef","devicePixelRatio","deref","asRumRect","topImpactedSource","currentImpactedArea","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","getInteractionCount","interactionCount","MAX_INP_VALUE","trackInteractionToNextPaint","viewLoadingType","EVENT","PerformanceEventTiming","getInteractionToNextPaint","setViewEnd","currentInp","viewEnd","getViewInteractionCount","stopViewInteractionCount","durationThreshold","previousInteractionCount","computeViewInteractionCount","trackViewInteractionCount","longestInteractions","sortAndTrimLongestInteractions","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","isTracked","trackLongestInteractions","subPartsTracker","groupsByInteractionId","updateGroupWithEntry","group","renderTime","existingGroup","referenceRenderTime","pruneUntracked","computeSubParts","inpDuration","nextPaintTime","inputDelay","processingDuration","presentationDelay","clear","createSubPartsTracker","firstInputSubscription","handleEntries","eventSubscription","newStartTime","getInteractionSelector","sanitizeInpValue","updateCurrentInp","viewEndTime","inpValue","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","hasManualLoadingTime","viewEnded","stopLoadingTimeTracking","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","trackLoadingTime","newLoadingTime","stopScrollMetricsTracking","newScrollMetrics","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","setINPViewEnd","getCommonViewMetrics","interactionToNextPaint","trackBfcacheMetrics","viewStartRelative","paintTime","requestAnimationFrame","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","activeViews","stopOnBFCacheRestore","locationChangeSubscription","currentView","startNewView","viewOptions","newlyCreatedView","customTimings","documentVersion","sessionIsActive","viewCreatedEvent","cancelScheduleViewUpdate","triggerViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","stopEventCountsTracking","trackViewEventCounts","keepAliveIntervalId","pageMayExitEvent","triggerBeforeViewUpdate","currentEnd","isActive","sanitized","sanitizeTiming","updatedName","newView","oldLocation","newLocation","currentLocation","otherLocation","hash","correspondingId","isHashAnAnchor","getPathFromHash","renewViewOnLocationChange","persisted","onBFCacheRestore","pageshowEvent","startViewCollection","pageOpenObservable","recorderApi","viewHistory","_l","_m","_o","_p","_q","_r","_s","_t","replayStats","getReplayStats","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","target_selector","previous_rect","current_rect","fcp","fid","inp","sub_parts","input_delay","processing_duration","presentation_delay","lcp","resource_url","load_delay","load_time","render_delay","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","isReplayForced","forcedReplay","rawSession","cookieContext","getSessionCookies","currentDomain","createdTimestamp","expireTimestamp","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","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","changed","deleted","listenToCookieStoreChange","watchCookieFallback","WATCH_COOKIE_INTERVAL_DELAY","previousCookieValue","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","processEntry","baseEvent","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","createEventRateLimiter","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","eventRateLimit","eventRateLimiters","defaultRumEventAttributes","serverRumEvent","rateLimitReached","shouldSend","allowedEventTypes","startSourceCodeContext","contextByFile","buildContextByFile","DD_SOURCE_CODE_CONTEXT","firstFrame","getSourceUrl","startRum","profilerApi","createEncoder","startRumSessionManagerStub","startRumEventBridge","batch","startRumBatch","preparePageExitSubscription","batchFlushObservable","startCustomerDataTelemetry","startTrackingConsentContext","stopInitialViewMetricsTelemetry","navigation","startInitialViewMetricsTelemetry","stopRumEventCollection","startRumEventCollectionResult","records","characterData","childList","subtree","createDOMMutationObservable","stopWindowOpen","createWindowOpenObservable","drift","browser_sdk_version","sdk_name","application","startDefaultContext","viewValueHistory","buildViewHistoryEntry","viewUpdate","startViewHistory","urlContexts","urlContextHistory","previousViewUrl","locationHref","viewUrl","buildUrlContext","changeTime","urlContext","findUrl","startUrlContexts","featureFlagContexts","featureFlagContext","feature_flags","currentContext","startFeatureFlagContexts","hasReplay","sampledForReplay","isRecording","has_replay","sampled_for_replay","startSessionContext","startConnectivityContext","useContextNamespace","globalContextManager","startGlobalContext","userContextManager","anonymous_id","usr","startUserContext","accountContextManager","account","startAccountContext","actionCollection","eventCollection","addEvent","startEventCollection","displayContext","viewport","animationFrameId","unsubscribeViewport","viewportDimension","cancelAnimationFrame","startDisplayContext","ciVisibilityContext","cookieObservable","testExecutionId","Cypress","cookieObservableSubscription","ci_test","test_execution_id","startCiVisibilityContext","synthetics","injected","startSyntheticsContext","stopViewCollection","resourceCollection","stopLongTaskCollection","startLongTaskCollection","vitalCollection","internalContext","viewContext","application_id","session_id","user_action","startInternalContext","startRumEventCollection","makeRumPublicApi","runtimeErrorSubscription","startBufferingData","createDeflateEncoder","streamId","onRumStart","preStartStrategy","createPostStartStrategy","rumPublicApi","setTrackingConsent","getInitConfiguration","START_STOP_ACTION","START_STOP_RESOURCE","setViewLoadingTime","setGlobalContext","getGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","setUser","getUser","setUserProperty","removeUserProperty","clearUser","setAccount","getAccount","setAccountProperty","removeAccountProperty","clearAccount","sanitizedOptions","getSessionReplayLink","startSessionReplayRecording","force","stopSessionReplayRecording","startFeatureOperation","action_type","succeedFeatureOperation","failFeatureOperation","getSessionReplayUrl","errorType","getSiteDefaultSubdomain","getDatadogSiteUrl","createFormDataTransport","httpRequest","attachments","formData","FormData","serializedEvent","serializedValue","RecordType","NodeType","ChangeType","AddString","AddNode","RemoveNode","Attribute","Text","Size","ScrollPosition","AddStyleSheet","AttachedStyleSheets","MediaPlaybackState","VisualViewport","IncrementalSource","MouseInteractionType","MediaInteractionType","SnapshotFormat","isFullSnapshotChangeRecordsEnabled","USE_CHANGE_RECORDS","USE_INCREMENTAL_CHANGE_RECORDS","isIncrementalSnapshotChangeRecordsEnabled","getElementInputValue","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","normalizedTagName","censoredImageForSize","serializeStyleSheets","cssStyleSheets","transaction","serializeStylesheet","cssStyleSheet","rules","cssRules","cssRule","addMetric","totalLength","rule","disabled","media","styleSheets","serializeAttribute","image","naturalWidth","naturalHeight","serializeDOMAttributes","attrs","scope","formValue","optionElement","selected","checked","serializeVirtualAttributes","doc","stylesheet","getCssRulesString","_cssText","sheet","mediaElement","rr_mediaState","paused","scrollLeft","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","getCssRuleStringForSafari","getCssRuleString","isCSSStyleRule","selectorText","escapeColon","isCSSImportRule","styleSheet","serializeNode","DOCUMENT_NODE","assignId","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","serializeDocumentTypeNode","processedTagName","getValidTagName","isSVG","SVGElement","rr_width","rr_height","serializeAttributes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeCDataNode","childNode","serializedChildNode","updateSerializationStats","serializeInTransaction","emitRecord","emitStats","serialize","serializationDuration","record","nodeIds","getOrInsert","serializedNodeIds","serializeChangesInTransaction","stringIds","pendingChanges","convertStringsToStringReferences","previousSize","changes","change","createChangeEncoder","addNode","addStyleSheet","mediaList","attachStyleSheets","nodeId","sheetIds","sheetId","removeNode","setAttributes","setMediaPlaybackState","setScrollPosition","setSize","setText","format","serializeFullSnapshot","initialOffset","serializeObservable","v1","serializeNodeAsChange","cursor","parentPrivacyLevel","selfPrivacyLevel","cdataNode","insertionPoint","advance","serializeCDataNodeAsChange","serializeStyleSheetsAsChange","serializeDocumentNodeAsChange","documentFragment","serializeDocumentFragmentNodeAsChange","serializeDocumentTypeNodeAsChange","domAttributes","encodedElementName","mediaState","linkOrStyle","styleSheetIds","serializeElementNodeAsChange","serializeTextNodeAsChange","descend","ascend","serializeHiddenNodePlaceholder","sheets","serializeStyleSheetAsChange","namespaceURI","createChildInsertionCursor","parentId","nextSiblingId","createInsertionCursor","container","previousSiblingId","computeInsertionPoint","serializeFullSnapshotAsChange","resetIds","assembleIncrementalSnapshot","serializeMutations","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","idsAreAssignedForNodeAndAncestors","adds","removes","hasBeenSerialized","addedAndMovedNodes","addedNodes","sortedAddedAndMovedNodes","nodes","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","serializedNode","nextId","getNextSibling","removedNodeMutations","processChildListMutations","texts","textMutations","handledNodes","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","shadowDomRemovedCallback","serializeMutationsAsChange","characterDataMutations","firstNewNodeId","forNodeAndDescendants","processRemovedNodes","getNextSiblingId","processAddedNodes","attributeNames","processAttributeMutations","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","isVisualViewportFactoredIn","getVisualViewport","takeFullSnapshot","defaultSerializeFullSnapshotCallback","has_focus","isTouchEvent","changedTouches","trackMove","updatePosition","cancelThrottle","coordinates","tryToComputeCoordinates","timeOffset","positions","isFinite","eventTypeToMouseInteraction","trackMouseInteraction","eventIds","trackScroll","scrollPositions","trackViewportResize","viewportResizeSubscription","trackVisualViewportResize","trackMediaInteraction","trackStyleSheet","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","instrumentGroupingCSSRuleClass","parentStyleSheet","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","stopper","currentRule","parentRule","trackFocus","trackViewEnd","flushMutations","viewEndSubscription","trackInput","lastInputStateMap","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","onElementChange","stopPropertySetterInstrumentation","inputState","isChecked","createRecordIfStateChanged","lastInputState","trackMutation","defaultSerializeMutationsCallback","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","throttledFlush","addMutations","createMutationBatch","takeRecords","attributeOldValue","characterDataOldValue","createStringIds","createItemIds","createWeakIdMap","firstId","createMap","processRecord","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","initShadowRootsController","scrollPositionsByElement","stopFullSnapshots","startFullSnapshots","trackers","tracker","createSegment","creationReason","encodedBytesCount","creation_reason","records_count","has_full_snapshot","index_in_view","serializationStats","addRecord","addStats","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","startSegmentTelemetry","requestEvent","bandwidthStats","fullSnapshot","incrementalSnapshot","ongoingRequests","totalSize","compressed","startRecording","replayRequest","startRecordBridge","segmentCollection","segmentTelemetry","stopRecording","PATH_MIXED_ALPHANUMERICS","getCustomOrDefaultViewName","customViewName","viewPathUrl","getDefaultViewName","buildProfileEventAttributes","profilerTrace","ids","names","views","viewName","extractViewIdsAndNames","longTaskIds","longTasks","longTask","actionIds","actions","vitalIds","vitalLabels","vitals","extractVitalIdsAndLabels","assembleProfilingPayload","profileAttributes","profileEventTags","buildProfileEventTags","profileEvent","toISOString","family","runtime","tags_profiler","clock_drift","buildProfileEvent","LONG_TASK_ID_HISTORY_EXPIRE_DELAY","createLongTaskHistory","ACTION_ID_HISTORY_TIME_OUT_DELAY","createActionHistory","actionStart","durationForEntry","VITAL_ID_HISTORY_TIME_OUT_DELAY","createVitalHistory","DEFAULT_RUM_PROFILER_CONFIGURATION","sampleIntervalMs","collectIntervalMs","minProfileDurationMs","minNumberOfSamples","createRumProfiler","profilingContextManager","profilerConfiguration","transport","lastViewEntry","globalCleanupTasks","longTaskHistory","actionHistory","vitalHistory","instance","stateReason","viewEntry","handleVisibilityChange","handleBeforeUnload","startNextProfilerInstance","stopProfiling","runningInstance","cleanupTask","collectProfilerInstance","stopProfilerInstance","error_reason","globalThisProfiler","Profiler","existingInstance","viewUpdatedSubscription","collectViewEntry","profiler","sampleInterval","handleSampleBufferFull","removeEventListener","trace","isBelowDurationThreshold","isBelowSampleThreshold","samples","numberOfSamples","sample","stackId","getNumberOfSamples","handleProfilerTrace","pauseProfilerInstance","isRunning","isPaused","statsPerView","getSegmentsCount","getOrCreateReplayStats","segments_count","addSegment","addWroteData","additionalBytesCount","segments_total_raw_size","toDelete","deleteOldestStats","ownKeys","__createBinding","create","o","k","k2","desc","__esModule","writable","__setModuleDefault","v","__importStar","getOwnPropertyNames","ar","exports","userHasOptedOutOfCookiesForCategory","consented","checkCookieConsent","deferRun","Consent","Cookies","execute","cookiebotJob","job","consent","Cookiebot","hasResponse","CookieString","parsedCookieConsent","CookieConsent","factory","module","OldCookies","noConflict","extend","converter","defaults","stringifiedAttributes","jar","charAt","getJSON","withConverter","__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","removeErrorListener","onError","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","worker_version","stream_id","isBrowserSupported","NodeList","isRecordingStarted","getErrorType","lazyLoadRecorder","importRecorder","getOrCreateDeflateEncoder","documentReadyDuration","recorderSettledDuration","forced","loadRecorderModuleDuration","recorderInitDuration","waitForDocReadyDuration","startRecorderInitTelemetry","doStart","startRecordingImpl","all","notifyWhenSettled","deflateEncoder","canStartRecording","isRecordingInProgress","shouldForceReplay","promise","importProfiler","shouldStartImmediately","cachedDeflateEncoder","makeRecorderApi","profiling","startProfilingContext","lazyLoadProfiler","makeProfilerApi","datadogRum","checkConsentTypePresent","consentType","packageConsent","datadogEnvironment","datadogVersion","datadogSampleRate","statistics","packageConsented"],"sourceRoot":""}