{"version":3,"file":"datadog.js","mappings":"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","sources":["webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.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/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/serializeDocument.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMove.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMouseInteraction.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackScroll.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewportResize.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMediaInteraction.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackStyleSheet.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFocus.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFrustration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewEnd.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackInput.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMutation.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/startFullSnapshots.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/recordIds.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/startRecordBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/connectivity/connectivity.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/customerDataTracker.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/trackingConsent.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/storeContextManager.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/encoder.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/displayAlreadyInitializedError.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/vital/vitalCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/plugins.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionStoreStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStateValidation.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/tags.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-core/esm/tools/matchOption.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/sampler.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/configuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/remoteConfiguration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/preStartRum.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.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/lifeCycle.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewHistory.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/discardNegativeDuration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/firstInputPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/performanceObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/privacy.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/getSelectorFromElement.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/listenActionEvents.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/computeFrustration.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/interactionSelectorCache.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/trackClickActions.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/action/actionCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.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/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/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/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/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-core/esm/transport/batch.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/flushController.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.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/contexts/syntheticsContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/hooks.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.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/displayContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/longAnimationFrame/longAnimationFrameCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/longTask/longTaskCollection.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/internalContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/getSessionReplayUrl.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/timer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/requestIdleCallback.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/getGlobalObject.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/handlingStack.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/computeStackTrace.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://market-storefront/webpack/bootstrap","webpack://market-storefront/webpack/runtime/define property getters","webpack://market-storefront/webpack/runtime/hasOwnProperty shorthand","webpack://market-storefront/webpack/runtime/make namespace object","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateEncoder.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/scriptLoadingError.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateWorker.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/isBrowserSupported.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/getSessionReplayLink.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/postStartStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/lazyLoadRecorder.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/./app/javascript/packs/datadog.js"],"sourcesContent":["export const MAX_STATS_HISTORY = 1000;\nlet statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    let replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    const toDelete = statsPerView.keys().next().value;\n    if (toDelete) {\n        statsPerView.delete(toDelete);\n    }\n}\n//# sourceMappingURL=replayStats.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot, CENSORED_STRING_MARK, shouldMaskNode } from '@datadog/browser-rum-core';\nconst serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    let current = node;\n    while (current) {\n        if (!hasSerializedNode(current) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\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}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_a) {\n        return url;\n    }\n}\nconst TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    const processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nexport function censoredImageForSize(width, height) {\n    return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${width}' height='${height}' style='background-color:silver'%3E%3C/svg%3E`;\n}\n//# sourceMappingURL=serializationUtils.js.map","export const RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport const NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport const IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport const MouseInteractionType = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport const MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map((cssStyleSheet) => {\n        const rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        const cssRules = Array.from(rules, (cssRule) => cssRule.cssText);\n        const styleSheet = {\n            cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK, STABLE_ATTRIBUTES, isLongDataUrl, sanitizeDataUrl, } from '@datadog/browser-rum-core';\nimport { censoredImageForSize } from './serializationUtils';\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    const attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        const tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' && (attributeName === 'src' || attributeName === 'srcset')) {\n            // generate image with similar dimension than the original to have the same rendering behaviour\n            const image = element;\n            if (image.naturalWidth > 0) {\n                return censoredImageForSize(image.naturalWidth, image.naturalHeight);\n            }\n            const { width, height } = element.getBoundingClientRect();\n            if (width > 0 || height > 0) {\n                return censoredImageForSize(width, height);\n            }\n            // if we can't get the image size, fallback to the censored image\n            return CENSORED_IMG_MARK;\n        }\n        // mask source URLs\n        if (tagName === 'SOURCE' && (attributeName === 'src' || attributeName === 'srcset')) {\n            return CENSORED_IMG_MARK;\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && attributeName.startsWith('data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n        // mask iframe srcdoc\n        if (tagName === 'IFRAME' && attributeName === 'srcdoc') {\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (isLongDataUrl(attributeValue)) {\n        return sanitizeDataUrl(attributeValue);\n    }\n    return attributeValue;\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { isSafari } from '@datadog/browser-core';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    const safeAttrs = {};\n    const tagName = getValidTagName(element.tagName);\n    const doc = element.ownerDocument;\n    for (let i = 0; i < element.attributes.length; i += 1) {\n        const attribute = element.attributes.item(i);\n        const attributeName = attribute.name;\n        const attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName, options.configuration);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        const formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        const optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => s.href === element.href);\n        const cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        const cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    const inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            delete safeAttrs.checked;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        const mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element only for full snapshot\n     */\n    let scrollTop;\n    let scrollLeft;\n    const serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop, scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                ({ scrollTop, scrollLeft } = serializationContext.elementsScrollPositions.get(element));\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\nexport function getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    let rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    const styleSheetCssText = Array.from(rules, isSafari() ? getCssRuleStringForSafari : getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleStringForSafari(rule) {\n    // Safari does not escape attribute selectors containing : properly\n    // https://bugs.webkit.org/show_bug.cgi?id=184604\n    if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n        // This regex replaces [foo:bar] by [foo\\\\:bar]\n        const escapeColon = /(\\[[\\w-]+[^\\\\])(:[^\\]]+\\])/g;\n        return rule.cssText.replace(escapeColon, '$1\\\\$2');\n    }\n    return getCssRuleString(rule);\n}\nfunction getCssRuleString(rule) {\n    // If it's an @import rule, try to inline sub-rules recursively with `getCssRulesString`. This\n    // operation can fail if the imported stylesheet is protected by CORS, in which case we fallback\n    // to the @import rule CSS text.\n    return (isCSSImportRule(rule) && getCssRulesString(rule.styleSheet)) || rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isNodeShadowRoot, hasChildNodes, forEachChildNodes, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, } from '@datadog/browser-rum-core';\nimport { NodeType } from '../../../types';\nimport { getSerializedNodeId, getValidTagName, setSerializedNodeId } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\nexport function serializeNodeWithId(node, options) {\n    const serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    const id = getSerializedNodeId(node) || generateNextId();\n    const serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nlet _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    const result = [];\n    forEachChildNodes(node, (childNode) => {\n        const serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    const isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: serializeChildNodes(element, options),\n        isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nfunction serializeElementNode(element, options) {\n    const tagName = getValidTagName(element.tagName);\n    const isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        const { width, height } = element.getBoundingClientRect();\n        return {\n            type: NodeType.Element,\n            tagName,\n            attributes: {\n                rr_width: `${width}px`,\n                rr_height: `${height}px`,\n                [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_HIDDEN,\n            },\n            childNodes: [],\n            isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    const attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    let childNodes = [];\n    if (hasChildNodes(element) &&\n        // Do not serialize style children as the css rules are already in the _cssText attribute\n        tagName !== 'style') {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        let childNodesSerializationOptions;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = {\n                ...options,\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            };\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: NodeType.Element,\n        tagName,\n        attributes,\n        childNodes,\n        isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    const textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { serializeNodeWithId } from './serializeNode';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration,\n    });\n}\n//# sourceMappingURL=serializeDocument.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nconst TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport const convertMouseEventToLayoutCoordinates = (clientX, clientY) => {\n    const visualViewport = window.visualViewport;\n    const normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport const getVisualViewport = (visualViewport) => ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n});\n//# sourceMappingURL=viewports.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: {\n            source,\n            ...data,\n        },\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { addEventListeners, addTelemetryDebug, throttle } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function trackMove(configuration, moveCb) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            const coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            const position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            moveCb(assembleIncrementalSnapshot(isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove, { positions: [position] }));\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\nexport function tryToComputeCoordinates(event) {\n    let { clientX: x, clientY: y } = isTouchEvent(event) ? event.changedTouches[0] : event;\n    if (window.visualViewport) {\n        const { visualViewportX, visualViewportY } = convertMouseEventToLayoutCoordinates(x, y);\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\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 { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './trackMove';\nconst eventTypeToMouseInteraction = {\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    [\"pointerup\" /* DOM_EVENT.POINTER_UP */]: MouseInteractionType.MouseUp,\n    [\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */]: MouseInteractionType.MouseDown,\n    [\"click\" /* DOM_EVENT.CLICK */]: MouseInteractionType.Click,\n    [\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */]: MouseInteractionType.ContextMenu,\n    [\"dblclick\" /* DOM_EVENT.DBL_CLICK */]: MouseInteractionType.DblClick,\n    [\"focus\" /* DOM_EVENT.FOCUS */]: MouseInteractionType.Focus,\n    [\"blur\" /* DOM_EVENT.BLUR */]: MouseInteractionType.Blur,\n    [\"touchstart\" /* DOM_EVENT.TOUCH_START */]: MouseInteractionType.TouchStart,\n    [\"touchend\" /* DOM_EVENT.TOUCH_END */]: MouseInteractionType.TouchEnd,\n};\nexport function trackMouseInteraction(configuration, mouseInteractionCb, recordIds) {\n    const handler = (event) => {\n        const target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        const id = getSerializedNodeId(target);\n        const type = eventTypeToMouseInteraction[event.type];\n        let interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            const coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id, type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id, type };\n        }\n        const record = {\n            id: recordIds.getIdForEvent(event),\n            ...assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction),\n        };\n        mouseInteractionCb(record);\n    };\n    return addEventListeners(configuration, document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMouseInteraction.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY, getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst SCROLL_OBSERVER_THRESHOLD = 100;\nexport function trackScroll(configuration, scrollCb, elementsScrollPositions, target = document) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        const id = getSerializedNodeId(target);\n        const scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        scrollCb(assembleIncrementalSnapshot(IncrementalSource.Scroll, {\n            id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD);\n    const { stop: removeListener } = addEventListener(configuration, target, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackScroll.js.map","import { throttle, addEventListeners, timeStampNow, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { IncrementalSource, RecordType } from '../../../types';\nimport { getVisualViewport } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function trackViewportResize(configuration, viewportResizeCb) {\n    const viewportResizeSubscription = initViewportObservable(configuration).subscribe((data) => {\n        viewportResizeCb(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: () => {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function trackVisualViewportResize(configuration, visualViewportResizeCb) {\n    const visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    const { throttled: updateDimension, cancel: cancelThrottle } = throttle(() => {\n        visualViewportResizeCb({\n            data: getVisualViewport(visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp: timeStampNow(),\n        });\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackViewportResize.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackMediaInteraction(configuration, mediaInteractionCb) {\n    return addEventListeners(configuration, document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], (event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, {\n            id: getSerializedNodeId(target),\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 { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackStyleSheet(styleSheetCb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    const instrumentationStoppers = [\n        instrumentMethod(CSSStyleSheet.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                adds: [{ rule, index }],\n            })));\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                removes: [{ index }],\n            })));\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethod(cls.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index || 0);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        adds: [{ rule, index: path }],\n                    }));\n                }\n            });\n        }), instrumentMethod(cls.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        removes: [{ index: path }],\n                    }));\n                }\n            });\n        }));\n    }\n    return {\n        stop: () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        },\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    const path = [];\n    let currentRule = rule;\n    while (currentRule.parentRule) {\n        const rules = Array.from(currentRule.parentRule.cssRules);\n        const index = rules.indexOf(currentRule);\n        path.unshift(index);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    const rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    const index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=trackStyleSheet.js.map","import { addEventListeners, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackFocus(configuration, focusCb) {\n    return addEventListeners(configuration, window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], () => {\n        focusCb({\n            data: { has_focus: document.hasFocus() },\n            type: RecordType.Focus,\n            timestamp: timeStampNow(),\n        });\n    });\n}\n//# sourceMappingURL=trackFocus.js.map","import { RecordType } from '../../../types';\nexport function trackFrustration(lifeCycle, frustrationCb, recordIds) {\n    const frustrationSubscription = lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, (data) => {\n        var _a, _b;\n        if (data.rawRumEvent.type === \"action\" /* RumEventType.ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* ActionType.CLICK */ &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            data.domainContext.events &&\n            data.domainContext.events.length) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map((e) => recordIds.getIdForEvent(e)),\n                },\n            });\n        }\n    });\n    return {\n        stop: () => {\n            frustrationSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFrustration.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackViewEnd(lifeCycle, viewEndCb) {\n    const viewEndSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, () => {\n        viewEndCb({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    });\n    return {\n        stop: () => {\n            viewEndSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackViewEnd.js.map","import { 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, getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackInput(configuration, inputCb, target = document) {\n    const defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    const lastInputStateMap = new WeakMap();\n    const isShadowRoot = target !== document;\n    const { stop: stopEventListeners } = addEventListeners(configuration, target, \n    // The 'input' event bubbles across shadow roots, so we don't have to listen for it on shadow\n    // roots since it will be handled by the event listener that we did add to the document. Only\n    // the 'change' event is blocked and needs to be handled on shadow roots.\n    isShadowRoot ? [\"change\" /* DOM_EVENT.CHANGE */] : [\"input\" /* DOM_EVENT.INPUT */, \"change\" /* DOM_EVENT.CHANGE */], (event) => {\n        const target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    });\n    let stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        const instrumentationStoppers = [\n            instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n        ];\n        stopPropertySetterInstrumentation = () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return {\n        stop: () => {\n            stopPropertySetterInstrumentation();\n            stopEventListeners();\n        },\n    };\n    function onElementChange(target) {\n        const nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        const type = target.type;\n        let inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            const value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        const name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            document.querySelectorAll(`input[type=\"radio\"][name=\"${CSS.escape(name)}\"]`).forEach((el) => {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        const lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            inputCb(assembleIncrementalSnapshot(IncrementalSource.Input, {\n                id: getSerializedNodeId(target),\n                ...inputState,\n            }));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.js.map","import { noop, throttle, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nconst MUTATION_PROCESS_MAX_DELAY = 100;\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport const MUTATION_PROCESS_MIN_DELAY = 16;\nexport function createMutationBatch(processMutationBatch) {\n    let cancelScheduledFlush = noop;\n    let pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n        leading: false,\n    });\n    return {\n        addMutations: (mutations) => {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push(...mutations);\n        },\n        flush,\n        stop: () => {\n            cancelScheduledFlush();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\nimport { assembleIncrementalSnapshot } from '../assembly';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function trackMutation(mutationCallback, configuration, shadowRootsController, target) {\n    const MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    const mutationBatch = createMutationBatch((mutations) => {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController);\n    });\n    const observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: () => {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: () => {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController) {\n    const nodePrivacyLevelCache = new Map();\n    mutations\n        .filter((mutation) => mutation.type === 'childList')\n        .forEach((mutation) => {\n        mutation.removedNodes.forEach((removedNode) => {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    const filteredMutations = mutations.filter((mutation) => mutation.target.isConnected &&\n        nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n        getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !==\n            NodePrivacyLevel.HIDDEN);\n    const { adds, removes, hasBeenSerialized } = processChildListMutations(filteredMutations.filter((mutation) => mutation.type === 'childList'), configuration, shadowRootsController, nodePrivacyLevelCache);\n    const texts = processCharacterDataMutations(filteredMutations.filter((mutation) => mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)), configuration, nodePrivacyLevelCache);\n    const attributes = processAttributesMutations(filteredMutations.filter((mutation) => mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)), configuration, nodePrivacyLevelCache);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback(assembleIncrementalSnapshot(IncrementalSource.Mutation, { adds, removes, texts, attributes }));\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController, nodePrivacyLevelCache) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    const addedAndMovedNodes = new Set();\n    const removedNodes = new Map();\n    for (const mutation of mutations) {\n        mutation.addedNodes.forEach((node) => {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach((node) => {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    const sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    const serializedNodeIds = new Set();\n    const addedNodeMutations = [];\n    for (const node of sortedAddedAndMovedNodes) {\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        const serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds,\n            parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController },\n            configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        const parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    const removedNodeMutations = [];\n    removedNodes.forEach((parent, node) => {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        let nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, configuration, nodePrivacyLevelCache) {\n    var _a;\n    const textMutations = [];\n    // Deduplicate mutations based on their target node\n    const handledNodes = new Set();\n    const filteredMutations = mutations.filter((mutation) => {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (const mutation of filteredMutations) {\n        const value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, configuration, nodePrivacyLevelCache) {\n    const attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    const handledElements = new Map();\n    const filteredMutations = mutations.filter((mutation) => {\n        const handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes && handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    const emittedMutations = new Map();\n    for (const mutation of filteredMutations) {\n        const uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        const privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        const attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        let transformedValue;\n        if (mutation.attributeName === 'value') {\n            const inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        let emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort((a, b) => {\n        const position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    forEachChildNodes(removedNode, (childNode) => traverseRemovedShadowDom(childNode, shadowDomRemovedCallback));\n}\n//# sourceMappingURL=trackMutation.js.map","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport const initShadowRootsController = (configuration, callback, elementsScrollPositions) => {\n    const controllerByShadowRoot = new Map();\n    const shadowRootsController = {\n        addShadowRoot: (shadowRoot) => {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            const mutationTracker = trackMutation(callback, configuration, shadowRootsController, shadowRoot);\n            // The change event does not bubble up across the shadow root, we have to listen on the shadow root\n            const inputTracker = trackInput(configuration, callback, shadowRoot);\n            // The scroll event does not bubble up across the shadow root, we have to listen on the shadow root\n            const scrollTracker = trackScroll(configuration, callback, elementsScrollPositions, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: () => mutationTracker.flush(),\n                stop: () => {\n                    mutationTracker.stop();\n                    inputTracker.stop();\n                    scrollTracker.stop();\n                },\n            });\n        },\n        removeShadowRoot: (shadowRoot) => {\n            const entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: () => {\n            controllerByShadowRoot.forEach(({ stop }) => stop());\n        },\n        flush: () => {\n            controllerByShadowRoot.forEach(({ flush }) => flush());\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { sendToExtension } from '@datadog/browser-core';\nimport * as replayStats from '../replayStats';\nimport { trackFocus, trackFrustration, trackInput, trackMediaInteraction, trackMouseInteraction, trackMove, trackMutation, trackScroll, trackStyleSheet, trackViewEnd, trackViewportResize, trackVisualViewportResize, } from './trackers';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nimport { startFullSnapshots } from './startFullSnapshots';\nimport { initRecordIds } from './recordIds';\nexport function record(options) {\n    const { emit, configuration, lifeCycle } = options;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    const emitAndComputeStats = (record) => {\n        emit(record);\n        sendToExtension('record', { record });\n        const view = options.viewHistory.findView();\n        replayStats.addRecord(view.id);\n    };\n    const elementsScrollPositions = createElementsScrollPositions();\n    const shadowRootsController = initShadowRootsController(configuration, emitAndComputeStats, elementsScrollPositions);\n    const { stop: stopFullSnapshots } = startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, (records) => records.forEach((record) => emitAndComputeStats(record)));\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    const recordIds = initRecordIds();\n    const mutationTracker = trackMutation(emitAndComputeStats, configuration, shadowRootsController, document);\n    const trackers = [\n        mutationTracker,\n        trackMove(configuration, emitAndComputeStats),\n        trackMouseInteraction(configuration, emitAndComputeStats, recordIds),\n        trackScroll(configuration, emitAndComputeStats, elementsScrollPositions, document),\n        trackViewportResize(configuration, emitAndComputeStats),\n        trackInput(configuration, emitAndComputeStats),\n        trackMediaInteraction(configuration, emitAndComputeStats),\n        trackStyleSheet(emitAndComputeStats),\n        trackFocus(configuration, emitAndComputeStats),\n        trackVisualViewportResize(configuration, emitAndComputeStats),\n        trackFrustration(lifeCycle, emitAndComputeStats, recordIds),\n        trackViewEnd(lifeCycle, (viewEndRecord) => {\n            flushMutations();\n            emitAndComputeStats(viewEndRecord);\n        }),\n    ];\n    return {\n        stop: () => {\n            shadowRootsController.stop();\n            trackers.forEach((tracker) => tracker.stop());\n            stopFullSnapshots();\n        },\n        flushMutations,\n        shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    const scrollPositionsByElement = new WeakMap();\n    return {\n        set(element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get(element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has(element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { getScrollX, getScrollY, getViewportDimension } from '@datadog/browser-rum-core';\nimport { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { serializeDocument } from './serialization';\nimport { getVisualViewport } from './viewports';\nexport function startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, fullSnapshotCallback) {\n    const takeFullSnapshot = (timestamp = timeStampNow(), serializationContext = {\n        status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n        elementsScrollPositions,\n        shadowRootsController,\n    }) => {\n        const { width, height } = getViewportDimension();\n        const records = [\n            {\n                data: {\n                    height,\n                    href: window.location.href,\n                    width,\n                },\n                type: RecordType.Meta,\n                timestamp,\n            },\n            {\n                data: {\n                    has_focus: document.hasFocus(),\n                },\n                type: RecordType.Focus,\n                timestamp,\n            },\n            {\n                data: {\n                    node: serializeDocument(document, configuration, serializationContext),\n                    initialOffset: {\n                        left: getScrollX(),\n                        top: getScrollY(),\n                    },\n                },\n                type: RecordType.FullSnapshot,\n                timestamp,\n            },\n        ];\n        if (window.visualViewport) {\n            records.push({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp,\n            });\n        }\n        return records;\n    };\n    fullSnapshotCallback(takeFullSnapshot());\n    const { unsubscribe } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, (view) => {\n        flushMutations();\n        fullSnapshotCallback(takeFullSnapshot(view.startClocks.timeStamp, {\n            shadowRootsController,\n            status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n            elementsScrollPositions,\n        }));\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\n//# sourceMappingURL=startFullSnapshots.js.map","export function initRecordIds() {\n    const recordIds = new WeakMap();\n    let nextId = 1;\n    return {\n        getIdForEvent(event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nexport function createSegment({ context, creationReason, encoder, }) {\n    let encodedBytesCount = 0;\n    const viewId = context.view.id;\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: replayStats.getSegmentsCount(viewId),\n        source: 'browser',\n        ...context,\n    };\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);\n        const prefix = encoder.isEmpty ? '{\"records\":[' : ',';\n        encoder.write(prefix + JSON.stringify(record), (additionalEncodedBytesCount) => {\n            encodedBytesCount += additionalEncodedBytesCount;\n            callback(encodedBytesCount);\n        });\n    }\n    function flush(callback) {\n        if (encoder.isEmpty) {\n            throw new Error('Empty segment flushed');\n        }\n        encoder.write(`],${JSON.stringify(metadata).slice(1)}\\n`);\n        encoder.finish((encoderResult) => {\n            replayStats.addWroteData(metadata.view.id, encoderResult.rawBytesCount);\n            callback(metadata, encoderResult);\n        });\n    }\n    return { addRecord, flush };\n}\n//# sourceMappingURL=segment.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { createSegment } from './segment';\nexport const SEGMENT_DURATION_LIMIT = 5 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport let SEGMENT_BYTES_LIMIT = 60000;\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as many records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment bytes count reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\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: unsubscribePageExited } = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, (pageExitEvent) => {\n        flushSegment(pageExitEvent.reason);\n    });\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush((metadata, encoderResult) => {\n                const payload = buildReplayPayload(encoderResult.output, metadata, 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        stop: () => {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\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, 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 { data: formData, bytesCount: data.byteLength };\n}\n//# sourceMappingURL=buildReplayPayload.js.map","import { createHttpRequest, addTelemetryDebug, canUseEventBridge } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { startRecordBridge } from '../domain/startRecordBridge';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewHistory, encoder, httpRequest) {\n    const cleanupTasks = [];\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    let addRecord;\n    if (!canUseEventBridge()) {\n        const segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);\n        addRecord = segmentCollection.addRecord;\n        cleanupTasks.push(segmentCollection.stop);\n    }\n    else {\n        ;\n        ({ addRecord } = startRecordBridge(viewHistory));\n    }\n    const { stop: stopRecording } = record({\n        emit: addRecord,\n        configuration,\n        lifeCycle,\n        viewHistory,\n    });\n    cleanupTasks.push(stopRecording);\n    return {\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRecordBridge(viewHistory) {\n    const bridge = getEventBridge();\n    return {\n        addRecord: (record) => {\n            // Get the current active view, not at the time of the record, aligning with the segment logic.\n            // This approach could potentially associate the record to an incorrect view, in case the record date is in the past (e.g. frustration records).\n            // However the risk is minimal. We could address the issue when potential negative impact are identified.\n            const view = viewHistory.findView();\n            bridge.send('record', record, view.id);\n        },\n    };\n}\n//# sourceMappingURL=startRecordBridge.js.map","import { 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","export const INTAKE_SITE_STAGING = 'datad0g.com';\nexport const INTAKE_SITE_FED_STAGING = 'dd0g-gov.com';\nexport const INTAKE_SITE_US1 = 'datadoghq.com';\nexport const INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport const INTAKE_SITE_US1_FED = 'ddog-gov.com';\nexport const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com';\nexport const INTAKE_URL_PARAMETERS = ['ddsource', 'ddtags'];\n//# sourceMappingURL=intakeSites.js.map","export function getConnectivity() {\n    var _a;\n    const navigator = window.navigator;\n    return {\n        status: navigator.onLine ? 'connected' : 'not_connected',\n        interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,\n        effective_type: (_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType,\n    };\n}\n//# sourceMappingURL=connectivity.js.map","import { noop } from '../tools/utils/functionUtils';\nimport { addEventListener } from './addEventListener';\nexport function runOnReadyState(configuration, expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n        return { stop: noop };\n    }\n    const eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n    return addEventListener(configuration, window, eventName, callback, { once: true });\n}\nexport function asyncRunOnReadyState(configuration, expectedReadyState) {\n    return new Promise((resolve) => {\n        runOnReadyState(configuration, expectedReadyState, resolve);\n    });\n}\n//# sourceMappingURL=runOnReadyState.js.map","/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value) {\n    if (value === null) {\n        return 'null';\n    }\n    if (Array.isArray(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n//# sourceMappingURL=typeUtils.js.map","export function isServerError(status) {\n    return status >= 500;\n}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (_a) {\n        // clone can throw if the response has already been used by another instrumentation or is disturbed\n        return;\n    }\n}\n//# sourceMappingURL=responseUtils.js.map","import { display } from './display';\nlet onMonitorErrorCollected;\nlet debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n    onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n    debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n    onMonitorErrorCollected = undefined;\n    debugMode = false;\n}\nexport function monitored(_, __, descriptor) {\n    const originalMethod = descriptor.value;\n    descriptor.value = function (...args) {\n        const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        monitorError(e);\n    }\n}\nexport function monitorError(e) {\n    displayIfDebugEnabled(e);\n    if (onMonitorErrorCollected) {\n        try {\n            onMonitorErrorCollected(e);\n        }\n        catch (e) {\n            displayIfDebugEnabled(e);\n        }\n    }\n}\nexport function displayIfDebugEnabled(...args) {\n    if (debugMode) {\n        display.error('[MONITOR]', ...args);\n    }\n}\n//# sourceMappingURL=monitor.js.map","/* eslint-disable local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport const ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\n/**\n * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove\n * \"console.*\" references. This causes some issue as we expect `console.*` to be defined.\n * As a workaround, let's use a variable alias, so those expressions won't be taken into account by\n * simple static analysis.\n *\n * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/\n * [2]: https://github.com/terser/terser#compress-options (look for drop_console)\n */\nexport const globalConsole = console;\nexport const originalConsoleMethods = {};\nObject.keys(ConsoleApiName).forEach((name) => {\n    originalConsoleMethods[name] = globalConsole[name];\n});\nconst PREFIX = 'Datadog Browser SDK:';\nexport const display = {\n    debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),\n    log: originalConsoleMethods.log.bind(globalConsole, PREFIX),\n    info: originalConsoleMethods.info.bind(globalConsole, PREFIX),\n    warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),\n    error: originalConsoleMethods.error.bind(globalConsole, PREFIX),\n};\nexport const DOCS_ORIGIN = 'https://docs.datadoghq.com';\nexport const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`;\nexport const MORE_DETAILS = 'More details:';\n//# sourceMappingURL=display.js.map","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}\n//# sourceMappingURL=arrayUtils.js.map","export function sendToExtension(type, payload) {\n    const callback = window.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type, payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.js.map","// eslint-disable-next-line no-restricted-syntax\nexport class Observable {\n    constructor(onFirstSubscribe) {\n        this.onFirstSubscribe = onFirstSubscribe;\n        this.observers = [];\n    }\n    subscribe(f) {\n        this.observers.push(f);\n        if (this.observers.length === 1 && this.onFirstSubscribe) {\n            this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined;\n        }\n        return {\n            unsubscribe: () => {\n                this.observers = this.observers.filter((other) => f !== other);\n                if (!this.observers.length && this.onLastUnsubscribe) {\n                    this.onLastUnsubscribe();\n                }\n            },\n        };\n    }\n    notify(data) {\n        this.observers.forEach((observer) => observer(data));\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//# sourceMappingURL=observable.js.map","import { ONE_KIBI_BYTE, computeBytesCount } from '../../tools/utils/byteUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../../tools/display';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;\n// We observed that the compression ratio is around 8 in general, but we also want to keep a margin\n// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB\n// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this\n// is a bit arbitrary.\nexport const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;\nexport const BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createCustomerDataTrackerManager(compressionStatus = 2 /* CustomerDataCompressionStatus.Disabled */) {\n    const customerDataTrackers = new Map();\n    let alreadyWarned = false;\n    function checkCustomerDataLimit(initialBytesCount = 0) {\n        if (alreadyWarned || compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n            return;\n        }\n        const bytesCountLimit = compressionStatus === 2 /* CustomerDataCompressionStatus.Disabled */\n            ? CUSTOMER_DATA_BYTES_LIMIT\n            : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT;\n        let bytesCount = initialBytesCount;\n        customerDataTrackers.forEach((tracker) => {\n            bytesCount += tracker.getBytesCount();\n        });\n        if (bytesCount > bytesCountLimit) {\n            displayCustomerDataLimitReachedWarning(bytesCountLimit);\n            alreadyWarned = true;\n        }\n    }\n    return {\n        /**\n         * Creates a detached tracker. The manager will not store a reference to that tracker, and the\n         * bytes count will be counted independently from other detached trackers.\n         *\n         * This is particularly useful when we don't know when the tracker will be unused, so we don't\n         * leak memory (ex: when used in Logger instances).\n         */\n        createDetachedTracker: () => {\n            const tracker = createCustomerDataTracker(() => checkCustomerDataLimit(tracker.getBytesCount()));\n            return tracker;\n        },\n        /**\n         * Creates a tracker if it doesn't exist, and returns it.\n         */\n        getOrCreateTracker: (type) => {\n            if (!customerDataTrackers.has(type)) {\n                customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit));\n            }\n            return customerDataTrackers.get(type);\n        },\n        setCompressionStatus: (newCompressionStatus) => {\n            if (compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n                compressionStatus = newCompressionStatus;\n                checkCustomerDataLimit();\n            }\n        },\n        getCompressionStatus: () => compressionStatus,\n        stop: () => {\n            customerDataTrackers.forEach((tracker) => tracker.stop());\n            customerDataTrackers.clear();\n        },\n    };\n}\nexport function createCustomerDataTracker(checkCustomerDataLimit) {\n    let bytesCountCache = 0;\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call context APIs synchronously multiple times in a row\n    const { throttled: computeBytesCountThrottled, cancel: cancelComputeBytesCount } = throttle((context) => {\n        bytesCountCache = computeBytesCount(jsonStringify(context));\n        checkCustomerDataLimit();\n    }, BYTES_COMPUTATION_THROTTLING_DELAY);\n    const resetBytesCount = () => {\n        cancelComputeBytesCount();\n        bytesCountCache = 0;\n    };\n    return {\n        updateCustomerData: (context) => {\n            if (isEmptyObject(context)) {\n                resetBytesCount();\n            }\n            else {\n                computeBytesCountThrottled(context);\n            }\n        },\n        resetCustomerData: resetBytesCount,\n        getBytesCount: () => bytesCountCache,\n        stop: () => {\n            cancelComputeBytesCount();\n        },\n    };\n}\nfunction displayCustomerDataLimitReachedWarning(bytesCountLimit) {\n    display.warn(`Customer data exceeds the recommended ${bytesCountLimit / ONE_KIBI_BYTE}KiB threshold. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#customer-data-exceeds-the-recommended-threshold-warning`);\n}\n//# sourceMappingURL=customerDataTracker.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' && key in newContext) {\n            /* eslint-disable @typescript-eslint/no-base-to-string */\n            newContext[key] = String(newContext[key]);\n        }\n        if (required && !(key in context)) {\n            display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`);\n        }\n    }\n    return newContext;\n}\nexport function createContextManager(name = '', { customerDataTracker, 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                customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\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            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\n            changeObservable.notify();\n        },\n        removeContextProperty: (key) => {\n            delete context[key];\n            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\n            ensureProperties(context, propertiesConfig, name);\n            changeObservable.notify();\n        },\n        clearContext: () => {\n            context = {};\n            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.resetCustomerData();\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 { 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 { 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 { computeBytesCount } from './utils/byteUtils';\nexport function createIdentityEncoder() {\n    let output = '';\n    let outputBytesCount = 0;\n    return {\n        isAsync: false,\n        get isEmpty() {\n            return !output;\n        },\n        write(data, callback) {\n            const additionalEncodedBytesCount = computeBytesCount(data);\n            outputBytesCount += additionalEncodedBytesCount;\n            output += data;\n            if (callback) {\n                callback(additionalEncodedBytesCount);\n            }\n        },\n        finish(callback) {\n            callback(this.finishSync());\n        },\n        finishSync() {\n            const result = {\n                output,\n                outputBytesCount,\n                rawBytesCount: outputBytesCount,\n                pendingData: '',\n            };\n            output = '';\n            outputBytesCount = 0;\n            return result;\n        },\n        estimateEncodedBytesCount(data) {\n            return data.length;\n        },\n    };\n}\n//# sourceMappingURL=encoder.js.map","import { 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","/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder) {\n    return placeholder\n        ? // eslint-disable-next-line  no-bitwise\n            (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)\n        : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID);\n}\nconst COMMA_SEPARATED_KEY_VALUE = /([\\w-]+)\\s*=\\s*([^;]+)/g;\nexport function findCommaSeparatedValue(rawString, name) {\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    while (true) {\n        const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            if (match[1] === name) {\n                return match[2];\n            }\n        }\n        else {\n            break;\n        }\n    }\n}\nexport function findCommaSeparatedValues(rawString) {\n    const result = new Map();\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    while (true) {\n        const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            result.set(match[1], match[2]);\n        }\n        else {\n            break;\n        }\n    }\n    return result;\n}\nexport function safeTruncate(candidate, length, suffix = '') {\n    const lastChar = candidate.charCodeAt(length - 1);\n    const isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    const correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength) {\n        return candidate;\n    }\n    return `${candidate.slice(0, correctedLength)}${suffix}`;\n}\n//# sourceMappingURL=stringUtils.js.map","import { clocksNow, combine, elapsed, generateUUID, toServerDuration } from '@datadog/browser-core';\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, true));\n        }\n    }\n    return {\n        addDurationVital,\n        startDurationVital: (name, options = {}) => startDurationVital(customVitalsState, name, options),\n        stopDurationVital: (nameOrRef, options = {}) => {\n            stopDurationVital(addDurationVital, customVitalsState, nameOrRef, options);\n        },\n    };\n}\nexport function startDurationVital({ vitalsByName, vitalsByReference }, name, options = {}) {\n    const vital = {\n        name,\n        startClocks: clocksNow(),\n        context: options.context,\n        description: options.description,\n    };\n    // To avoid leaking implementation details of the vital, we return a reference to it.\n    const reference = { __dd_vital_reference: true };\n    vitalsByName.set(name, vital);\n    // To avoid memory leaks caused by the creation of numerous references (e.g., from improper useEffect implementations), we use a WeakMap.\n    vitalsByReference.set(reference, vital);\n    return reference;\n}\nexport function stopDurationVital(stopCallback, { vitalsByName, vitalsByReference }, nameOrRef, options = {}) {\n    const vitalStart = typeof nameOrRef === 'string' ? vitalsByName.get(nameOrRef) : vitalsByReference.get(nameOrRef);\n    if (!vitalStart) {\n        return;\n    }\n    stopCallback(buildDurationVital(vitalStart, vitalStart.startClocks, options, clocksNow()));\n    if (typeof nameOrRef === 'string') {\n        vitalsByName.delete(nameOrRef);\n    }\n    else {\n        vitalsByReference.delete(nameOrRef);\n    }\n}\nfunction buildDurationVital(vitalStart, startClocks, stopOptions, stopClocks) {\n    var _a;\n    return {\n        name: vitalStart.name,\n        type: \"duration\" /* VitalType.DURATION */,\n        startClocks,\n        duration: elapsed(startClocks.timeStamp, stopClocks.timeStamp),\n        context: combine(vitalStart.context, stopOptions.context),\n        description: (_a = stopOptions.description) !== null && _a !== void 0 ? _a : vitalStart.description,\n    };\n}\nfunction processVital(vital, valueComputedBySdk) {\n    const rawRumEvent = {\n        date: vital.startClocks.timeStamp,\n        vital: {\n            id: generateUUID(),\n            type: vital.type,\n            name: vital.name,\n            duration: toServerDuration(vital.duration),\n            description: vital.description,\n        },\n        type: \"vital\" /* RumEventType.VITAL */,\n    };\n    if (valueComputedBySdk) {\n        rawRumEvent._dd = {\n            vital: {\n                computed_value: true,\n            },\n        };\n    }\n    return {\n        rawRumEvent,\n        startTime: vital.startClocks.relative,\n        duration: vital.duration,\n        customerContext: vital.context,\n        domainContext: {},\n    };\n}\n//# sourceMappingURL=vitalCollection.js.map","export function callPluginsMethod(plugins, methodName, parameter) {\n    if (!plugins) {\n        return;\n    }\n    for (const plugin of plugins) {\n        const method = plugin[methodName];\n        if (method) {\n            method(parameter);\n        }\n    }\n}\n//# sourceMappingURL=plugins.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nlet fetchObservable;\nexport function initFetchObservable() {\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nexport function resetFetchObservable() {\n    fetchObservable = undefined;\n}\nfunction createFetchObservable() {\n    return new Observable((observable) => {\n        if (!window.fetch) {\n            return;\n        }\n        const { stop } = instrumentMethod(window, 'fetch', (call) => beforeSend(call, observable), {\n            computeHandlingStack: true,\n        });\n        return stop;\n    });\n}\nfunction beforeSend({ parameters, onPostCall, handlingStack }, observable) {\n    const [input, init] = parameters;\n    let methodFromParams = init && init.method;\n    if (methodFromParams === undefined && input instanceof Request) {\n        methodFromParams = input.method;\n    }\n    const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET';\n    const url = input instanceof Request ? input.url : normalizeUrl(String(input));\n    const startClocks = clocksNow();\n    const context = {\n        state: 'start',\n        init,\n        input,\n        method,\n        startClocks,\n        url,\n        handlingStack,\n    };\n    observable.notify(context);\n    // Those properties can be changed by observable subscribers\n    parameters[0] = context.input;\n    parameters[1] = context.init;\n    onPostCall((responsePromise) => afterSend(observable, responsePromise, context));\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    const context = startContext;\n    function reportFetch(partialContext) {\n        context.state = 'resolve';\n        Object.assign(context, partialContext);\n        observable.notify(context);\n    }\n    responsePromise.then(monitor((response) => {\n        reportFetch({\n            response,\n            responseType: response.type,\n            status: response.status,\n            isAborted: false,\n        });\n    }), monitor((error) => {\n        var _a, _b;\n        reportFetch({\n            status: 0,\n            isAborted: ((_b = (_a = context.init) === null || _a === void 0 ? void 0 : _a.signal) === null || _b === void 0 ? void 0 : _b.aborted) || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),\n            error,\n        });\n    }));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, findCommaSeparatedValues, generateUUID } from '../tools/utils/stringUtils';\nexport function setCookie(name, value, expireDelay = 0, options) {\n    const date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    const expires = `expires=${date.toUTCString()}`;\n    const sameSite = options && options.crossSite ? 'none' : 'strict';\n    const domain = options && options.domain ? `;domain=${options.domain}` : '';\n    const secure = options && options.secure ? ';secure' : '';\n    const partitioned = options && options.partitioned ? ';partitioned' : '';\n    document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`;\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nlet initCookieParsed;\n/**\n * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)\n * to avoid accessing document.cookie multiple times.\n */\nexport function getInitCookie(name) {\n    if (!initCookieParsed) {\n        initCookieParsed = findCommaSeparatedValues(document.cookie);\n    }\n    return initCookieParsed.get(name);\n}\nexport function resetInitCookies() {\n    initCookieParsed = undefined;\n}\nexport function deleteCookie(name, options) {\n    setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n    if (document.cookie === undefined || document.cookie === null) {\n        return false;\n    }\n    try {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        const testCookieName = `dd_cookie_test_${generateUUID()}`;\n        const testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n        const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n        deleteCookie(testCookieName, options);\n        return isCookieCorrectlySet;\n    }\n    catch (error) {\n        display.error(error);\n        return false;\n    }\n}\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nlet getCurrentSiteCache;\nexport function getCurrentSite() {\n    if (getCurrentSiteCache === undefined) {\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 = window.location.hostname.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    return getCurrentSiteCache;\n}\n//# sourceMappingURL=cookie.js.map","import { getInitCookie } from '../../browser/cookie';\nexport const SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    const value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    const value = window._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","export const SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils';\nexport const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\nexport const SESSION_COOKIE_EXPIRATION_DELAY = ONE_YEAR;\nexport const SessionPersistence = {\n    COOKIE: 'cookie',\n    LOCAL_STORAGE: 'local-storage',\n};\n//# sourceMappingURL=sessionConstants.js.map","export const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;\nexport const SESSION_ENTRY_SEPARATOR = '&';\nexport function isValidSessionString(sessionString) {\n    return (!!sessionString &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\n//# sourceMappingURL=sessionStateValidation.js.map","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation';\nexport const EXPIRED = '1';\nexport function getExpiredSessionState(previousSessionState, configuration) {\n    const expiredSessionState = {\n        isExpired: EXPIRED,\n    };\n    if (configuration.trackAnonymousUser) {\n        if (previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId) {\n            expiredSessionState.anonymousId = previousSessionState === null || previousSessionState === void 0 ? void 0 : previousSessionState.anonymousId;\n        }\n        else {\n            expiredSessionState.anonymousId = generateUUID();\n        }\n    }\n    return expiredSessionState;\n}\nexport function isSessionInNotStartedState(session) {\n    return isEmptyObject(session);\n}\nexport function isSessionStarted(session) {\n    return !isSessionInNotStartedState(session);\n}\nexport function isSessionInExpiredState(session) {\n    return session.isExpired !== undefined || !isActiveSession(session);\n}\n// An active session is a session in either `Tracked` or `NotTracked` state\nfunction isActiveSession(sessionState) {\n    // created and expire can be undefined for versions which was not storing them\n    // these checks could be removed when older versions will not be available/live anymore\n    return ((sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&\n        (sessionState.expire === undefined || dateNow() < Number(sessionState.expire)));\n}\nexport function expandSessionState(session) {\n    session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n    return (objectEntries(session)\n        // we use `aid` as a key for anonymousId\n        .map(([key, value]) => (key === 'anonymousId' ? `aid=${value}` : `${key}=${value}`))\n        .join(SESSION_ENTRY_SEPARATOR));\n}\nexport function toSessionState(sessionString) {\n    const session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach((entry) => {\n            const matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                const [, key, value] = matches;\n                if (key === 'aid') {\n                    // we use `aid` as a key for anonymousId\n                    session.anonymousId = value;\n                }\n                else {\n                    session[key] = value;\n                }\n            }\n        });\n    }\n    return session;\n}\n//# sourceMappingURL=sessionState.js.map","import { getInitCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionStarted } from './sessionState';\nexport const OLD_SESSION_COOKIE_NAME = '_dd';\nexport const OLD_RUM_COOKIE_NAME = '_dd_r';\nexport const OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport const RUM_SESSION_KEY = 'rum';\nexport const LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(cookieStoreStrategy) {\n    const sessionString = getInitCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME);\n        const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME);\n        const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME);\n        const session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        if (isSessionStarted(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { isChromium } from '../../../tools/utils/browserDetection';\nimport { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY, SessionPersistence, } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n    const cookieOptions = buildCookieOptions(initConfiguration);\n    return areCookiesAuthorized(cookieOptions) ? { type: SessionPersistence.COOKIE, cookieOptions } : 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: persistSessionCookie(cookieOptions),\n        retrieveSession: retrieveSessionCookie,\n        expireSession: (sessionState) => expireSessionCookie(cookieOptions, sessionState, configuration),\n    };\n    tryOldCookiesMigration(cookieStore);\n    return cookieStore;\n}\nfunction persistSessionCookie(options) {\n    return (session) => {\n        setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n    };\n}\nfunction expireSessionCookie(options, sessionState, configuration) {\n    const expiredSessionState = getExpiredSessionState(sessionState, configuration);\n    // we do not extend cookie expiration date\n    setCookie(SESSION_STORE_KEY, toSessionString(expiredSessionState), configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY, options);\n}\nfunction retrieveSessionCookie() {\n    const sessionString = getCookie(SESSION_STORE_KEY);\n    const sessionState = toSessionState(sessionString);\n    return sessionState;\n}\nexport function buildCookieOptions(initConfiguration) {\n    const cookieOptions = {};\n    cookieOptions.secure =\n        !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { SessionPersistence } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nconst LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n    try {\n        const id = generateUUID();\n        const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`;\n        localStorage.setItem(testKey, id);\n        const retrievedId = localStorage.getItem(testKey);\n        localStorage.removeItem(testKey);\n        return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined;\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy(configuration) {\n    return {\n        isLockEnabled: false,\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        expireSession: (sessionState) => expireSessionFromLocalStorage(sessionState, configuration),\n    };\n}\nfunction persistInLocalStorage(sessionState) {\n    localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n    const sessionString = localStorage.getItem(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction expireSessionFromLocalStorage(previousSessionState, configuration) {\n    persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration));\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport const LOCK_RETRY_DELAY = 10;\nexport const LOCK_MAX_TRIES = 100;\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 session = sessionStoreStrategy.retrieveSession();\n        const lock = session.lock;\n        if (session.lock) {\n            delete session.lock;\n        }\n        return {\n            session,\n            lock,\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 = generateUUID();\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}\n//# sourceMappingURL=sessionStoreOperations.js.map","import { clearInterval, setInterval } from '../../tools/timer';\nimport { Observable } from '../../tools/observable';\nimport { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { display } from '../../tools/display';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { getExpiredSessionState, isSessionInExpiredState, isSessionInNotStartedState, isSessionStarted, } from './sessionState';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\nimport { SessionPersistence } from './sessionConstants';\n/**\n * Every second, the storage will be polled to check for any change that can occur\n * to the session state in another browser tab, or another window.\n * This value has been determined from our previous cookie-only implementation.\n */\nexport const STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Selects the correct session store strategy type based on the configuration and storage\n * availability.\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    switch (initConfiguration.sessionPersistence) {\n        case SessionPersistence.COOKIE:\n            return selectCookieStrategy(initConfiguration);\n        case SessionPersistence.LOCAL_STORAGE:\n            return selectLocalStorageStrategy();\n        case undefined: {\n            let sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n            if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n                sessionStoreStrategyType = selectLocalStorageStrategy();\n            }\n            return sessionStoreStrategyType;\n        }\n        default:\n            display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`);\n    }\n}\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, computeSessionState) {\n    const renewObservable = new Observable();\n    const expireObservable = new Observable();\n    const sessionStateUpdateObservable = new Observable();\n    const sessionStoreStrategy = sessionStoreStrategyType.type === SessionPersistence.COOKIE\n        ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy(configuration);\n    const { expireSession } = sessionStoreStrategy;\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        processSessionStoreOperations({\n            process: (sessionState) => isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    function synchronizeSession(sessionState) {\n        if (isSessionInExpiredState(sessionState)) {\n            sessionState = getExpiredSessionState(sessionState, configuration);\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(sessionState)) {\n                expireSessionInCache();\n            }\n            else {\n                sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState });\n                sessionCache = sessionState;\n            }\n        }\n        return sessionState;\n    }\n    function startSession() {\n        processSessionStoreOperations({\n            process: (sessionState) => {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return getExpiredSessionState(sessionState, configuration);\n                }\n            },\n            after: (sessionState) => {\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\n    function expandOrRenewSessionState(sessionState) {\n        if (isSessionInNotStartedState(sessionState)) {\n            return false;\n        }\n        const { trackingType, isTracked } = computeSessionState(sessionState[productKey]);\n        sessionState[productKey] = trackingType;\n        delete sessionState.isExpired;\n        if (isTracked && !sessionState.id) {\n            sessionState.id = generateUUID();\n            sessionState.created = String(dateNow());\n        }\n    }\n    function hasSessionInCache() {\n        return sessionCache[productKey] !== undefined;\n    }\n    function isSessionInCacheOutdated(sessionState) {\n        return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];\n    }\n    function expireSessionInCache() {\n        sessionCache = getExpiredSessionState(sessionCache, configuration);\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function updateSessionState(partialSessionState) {\n        processSessionStoreOperations({\n            process: (sessionState) => ({ ...sessionState, ...partialSessionState }),\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    return {\n        expandOrRenewSession: throttledExpandOrRenewSession,\n        expandSession,\n        getSession: () => sessionCache,\n        renewObservable,\n        expireObservable,\n        sessionStateUpdateObservable,\n        restartSession: startSession,\n        expire: () => {\n            cancelExpandOrRenewSession();\n            expireSession(sessionCache);\n            synchronizeSession(getExpiredSessionState(sessionCache, configuration));\n        },\n        stop: () => {\n            clearInterval(watchSessionTimeoutId);\n        },\n        updateSessionState,\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_US1, INTAKE_SITE_FED_STAGING, PCI_INTAKE_HOST_US1 } from './intakeSites';\nexport function createEndpointBuilder(initConfiguration, trackType, configurationTags) {\n    const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType);\n    return {\n        build(api, payload) {\n            const parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\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 }, trackType, configurationTags, api, { retry, encoding }) {\n    const tags = [`sdk_version:${\"6.5.1\"}`, `api:${api}`].concat(configurationTags);\n    if (retry) {\n        tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`);\n    }\n    const parameters = [\n        'ddsource=browser',\n        `ddtags=${encodeURIComponent(tags.join(','))}`,\n        `dd-api-key=${clientToken}`,\n        `dd-evp-origin-version=${encodeURIComponent(\"6.5.1\")}`,\n        'dd-evp-origin=browser',\n        `dd-request-id=${generateUUID()}`,\n    ];\n    if (encoding) {\n        parameters.push(`dd-evp-encoding=${encoding}`);\n    }\n    if (trackType === 'rum') {\n        parameters.push(`batch_time=${timeStampNow()}`);\n    }\n    if (internalAnalyticsSubdomain) {\n        parameters.reverse();\n    }\n    return parameters.join('&');\n}\n//# sourceMappingURL=endpointBuilder.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 } = configuration;\n    const tags = [];\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    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 valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;\n    if (rawValue.length > valueSizeLimit || hasForbiddenCharacters(rawValue)) {\n        display.warn(`${key} value 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    const sanitizedValue = rawValue.replace(/,/g, '_');\n    return `${key}:${sanitizedValue}`;\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","import { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    const site = initConfiguration.site || INTAKE_SITE_US1;\n    const tags = buildTags(initConfiguration);\n    const endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    const replicaConfiguration = computeReplicaConfiguration(initConfiguration, tags);\n    return {\n        replica: replicaConfiguration,\n        site,\n        ...endpointBuilders,\n    };\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    return {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    const replicaConfiguration = {\n        ...initConfiguration,\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    };\n    const replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n    };\n    return { applicationId: initConfiguration.replica.applicationId, ...replicaEndpointBuilders };\n}\nexport function isIntakeUrl(url) {\n    // check if tags is present in the query string\n    return INTAKE_URL_PARAMETERS.every((param) => url.includes(param));\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display';\nimport { ONE_SECOND } from '../../tools/utils/timeUtils';\nimport { isPercentage } from '../../tools/utils/numberUtils';\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { objectHasValue } from '../../tools/utils/objectUtils';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { TrackingConsent } from '../trackingConsent';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport const DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\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) {\n    var _a, _b, _c, _d, _e, _f;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\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        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: 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: initConfiguration.service || undefined,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\n        allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,\n        trackingConsent: (_e = initConfiguration.trackingConsent) !== null && _e !== void 0 ? _e : TrackingConsent.GRANTED,\n        trackAnonymousUser: (_f = initConfiguration.trackAnonymousUser) !== null && _f !== void 0 ? _f : true,\n        storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,\n        /**\n         * beacon payload max queue size implementation is 64kb\n         * ensure that we leave room for logs, rum and potential other users\n         */\n        batchBytesLimit: 16 * ONE_KIBI_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxTelemetryEventsPerPage: 15,\n        /**\n         * flush automatically, aim to be lower than ALB connection timeout\n         * to maximize connection reuse.\n         */\n        flushTimeout: (30 * ONE_SECOND),\n        /**\n         * Logs intake limit\n         */\n        batchMessagesLimit: 50,\n        messageBytesLimit: 256 * ONE_KIBI_BYTE,\n        ...computeTransportConfiguration(initConfiguration),\n    };\n}\nexport function serializeConfiguration(initConfiguration) {\n    return {\n        session_sample_rate: initConfiguration.sessionSampleRate,\n        telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n        telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,\n        use_before_send: !!initConfiguration.beforeSend,\n        use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,\n        use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n        use_proxy: !!initConfiguration.proxy,\n        silent_multiple_init: initConfiguration.silentMultipleInit,\n        track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n        track_anonymous_user: initConfiguration.trackAnonymousUser,\n        session_persistence: initConfiguration.sessionPersistence,\n        allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,\n        store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,\n        allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,\n        tracking_consent: initConfiguration.trackingConsent,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { display } from './display';\nimport { getType } from './utils/typeUtils';\nexport function isMatchOption(item) {\n    const itemType = getType(item);\n    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;\n}\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list, value, useStartsWith = false) {\n    return list.some((item) => {\n        try {\n            if (typeof item === 'function') {\n                return item(value);\n            }\n            else if (item instanceof RegExp) {\n                return item.test(value);\n            }\n            else if (typeof item === 'string') {\n                return useStartsWith ? value.startsWith(item) : item === value;\n            }\n        }\n        catch (e) {\n            display.error(e);\n        }\n        return false;\n    });\n}\n//# sourceMappingURL=matchOption.js.map","export 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 { performDraw } from '@datadog/browser-core';\nlet sampleDecisionCache;\nexport function isTraceSampled(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    if (sampleDecisionCache && sessionId === sampleDecisionCache.sessionId) {\n        return sampleDecisionCache.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 = { sessionId, decision };\n    return decision;\n}\n// Exported for tests\nexport function resetSampleDecisionCache() {\n    sampleDecisionCache = undefined;\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","import { objectEntries, shallowClone, getType, isMatchOption, matchList, TraceContextInjection, } from '@datadog/browser-core';\nimport { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier';\nimport { isTraceSampled } from './sampler';\nexport function isTracingOption(item) {\n    const expectedItem = item;\n    return (getType(expectedItem) === 'object' &&\n        isMatchOption(expectedItem.match) &&\n        Array.isArray(expectedItem.propagatorTypes));\n}\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course, it might not be the case every time, but it should limit having incomplete traces a\n * bit.\n * */\nexport function clearTracingIfNeeded(context) {\n    if (context.status === 0 && !context.isAborted) {\n        context.traceId = undefined;\n        context.spanId = undefined;\n        context.traceSampled = undefined;\n    }\n}\nexport function startTracer(configuration, sessionManager) {\n    return {\n        clearTracingIfNeeded,\n        traceFetch: (context) => injectHeadersIfTracingAllowed(configuration, context, sessionManager, (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, (tracingHeaders) => {\n            Object.keys(tracingHeaders).forEach((name) => {\n                xhr.setRequestHeader(name, tracingHeaders[name]);\n            });\n        }),\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, 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 = isTraceSampled(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, tracingOption.propagatorTypes));\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, propagatorTypes) {\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    return tracingHeaders;\n}\n//# sourceMappingURL=tracer.js.map","import { getType, isMatchOption, serializeConfiguration, DefaultPrivacyLevel, TraceContextInjection, display, objectHasValue, validateAndBuildConfiguration, isSampleRate, isNumber, } from '@datadog/browser-core';\nimport { isTracingOption } from '../tracing/tracer';\nexport const DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'datadog'];\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e, _f;\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);\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        version: initConfiguration.version || undefined,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate,\n        startSessionReplayRecordingManually: initConfiguration.startSessionReplayRecordingManually !== undefined\n            ? !!initConfiguration.startSessionReplayRecordingManually\n            : sessionReplaySampleRate === 0,\n        traceSampleRate: (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : 100,\n        rulePsr: isNumber(initConfiguration.traceSampleRate) ? initConfiguration.traceSampleRate / 100 : undefined,\n        allowedTracingUrls,\n        excludedActivityUrls: (_c = initConfiguration.excludedActivityUrls) !== null && _c !== void 0 ? _c : [],\n        workerUrl: initConfiguration.workerUrl,\n        compressIntakeRequests: !!initConfiguration.compressIntakeRequests,\n        trackUserInteractions: !!((_d = initConfiguration.trackUserInteractions) !== null && _d !== void 0 ? _d : true),\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: !!((_e = initConfiguration.trackResources) !== null && _e !== void 0 ? _e : true),\n        trackLongTasks: !!((_f = initConfiguration.trackLongTasks) !== null && _f !== void 0 ? _f : true),\n        subdomain: initConfiguration.subdomain,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK,\n        enablePrivacyForActionName: !!initConfiguration.enablePrivacyForActionName,\n        customerDataTelemetrySampleRate: 1,\n        traceContextInjection: objectHasValue(TraceContextInjection, initConfiguration.traceContextInjection)\n            ? initConfiguration.traceContextInjection\n            : TraceContextInjection.SAMPLED,\n        plugins: initConfiguration.plugins || [],\n        trackFeatureFlagsForEvents: initConfiguration.trackFeatureFlagsForEvents || [],\n        ...baseConfiguration,\n    };\n}\n/**\n * Validates allowedTracingUrls and converts match options to tracing options\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    if (initConfiguration.allowedTracingUrls === undefined) {\n        return [];\n    }\n    if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n        display.error('Allowed Tracing URLs should be an array');\n        return;\n    }\n    if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n        display.error('Service needs to be configured when tracing is enabled');\n        return;\n    }\n    // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n    const tracingOptions = [];\n    initConfiguration.allowedTracingUrls.forEach((option) => {\n        if (isMatchOption(option)) {\n            tracingOptions.push({ match: option, propagatorTypes: DEFAULT_PROPAGATOR_TYPES });\n        }\n        else if (isTracingOption(option)) {\n            tracingOptions.push(option);\n        }\n        else {\n            display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);\n        }\n    });\n    return tracingOptions;\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls\n */\nfunction getSelectedTracingPropagators(configuration) {\n    const usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach((option) => {\n            if (isMatchOption(option)) {\n                DEFAULT_PROPAGATOR_TYPES.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));\n            }\n            else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n                option.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));\n            }\n        });\n    }\n    return Array.from(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a;\n    const baseSerializedConfiguration = serializeConfiguration(configuration);\n    return {\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n        trace_sample_rate: configuration.traceSampleRate,\n        trace_context_injection: configuration.traceContextInjection,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_urls: Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\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: Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\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        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        ...baseSerializedConfiguration,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { display, addEventListener, buildEndpointHost } from '@datadog/browser-core';\nconst REMOTE_CONFIGURATION_VERSION = 'v1';\nexport function fetchAndApplyRemoteConfiguration(initConfiguration, callback) {\n    fetchRemoteConfiguration(initConfiguration, (remoteInitConfiguration) => {\n        callback(applyRemoteConfiguration(initConfiguration, remoteInitConfiguration));\n    });\n}\nexport function applyRemoteConfiguration(initConfiguration, remoteInitConfiguration) {\n    return { ...initConfiguration, ...remoteInitConfiguration };\n}\nexport function fetchRemoteConfiguration(configuration, callback) {\n    const xhr = new XMLHttpRequest();\n    addEventListener(configuration, xhr, 'load', function () {\n        if (xhr.status === 200) {\n            const remoteConfiguration = JSON.parse(xhr.responseText);\n            callback(remoteConfiguration.rum);\n        }\n        else {\n            displayRemoteConfigurationFetchingError();\n        }\n    });\n    addEventListener(configuration, xhr, 'error', function () {\n        displayRemoteConfigurationFetchingError();\n    });\n    xhr.open('GET', buildEndpoint(configuration));\n    xhr.send();\n}\nexport function buildEndpoint(configuration) {\n    return `https://sdk-configuration.${buildEndpointHost('rum', configuration)}/${REMOTE_CONFIGURATION_VERSION}/${encodeURIComponent(configuration.remoteConfigurationId)}.json`;\n}\nfunction displayRemoteConfigurationFetchingError() {\n    display.error('Error fetching the remote configuration.');\n}\n//# sourceMappingURL=remoteConfiguration.js.map","import { createBoundedBuffer, display, canUseEventBridge, displayAlreadyInitializedError, willSyntheticsInjectRum, noop, timeStampNow, clocksNow, getEventBridge, initFeatureFlags, addTelemetryConfiguration, initFetchObservable, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration, } from '../domain/configuration';\nimport { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection';\nimport { fetchAndApplyRemoteConfiguration, serializeRumConfiguration } from '../domain/configuration';\nimport { callPluginsMethod } from '../domain/plugins';\nexport function createPreStartStrategy({ ignoreInitIfSyntheticsWillInjectRum, startDeflateWorker }, getCommonContext, trackingConsentState, customVitalsState, doStartRum) {\n    const bufferApiCalls = createBoundedBuffer();\n    let firstStartViewCall;\n    let deflateWorker;\n    let cachedInitConfiguration;\n    let cachedConfiguration;\n    const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);\n    const emptyContext = {};\n    function tryStartRum() {\n        if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        trackingConsentStateSubscription.unsubscribe();\n        let initialViewOptions;\n        if (cachedConfiguration.trackViewsManually) {\n            if (!firstStartViewCall) {\n                return;\n            }\n            // An initial view is always created when starting RUM.\n            // When tracking views automatically, any startView call before RUM start creates an extra\n            // view.\n            // When tracking views manually, we use the ViewOptions from the first startView call as the\n            // initial view options, and we remove the actual startView call so we don't create an extra\n            // view.\n            bufferApiCalls.remove(firstStartViewCall.callback);\n            initialViewOptions = firstStartViewCall.options;\n        }\n        const startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions);\n        bufferApiCalls.drain(startRumResult);\n    }\n    function doInit(initConfiguration) {\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);\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        // Instrumuent fetch to track network requests\n        // This is needed in case the consent is not granted and some cutsomer\n        // library (Apollo Client) is storing uninstrumented fetch to be used later\n        // The subscrption 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 strategy = {\n        init(initConfiguration, publicApi) {\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, doInit);\n            }\n            else {\n                doInit(initConfiguration);\n            }\n        },\n        get initConfiguration() {\n            return cachedInitConfiguration;\n        },\n        getInternalContext: noop,\n        stopSession: noop,\n        addTiming(name, time = timeStampNow()) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addTiming(name, time));\n        },\n        startView(options, startClocks = clocksNow()) {\n            const callback = (startRumResult) => {\n                startRumResult.startView(options, startClocks);\n            };\n            bufferApiCalls.add(callback);\n            if (!firstStartViewCall) {\n                firstStartViewCall = { options, callback };\n                tryStartRum();\n            }\n        },\n        setViewName(name) {\n            bufferApiCalls.add((startRumResult) => startRumResult.setViewName(name));\n        },\n        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        addAction(action, commonContext = getCommonContext()) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addAction(action, commonContext));\n        },\n        addError(providedError, commonContext = getCommonContext()) {\n            bufferApiCalls.add((startRumResult) => startRumResult.addError(providedError, commonContext));\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    };\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}\n//# sourceMappingURL=preStartRum.js.map","import { addTelemetryUsage, createContextManager, deepClone, makePublicApi, monitor, clocksNow, callMonitored, createHandlingStack, sanitize, createIdentityEncoder, createCustomerDataTrackerManager, storeContextManager, displayAlreadyInitializedError, createTrackingConsentState, timeStampToClocks, } from '@datadog/browser-core';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nimport { createCustomVitalsState } from '../domain/vital/vitalCollection';\nimport { callPluginsMethod } from '../domain/plugins';\nimport { createPreStartStrategy } from './preStartRum';\nconst RUM_STORAGE_KEY = 'rum';\nexport function makeRumPublicApi(startRumImpl, recorderApi, options = {}) {\n    const customerDataTrackerManager = createCustomerDataTrackerManager(0 /* CustomerDataCompressionStatus.Unknown */);\n    const globalContextManager = createContextManager('global context', {\n        customerDataTracker: customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */),\n    });\n    const userContextManager = createContextManager('user', {\n        customerDataTracker: customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */),\n        propertiesConfig: {\n            id: { type: 'string' },\n            name: { type: 'string' },\n            email: { type: 'string' },\n        },\n    });\n    const accountContextManager = createContextManager('account', {\n        customerDataTracker: customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */),\n        propertiesConfig: {\n            id: { type: 'string', required: true },\n            name: { type: 'string' },\n        },\n    });\n    const trackingConsentState = createTrackingConsentState();\n    const customVitalsState = createCustomVitalsState();\n    function getCommonContext() {\n        return buildCommonContext(globalContextManager, userContextManager, accountContextManager, recorderApi);\n    }\n    let strategy = createPreStartStrategy(options, getCommonContext, trackingConsentState, customVitalsState, (configuration, deflateWorker, initialViewOptions) => {\n        if (configuration.storeContextsAcrossPages) {\n            storeContextManager(configuration, globalContextManager, RUM_STORAGE_KEY, 2 /* CustomerDataType.GlobalContext */);\n            storeContextManager(configuration, userContextManager, RUM_STORAGE_KEY, 1 /* CustomerDataType.User */);\n            storeContextManager(configuration, accountContextManager, RUM_STORAGE_KEY, 4 /* CustomerDataType.Account */);\n        }\n        customerDataTrackerManager.setCompressionStatus(deflateWorker ? 1 /* CustomerDataCompressionStatus.Enabled */ : 2 /* CustomerDataCompressionStatus.Disabled */);\n        const startRumResult = startRumImpl(configuration, recorderApi, customerDataTrackerManager, getCommonContext, initialViewOptions, deflateWorker && options.createDeflateEncoder\n            ? (streamId) => options.createDeflateEncoder(configuration, deflateWorker, streamId)\n            : createIdentityEncoder, trackingConsentState, customVitalsState);\n        recorderApi.onRumStart(startRumResult.lifeCycle, configuration, startRumResult.session, startRumResult.viewHistory, deflateWorker);\n        strategy = createPostStartStrategy(strategy, startRumResult);\n        callPluginsMethod(configuration.plugins, 'onRumStart', { strategy });\n        return startRumResult;\n    });\n    const startView = monitor((options) => {\n        const sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        if (sanitizedOptions.context) {\n            customerDataTrackerManager.getOrCreateTracker(3 /* CustomerDataType.View */).updateCustomerData(sanitizedOptions.context);\n        }\n        strategy.startView(sanitizedOptions);\n        addTelemetryUsage({ feature: 'start-view' });\n    });\n    const rumPublicApi = makePublicApi({\n        init: monitor((initConfiguration) => {\n            strategy.init(initConfiguration, rumPublicApi);\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        setGlobalContext: monitor((context) => {\n            globalContextManager.setContext(context);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        getGlobalContext: monitor(() => globalContextManager.getContext()),\n        setGlobalContextProperty: monitor((key, value) => {\n            globalContextManager.setContextProperty(key, value);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        removeGlobalContextProperty: monitor((key) => globalContextManager.removeContextProperty(key)),\n        clearGlobalContext: monitor(() => globalContextManager.clearContext()),\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: \"custom\" /* ActionType.CUSTOM */,\n                    handlingStack,\n                });\n                addTelemetryUsage({ feature: 'add-action' });\n            });\n        },\n        addError: (error, context) => {\n            const handlingStack = createHandlingStack('error');\n            callMonitored(() => {\n                strategy.addError({\n                    error, // Do not sanitize error here, it is needed unserialized by computeRawError()\n                    handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n                addTelemetryUsage({ feature: 'add-error' });\n            });\n        },\n        addTiming: monitor((name, time) => {\n            // TODO: next major decide to drop relative time support or update its behaviour\n            strategy.addTiming(sanitize(name), time);\n        }),\n        setUser: monitor((newUser) => {\n            userContextManager.setContext(newUser);\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        getUser: monitor(userContextManager.getContext),\n        setUserProperty: monitor((key, property) => {\n            userContextManager.setContextProperty(key, property);\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        removeUserProperty: monitor(userContextManager.removeContextProperty),\n        clearUser: monitor(userContextManager.clearContext),\n        setAccount: monitor(accountContextManager.setContext),\n        getAccount: monitor(accountContextManager.getContext),\n        setAccountProperty: monitor(accountContextManager.setContextProperty),\n        removeAccountProperty: monitor(accountContextManager.removeContextProperty),\n        clearAccount: monitor(accountContextManager.clearContext),\n        startView,\n        stopSession: monitor(() => {\n            strategy.stopSession();\n            addTelemetryUsage({ feature: 'stop-session' });\n        }),\n        addFeatureFlagEvaluation: monitor((key, value) => {\n            strategy.addFeatureFlagEvaluation(sanitize(key), sanitize(value));\n            addTelemetryUsage({ feature: 'add-feature-flag-evaluation' });\n        }),\n        getSessionReplayLink: monitor(() => recorderApi.getSessionReplayLink()),\n        startSessionReplayRecording: monitor((options) => {\n            recorderApi.start(options);\n            addTelemetryUsage({ feature: 'start-session-replay-recording', force: options && options.force });\n        }),\n        stopSessionReplayRecording: monitor(() => recorderApi.stop()),\n        addDurationVital: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'add-duration-vital' });\n            strategy.addDurationVital({\n                name: sanitize(name),\n                type: \"duration\" /* VitalType.DURATION */,\n                startClocks: timeStampToClocks(options.startTime),\n                duration: options.duration,\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n        startDurationVital: monitor((name, options) => {\n            addTelemetryUsage({ feature: 'start-duration-vital' });\n            return strategy.startDurationVital(sanitize(name), {\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n        stopDurationVital: monitor((nameOrRef, options) => {\n            addTelemetryUsage({ feature: 'stop-duration-vital' });\n            strategy.stopDurationVital(typeof nameOrRef === 'string' ? sanitize(nameOrRef) : nameOrRef, {\n                context: sanitize(options && options.context),\n                description: sanitize(options && options.description),\n            });\n        }),\n    });\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","export function buildCommonContext(globalContextManager, userContextManager, accountContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        account: accountContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.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(() => observable.notify()));\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 { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    let eventCount = 0;\n    let allowNextEvent = false;\n    return {\n        isLimitReached() {\n            if (eventCount === 0) {\n                setTimeout(() => {\n                    eventCount = 0;\n                }, ONE_MINUTE);\n            }\n            eventCount += 1;\n            if (eventCount <= limit || allowNextEvent) {\n                allowNextEvent = false;\n                return false;\n            }\n            if (eventCount === limit + 1) {\n                allowNextEvent = true;\n                try {\n                    onLimitReached({\n                        message: `Reached max number of ${eventType}s by minute: ${limit}`,\n                        source: ErrorSource.AGENT,\n                        startClocks: clocksNow(),\n                    });\n                }\n                finally {\n                    allowNextEvent = false;\n                }\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=createEventRateLimiter.js.map","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core';\n/**\n * Allows declaring and enforcing modifications to specific fields of an object.\n * Only supports modifying properties of an object (even if nested in an array).\n * Does not support array manipulation (adding/removing items).\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    const clone = deepClone(object);\n    const result = modifier(clone);\n    objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => \n    // Traverse both object and clone simultaneously up to the path and apply the modification from the clone to the original object when the type is valid\n    setValueAtPath(object, clone, fieldPath.split(/\\.|(?=\\[\\])/), fieldType));\n    return result;\n}\nfunction setValueAtPath(object, clone, pathSegments, fieldType) {\n    const [field, ...restPathSegments] = pathSegments;\n    if (field === '[]') {\n        if (Array.isArray(object) && Array.isArray(clone)) {\n            object.forEach((item, i) => setValueAtPath(item, clone[i], restPathSegments, fieldType));\n        }\n        return;\n    }\n    if (!isValidObject(object) || !isValidObject(clone)) {\n        return;\n    }\n    if (restPathSegments.length > 0) {\n        return setValueAtPath(object[field], clone[field], restPathSegments, fieldType);\n    }\n    setNestedValue(object, field, clone[field], fieldType);\n}\nfunction setNestedValue(object, field, value, fieldType) {\n    const newType = getType(value);\n    if (newType === fieldType) {\n        object[field] = sanitize(value);\n    }\n    else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n        object[field] = {};\n    }\n}\nfunction isValidObject(object) {\n    return getType(object) === 'object';\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, round, isExperimentalFeatureEnabled, ExperimentalFeature, getConnectivity, addTelemetryDebug, } from '@datadog/browser-core';\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, sessionManager, viewHistory, urlContexts, displayContext, getCommonContext, reportError) {\n    modifiableFieldPathsByEvent = {\n        [\"view\" /* RumEventType.VIEW */]: {\n            'view.performance.lcp.resource_url': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n        },\n        [\"error\" /* RumEventType.ERROR */]: {\n            'error.message': 'string',\n            'error.stack': 'string',\n            'error.resource.url': 'string',\n            'error.fingerprint': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [\"resource\" /* RumEventType.RESOURCE */]: {\n            'resource.url': 'string',\n            ...(isExperimentalFeatureEnabled(ExperimentalFeature.WRITABLE_RESOURCE_GRAPHQL)\n                ? { 'resource.graphql': 'object' }\n                : {}),\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [\"action\" /* RumEventType.ACTION */]: {\n            'action.target.name': 'string',\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n            ...ROOT_MODIFIABLE_FIELD_PATHS,\n        },\n        [\"long_task\" /* 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        },\n        [\"vital\" /* RumEventType.VITAL */]: {\n            ...USER_CUSTOMIZABLE_FIELD_PATHS,\n            ...VIEW_MODIFIABLE_FIELD_PATHS,\n        },\n    };\n    const eventRateLimiters = {\n        [\"error\" /* RumEventType.ERROR */]: createEventRateLimiter(\"error\" /* RumEventType.ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        [\"action\" /* RumEventType.ACTION */]: createEventRateLimiter(\"action\" /* RumEventType.ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        [\"vital\" /* RumEventType.VITAL */]: createEventRateLimiter(\"vital\" /* RumEventType.VITAL */, configuration.eventRateLimiterThreshold, reportError),\n    };\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, ({ startTime, duration, rawRumEvent, domainContext, savedCommonContext, customerContext }) => {\n        const viewHistoryEntry = viewHistory.findView(startTime);\n        const urlContext = urlContexts.findUrl(startTime);\n        const session = sessionManager.findTrackedSession(startTime);\n        if (session &&\n            viewHistoryEntry &&\n            !urlContext &&\n            isExperimentalFeatureEnabled(ExperimentalFeature.MISSING_URL_CONTEXT_TELEMETRY)) {\n            addTelemetryDebug('Missing URL entry', {\n                debug: {\n                    eventType: rawRumEvent.type,\n                    startTime,\n                    urlEntries: urlContexts.getAllEntries(),\n                    urlDeletedEntries: urlContexts.getDeletedEntries(),\n                    viewEntries: viewHistory.getAllEntries(),\n                    viewDeletedEntries: viewHistory.getDeletedEntries(),\n                },\n            });\n        }\n        if (session && viewHistoryEntry && urlContext) {\n            const commonContext = savedCommonContext || getCommonContext();\n            const rumContext = {\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                    },\n                    browser_sdk_version: canUseEventBridge() ? \"6.5.1\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: \"user\" /* SessionType.USER */,\n                },\n                display: displayContext.get(),\n                connectivity: getConnectivity(),\n                context: commonContext.context,\n            };\n            const serverRumEvent = combine(rumContext, hooks.triggerHook(0 /* HookNames.Assemble */, {\n                eventType: rawRumEvent.type,\n                startTime,\n                duration,\n            }), { context: customerContext }, rawRumEvent);\n            if (!('has_replay' in serverRumEvent.session)) {\n                ;\n                serverRumEvent.session.has_replay = commonContext.hasReplay;\n            }\n            if (serverRumEvent.type === 'view') {\n                ;\n                serverRumEvent.session.sampled_for_replay =\n                    session.sessionReplay === 1 /* SessionReplayState.SAMPLED */;\n            }\n            if (session.anonymousId && !commonContext.user.anonymous_id && !!configuration.trackAnonymousUser) {\n                commonContext.user.anonymous_id = session.anonymousId;\n            }\n            if (!isEmptyObject(commonContext.user)) {\n                ;\n                serverRumEvent.usr = commonContext.user;\n            }\n            if (!isEmptyObject(commonContext.account) && commonContext.account.id) {\n                ;\n                serverRumEvent.account = commonContext.account;\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    });\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 !== \"view\" /* 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 { AbstractLifeCycle } from '@datadog/browser-core';\nexport const LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","// eslint-disable-next-line no-restricted-syntax\nexport class AbstractLifeCycle {\n    constructor() {\n        this.callbacks = {};\n    }\n    notify(eventType, data) {\n        const eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach((callback) => callback(data));\n        }\n    }\n    subscribe(eventType, callback) {\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: () => {\n                this.callbacks[eventType] = this.callbacks[eventType].filter((other) => callback !== other);\n            },\n        };\n    }\n}\n//# sourceMappingURL=abstractLifeCycle.js.map","import { setInterval, clearInterval } from './timer';\nimport { removeItem } from './utils/arrayUtils';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nconst END_OF_TIMES = Infinity;\nexport const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\nlet cleanupHistoriesInterval = null;\nconst cleanupTasks = new Set();\nfunction cleanupHistories() {\n    cleanupTasks.forEach((task) => task());\n}\nexport function createValueHistory({ expireDelay, maxEntries, }) {\n    let entries = [];\n    const deletedEntries = [];\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            const entry = entries.pop();\n            if (entry) {\n                deletedEntries.push(entry.startTime);\n            }\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    function getAllEntries() {\n        return entries.map(({ startTime, endTime, value }) => ({\n            startTime,\n            endTime: endTime === END_OF_TIMES ? 'Infinity' : endTime,\n            value,\n        }));\n    }\n    function getDeletedEntries() {\n        return deletedEntries;\n    }\n    /**\n     * Remove all entries from this collection.\n     */\n    function reset() {\n        entries = [];\n    }\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    function stop() {\n        cleanupTasks.delete(clearExpiredValues);\n        if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {\n            clearInterval(cleanupHistoriesInterval);\n            cleanupHistoriesInterval = null;\n        }\n    }\n    return { add, find, closeActive, findAll, reset, stop, getAllEntries, getDeletedEntries };\n}\n//# sourceMappingURL=valueHistory.js.map","import { SESSION_TIME_OUT_DELAY, createValueHistory } from '@datadog/browser-core';\nexport const VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewHistory(lifeCycle) {\n    const viewValueHistory = createValueHistory({ expireDelay: VIEW_CONTEXT_TIME_OUT_DELAY });\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, (view) => {\n        viewValueHistory.add(buildViewHistoryEntry(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, ({ endClocks }) => {\n        viewValueHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(3 /* LifeCycleEventType.BEFORE_VIEW_UPDATED */, (viewUpdate) => {\n        const currentView = viewValueHistory.find(viewUpdate.startClocks.relative);\n        if (currentView && viewUpdate.name) {\n            currentView.name = viewUpdate.name;\n        }\n        if (currentView && viewUpdate.context) {\n            currentView.context = viewUpdate.context;\n        }\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        getAllEntries: () => viewValueHistory.getAllEntries(),\n        getDeletedEntries: () => viewValueHistory.getDeletedEntries(),\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, 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    let hasBeenReported = false;\n    const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {\n        if (xhr.readyState === XMLHttpRequest.DONE) {\n            // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n            // application during a future event. For example, Angular is calling .abort() on\n            // completed requests during an onreadystatechange event, so the status becomes '0'\n            // before the request is collected.\n            onEnd();\n        }\n    });\n    const onEnd = () => {\n        unsubscribeLoadEndListener();\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        const completeContext = context;\n        completeContext.state = 'complete';\n        completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n        completeContext.status = xhr.status;\n        observable.notify(shallowClone(completeContext));\n    };\n    const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd);\n    observable.notify(startContext);\n}\nfunction abortXhr({ target: xhr }) {\n    const context = xhrContexts.get(xhr);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { addTelemetryDebug, elapsed, getPathName, isValidUrl, toServerDuration, isIntakeUrl, } from '@datadog/browser-core';\nexport const FAKE_INITIAL_DOCUMENT = 'initial_document';\nconst RESOURCE_TYPES = [\n    [\"document\" /* ResourceType.DOCUMENT */, (initiatorType) => FAKE_INITIAL_DOCUMENT === initiatorType],\n    [\"xhr\" /* ResourceType.XHR */, (initiatorType) => 'xmlhttprequest' === initiatorType],\n    [\"fetch\" /* ResourceType.FETCH */, (initiatorType) => 'fetch' === initiatorType],\n    [\"beacon\" /* ResourceType.BEACON */, (initiatorType) => 'beacon' === initiatorType],\n    [\"css\" /* ResourceType.CSS */, (_, path) => /\\.css$/i.test(path)],\n    [\"js\" /* ResourceType.JS */, (_, path) => /\\.js$/i.test(path)],\n    [\n        \"image\" /* ResourceType.IMAGE */,\n        (initiatorType, path) => ['image', 'img', 'icon'].includes(initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null,\n    ],\n    [\"font\" /* ResourceType.FONT */, (_, path) => /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],\n    [\n        \"media\" /* 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        addTelemetryDebug(`Failed to construct URL for \"${entry.name}\"`);\n        return \"other\" /* 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 \"other\" /* 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);\n}\nconst DATA_URL_REGEX = /data:(.+)?(;base64)?,/g;\nexport const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 24000;\nexport function isLongDataUrl(url) {\n    if (url.length <= MAX_ATTRIBUTE_VALUE_CHAR_LENGTH) {\n        return false;\n    }\n    else if (url.substring(0, 5) === 'data:') {\n        // Avoid String.match RangeError: Maximum call stack size exceeded\n        url = url.substring(0, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH);\n        return true;\n    }\n    return false;\n}\nexport function sanitizeDataUrl(url) {\n    return `${url.match(DATA_URL_REGEX)[0]}[...]`;\n}\n//# sourceMappingURL=resourceUtils.js.map","import { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nlet nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    const tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    const subscription = initXhrObservable(configuration).subscribe((rawContext) => {\n        const context = rawContext;\n        if (!isAllowedRequestUrl(context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceXhr(context, context.xhr);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    traceSampled: context.traceSampled,\n                    type: \"xhr\" /* RequestType.XHR */,\n                    url: context.url,\n                    xhr: context.xhr,\n                    isAborted: context.isAborted,\n                    handlingStack: context.handlingStack,\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nexport function trackFetch(lifeCycle, tracer) {\n    const subscription = initFetchObservable().subscribe((rawContext) => {\n        const context = rawContext;\n        if (!isAllowedRequestUrl(context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, (duration) => {\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration,\n                        method: context.method,\n                        requestIndex: context.requestIndex,\n                        responseType: context.responseType,\n                        spanId: context.spanId,\n                        startClocks: context.startClocks,\n                        status: context.status,\n                        traceId: context.traceId,\n                        traceSampled: context.traceSampled,\n                        type: \"fetch\" /* RequestType.FETCH */,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                        isAborted: context.isAborted,\n                        handlingStack: context.handlingStack,\n                    });\n                });\n                break;\n        }\n    });\n    return { stop: () => subscription.unsubscribe() };\n}\nfunction getNextRequestIndex() {\n    const result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\nfunction waitForResponseToComplete(context, callback) {\n    const clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, () => {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","import { monitor } from './monitor';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n    const reader = stream.getReader();\n    const chunks = [];\n    let readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor((result) => {\n            if (result.done) {\n                onDone();\n                return;\n            }\n            if (options.collectStreamBody) {\n                chunks.push(result.value);\n            }\n            readBytesCount += result.value.length;\n            if (readBytesCount > options.bytesLimit) {\n                onDone();\n            }\n            else {\n                readMore();\n            }\n        }), monitor((error) => callback(error)));\n    }\n    function onDone() {\n        reader.cancel().catch(\n        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n        // as an unhandled rejection\n        noop);\n        let bytes;\n        let limitExceeded;\n        if (options.collectStreamBody) {\n            let completeBuffer;\n            if (chunks.length === 1) {\n                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n                // use it directly.\n                completeBuffer = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer = new Uint8Array(readBytesCount);\n                let offset = 0;\n                chunks.forEach((chunk) => {\n                    completeBuffer.set(chunk, offset);\n                    offset += chunk.length;\n                });\n            }\n            bytes = completeBuffer.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer.length > options.bytesLimit;\n        }\n        callback(undefined, bytes, limitExceeded);\n    }\n}\n//# sourceMappingURL=readBytesFromStream.js.map","import { isNumber } from '@datadog/browser-core';\nexport function discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=discardNegativeDuration.js.map","import { noop } from '@datadog/browser-core';\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 \"error\" /* RumEventType.ERROR */:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case \"action\" /* 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 \"long_task\" /* RumEventType.LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case \"resource\" /* RumEventType.RESOURCE */:\n                if (!((_a = event._dd) === null || _a === void 0 ? void 0 : _a.discarded)) {\n                    eventCounts.resourceCount += 1;\n                    callback();\n                }\n                break;\n        }\n    });\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n        eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { addEventListeners, dateNow, relativeNow } from '@datadog/browser-core';\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nexport function retrieveFirstInputTiming(configuration, callback) {\n    const startTimeStamp = dateNow();\n    let timingSent = false;\n    const { stop: removeEventListeners } = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"mousedown\" /* DOM_EVENT.MOUSE_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */], (evt) => {\n        // Only count cancelable events, which should trigger behavior important to the user.\n        if (!evt.cancelable) {\n            return;\n        }\n        // This timing will be used to compute the \"first Input delay\", which is the delta between\n        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n        // (e.g. performance.now()).\n        const timing = {\n            entryType: 'first-input',\n            processingStart: relativeNow(),\n            processingEnd: relativeNow(),\n            startTime: evt.timeStamp,\n            duration: 0, // arbitrary value to avoid nullable duration and simplify INP logic\n            name: '',\n            cancelable: false,\n            target: null,\n            toJSON: () => ({}),\n        };\n        if (evt.type === \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(configuration, timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true });\n    return { stop: removeEventListeners };\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(configuration, timing) {\n        addEventListeners(configuration, window, [\"pointerup\" /* DOM_EVENT.POINTER_UP */, \"pointercancel\" /* DOM_EVENT.POINTER_CANCEL */], (event) => {\n            if (event.type === \"pointerup\" /* DOM_EVENT.POINTER_UP */) {\n                sendTiming(timing);\n            }\n        }, { once: true });\n    }\n    function sendTiming(timing) {\n        if (!timingSent) {\n            timingSent = true;\n            removeEventListeners();\n            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n            // the time between now and when the page was loaded.\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n            const delay = timing.processingStart - timing.startTime;\n            if (delay >= 0 && delay < dateNow() - startTimeStamp) {\n                callback(timing);\n            }\n        }\n    }\n}\n//# sourceMappingURL=firstInputPolyfill.js.map","import { addEventListener, Observable, setTimeout, clearTimeout, monitor } from '@datadog/browser-core';\nimport { hasValidResourceEntryDuration, isAllowedRequestUrl } from '../domain/resource/resourceUtils';\nimport { retrieveFirstInputTiming } from './firstInputPolyfill';\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected performance entry\n// eslint-disable-next-line no-restricted-syntax\nexport var RumPerformanceEntryType;\n(function (RumPerformanceEntryType) {\n    RumPerformanceEntryType[\"EVENT\"] = \"event\";\n    RumPerformanceEntryType[\"FIRST_INPUT\"] = \"first-input\";\n    RumPerformanceEntryType[\"LARGEST_CONTENTFUL_PAINT\"] = \"largest-contentful-paint\";\n    RumPerformanceEntryType[\"LAYOUT_SHIFT\"] = \"layout-shift\";\n    RumPerformanceEntryType[\"LONG_TASK\"] = \"longtask\";\n    RumPerformanceEntryType[\"LONG_ANIMATION_FRAME\"] = \"long-animation-frame\";\n    RumPerformanceEntryType[\"NAVIGATION\"] = \"navigation\";\n    RumPerformanceEntryType[\"PAINT\"] = \"paint\";\n    RumPerformanceEntryType[\"RESOURCE\"] = \"resource\";\n})(RumPerformanceEntryType || (RumPerformanceEntryType = {}));\nexport function createPerformanceObservable(configuration, options) {\n    return new Observable((observable) => {\n        if (!window.PerformanceObserver) {\n            return;\n        }\n        const handlePerformanceEntries = (entries) => {\n            const rumPerformanceEntries = filterRumPerformanceEntries(entries);\n            if (rumPerformanceEntries.length > 0) {\n                observable.notify(rumPerformanceEntries);\n            }\n        };\n        let timeoutId;\n        let isObserverInitializing = true;\n        const observer = new PerformanceObserver(monitor((entries) => {\n            // In Safari the performance observer callback is synchronous.\n            // Because the buffered performance entry list can be quite large we delay the computation to prevent the SDK from blocking the main thread on init\n            if (isObserverInitializing) {\n                timeoutId = setTimeout(() => handlePerformanceEntries(entries.getEntries()));\n            }\n            else {\n                handlePerformanceEntries(entries.getEntries());\n            }\n        }));\n        try {\n            observer.observe(options);\n        }\n        catch (_a) {\n            // Some old browser versions (<= chrome 74 ) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to getEntriesByType and PerformanceObserver with entryTypes\n            // TODO: remove this fallback in the next major version\n            const fallbackSupportedEntryTypes = [\n                RumPerformanceEntryType.RESOURCE,\n                RumPerformanceEntryType.NAVIGATION,\n                RumPerformanceEntryType.LONG_TASK,\n                RumPerformanceEntryType.PAINT,\n            ];\n            if (fallbackSupportedEntryTypes.includes(options.type)) {\n                if (options.buffered) {\n                    timeoutId = setTimeout(() => handlePerformanceEntries(performance.getEntriesByType(options.type)));\n                }\n                try {\n                    observer.observe({ entryTypes: [options.type] });\n                }\n                catch (_b) {\n                    // Old versions of Safari are throwing \"entryTypes contained only unsupported types\"\n                    // errors when observing only unsupported entry types.\n                    //\n                    // We could use `supportPerformanceTimingEvent` to make sure we don't invoke\n                    // `observer.observe` with an unsupported entry type, but Safari 11 and 12 don't support\n                    // `Performance.supportedEntryTypes`, so doing so would lose support for these versions\n                    // even if they do support the entry type.\n                    return;\n                }\n            }\n        }\n        isObserverInitializing = false;\n        manageResourceTimingBufferFull(configuration);\n        let stopFirstInputTiming;\n        if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT) &&\n            options.type === RumPerformanceEntryType.FIRST_INPUT) {\n            ;\n            ({ stop: stopFirstInputTiming } = retrieveFirstInputTiming(configuration, (timing) => {\n                handlePerformanceEntries([timing]);\n            }));\n        }\n        return () => {\n            observer.disconnect();\n            if (stopFirstInputTiming) {\n                stopFirstInputTiming();\n            }\n            clearTimeout(timeoutId);\n        };\n    });\n}\nlet resourceTimingBufferFullListener;\nfunction manageResourceTimingBufferFull(configuration) {\n    if (!resourceTimingBufferFullListener && supportPerformanceObject() && 'addEventListener' in performance) {\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n        resourceTimingBufferFullListener = addEventListener(configuration, performance, 'resourcetimingbufferfull', () => {\n            performance.clearResourceTimings();\n        });\n    }\n    return () => {\n        resourceTimingBufferFullListener === null || resourceTimingBufferFullListener === void 0 ? void 0 : resourceTimingBufferFullListener.stop();\n    };\n}\nfunction supportPerformanceObject() {\n    return window.performance !== undefined && 'getEntries' in performance;\n}\nexport function supportPerformanceTimingEvent(entryType) {\n    return (window.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes !== undefined &&\n        PerformanceObserver.supportedEntryTypes.includes(entryType));\n}\nfunction filterRumPerformanceEntries(entries) {\n    return entries.filter((entry) => !isForbiddenResource(entry));\n}\nfunction isForbiddenResource(entry) {\n    return (entry.entryType === RumPerformanceEntryType.RESOURCE &&\n        (!isAllowedRequestUrl(entry.name) || !hasValidResourceEntryDuration(entry)));\n}\n//# sourceMappingURL=performanceObservable.js.map","import { matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../browser/performanceObservable';\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;\n/**\n * Wait for the page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, pageActivityEndCallback, maxDuration) {\n    const pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    let pageActivityEndTimeoutId;\n    let hasCompleted = false;\n    const validationTimeoutId = setTimeout(monitor(() => complete({ hadActivity: false })), PAGE_ACTIVITY_VALIDATION_DELAY);\n    const maxDurationTimeoutId = maxDuration !== undefined\n        ? setTimeout(monitor(() => complete({ hadActivity: true, end: timeStampNow() })), maxDuration)\n        : undefined;\n    const pageActivitySubscription = pageActivityObservable.subscribe(({ isBusy }) => {\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        const lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = setTimeout(monitor(() => complete({ hadActivity: true, end: lastChangeTime })), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    const stop = () => {\n        hasCompleted = true;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        pageActivityEndCallback(event);\n    }\n    return { stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    return new Observable((observable) => {\n        const subscriptions = [];\n        let firstRequestIndex;\n        let pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), 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}\n//# sourceMappingURL=waitPageActivityEnd.js.map","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    const shadowRoot = node;\n    return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);\n}\nexport function hasChildNodes(node) {\n    return node.childNodes.length > 0 || isNodeShadowHost(node);\n}\nexport function forEachChildNodes(node, callback) {\n    let child = node.firstChild;\n    while (child) {\n        callback(child);\n        child = child.nextSibling;\n    }\n    if (isNodeShadowHost(node)) {\n        callback(node.shadowRoot);\n    }\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nimport { isElementNode, getParentNode, isTextNode } from '../browser/htmlDomUtils';\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};\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_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};\nconst TEXT_MASKING_CHAR = 'x';\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.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_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_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    const element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport const censorText = (text) => text.replace(/\\S/g, TEXT_MASKING_CHAR);\nexport function getTextContent(textNode, ignoreWhiteSpace, 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    if (ignoreWhiteSpace && !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 getPrivacySelector(privacyLevel) {\n    return `[${PRIVACY_ATTR_NAME}=\"${privacyLevel}\"], .${PRIVACY_CLASS_PREFIX}${privacyLevel}`;\n}\n//# sourceMappingURL=privacy.js.map","import { safeTruncate } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getPrivacySelector } from '../privacy';\n/**\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 function getActionNameFromElement(element, { enablePrivacyForActionName, actionNameAttribute: userProgrammaticAttribute }, nodePrivacyLevel) {\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, userProgrammaticAttribute, priorityStrategies, enablePrivacyForActionName) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies, enablePrivacyForActionName) || { name: '', nameSource: \"blank\" /* ActionNameSource.BLANK */ });\n}\nfunction getActionNameFromElementProgrammatically(targetElement, programmaticAttribute) {\n    // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n    // without limit. It is up to the user to declare a relevant naming strategy.\n    const elementWithAttribute = targetElement.closest(`[${programmaticAttribute}]`);\n    if (!elementWithAttribute) {\n        return;\n    }\n    const name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nconst priorityStrategies = [\n    // associated LABEL text\n    (element, userProgrammaticAttribute) => {\n        if ('labels' in element && element.labels && element.labels.length > 0) {\n            return getActionNameFromTextualContent(element.labels[0], userProgrammaticAttribute);\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, userProgrammaticAttribute, privacyEnabledActionName) => {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName);\n        }\n    },\n    (element) => getActionNameFromStandardAttribute(element, 'aria-label'),\n    // associated element text designated by the aria-labelledby attribute\n    (element, userProgrammaticAttribute, privacyEnabledActionName) => {\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, userProgrammaticAttribute, privacyEnabledActionName))\n                    .join(' '),\n                nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n            };\n        }\n    },\n    (element) => getActionNameFromStandardAttribute(element, 'alt'),\n    (element) => getActionNameFromStandardAttribute(element, 'name'),\n    (element) => getActionNameFromStandardAttribute(element, 'title'),\n    (element) => getActionNameFromStandardAttribute(element, 'placeholder'),\n    // SELECT first OPTION text\n    (element, userProgrammaticAttribute) => {\n        if ('options' in element && element.options.length > 0) {\n            return getActionNameFromTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nconst fallbackStrategies = [\n    (element, userProgrammaticAttribute, privacyEnabledActionName) => getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName),\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, userProgrammaticAttribute, strategies, privacyEnabledActionName) {\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, userProgrammaticAttribute, privacyEnabledActionName);\n            if (actionName) {\n                const { name, nameSource } = actionName;\n                const trimmedName = name && name.trim();\n                if (trimmedName) {\n                    return { name: truncate(normalizeWhitespace(trimmedName)), nameSource };\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? `${safeTruncate(s, 100)} [...]` : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getActionNameFromStandardAttribute(element, attribute) {\n    return {\n        name: element.getAttribute(attribute) || '',\n        nameSource: \"standard_attribute\" /* ActionNameSource.STANDARD_ATTRIBUTE */,\n    };\n}\nfunction getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName) {\n    return {\n        name: getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName) || '',\n        nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n    };\n}\nfunction getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName) {\n    if (element.isContentEditable) {\n        return;\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 (privacyEnabledActionName) {\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}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/getActionNameFromElement';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport const STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nconst GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nconst UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    if (!targetElement.isConnected) {\n        // We cannot compute a selector for a detached element, as we don't have access to all of its\n        // parents, and we cannot determine if it's unique in the document.\n        return;\n    }\n    let targetElementSelector;\n    let currentElement = targetElement;\n    while (currentElement && currentElement.nodeName !== 'HTML') {\n        const globallyUniqueSelector = findSelector(currentElement, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        const uniqueSelectorAmongChildren = findSelector(currentElement, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector);\n        currentElement = currentElement.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return `#${CSS.escape(element.id)}`;\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    const classList = element.classList;\n    for (let i = 0; i < classList.length; i += 1) {\n        const className = classList[i];\n        if (isGeneratedValue(className)) {\n            continue;\n        }\n        return `${CSS.escape(element.tagName)}.${CSS.escape(className)}`;\n    }\n}\nfunction getTagNameSelector(element) {\n    return CSS.escape(element.tagName);\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        const selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (const attributeName of STABLE_ATTRIBUTES) {\n        const selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return `${CSS.escape(element.tagName)}[${attributeName}=\"${CSS.escape(element.getAttribute(attributeName))}\"]`;\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    let sibling = element.parentElement.firstElementChild;\n    let elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return `${CSS.escape(element.tagName)}:nth-of-type(${elementIndex})`;\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (const selectorGetter of selectorGetters) {\n        const elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        if (predicate(element, elementSelector, childSelector)) {\n            return combineSelector(elementSelector, childSelector);\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, elementSelector, childSelector) {\n    return element.ownerDocument.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > CHILD_SELECTOR\" returns a single element.\n *\n * @param {Element} currentElement - the element being considered while iterating over the target\n * element ancestors.\n *\n * @param {string} 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 *\n * @param {string|undefined} childSelector - child selector is a selector that targets a descendant\n * of the current element. When undefined, the current element is the target element.\n *\n * # Scope selector usage\n *\n * When composed together, the final selector will be joined with `>` operators to make sure we\n * target direct descendants at each level. In this function, we'll use `querySelector` to check if\n * a selector matches descendants of the current element. But by default, the query selector match\n * elements at any level. Example:\n *\n * ```html\n * <main>\n *   <div>\n *     <span></span>\n *   </div>\n *   <marquee>\n *     <div>\n *       <span></span>\n *     </div>\n *   </marquee>\n * </main>\n * ```\n *\n * `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the\n * selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`\n * operator (`MAIN > DIV > SPAN`).\n *\n * To avoid this, we can use the `:scope` selector to make sure the selector starts from the current\n * sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).\n *\n * [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope\n *\n * # Performance considerations\n *\n * We compute selectors in performance-critical operations (ex: during a click), so we need to make\n * sure the function is as fast as possible. We observed that naively using `querySelectorAll` to\n * check if the selector matches more than 1 element is quite expensive, so we want to avoid it.\n *\n * Because we are iterating the DOM upward and we use that function at every level, we know the\n * child selector is already unique among the current element children, so we don't need to check\n * for the current element subtree.\n *\n * Instead, we can focus on the current element siblings. If we find a single element matching the\n * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`\n * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.\n */\nexport function isSelectorUniqueAmongSiblings(currentElement, currentElementSelector, childSelector) {\n    let isSiblingMatching;\n    if (childSelector === undefined) {\n        // If the child selector is undefined (meaning `currentElement` is the target element, not one\n        // of its ancestor), we need to use `matches` to check if the sibling is matching the selector,\n        // as `querySelector` only returns a descendant of the element.\n        isSiblingMatching = (sibling) => sibling.matches(currentElementSelector);\n    }\n    else {\n        const scopedSelector = combineSelector(`${currentElementSelector}:scope`, childSelector);\n        isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null;\n    }\n    const parent = currentElement.parentElement;\n    let sibling = parent.firstElementChild;\n    while (sibling) {\n        if (sibling !== currentElement && isSiblingMatching(sibling)) {\n            return false;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return true;\n}\nfunction combineSelector(parent, child) {\n    return child ? `${parent}>${child}` : parent;\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { 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 { 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';\nconst MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(\"rage_click\" /* FrustrationType.RAGE_CLICK */);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(\"error_click\" /* 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(\"error_click\" /* 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(\"dead_click\" /* 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    return !click.event.target.matches(DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { elapsed, ONE_SECOND, relativeNow } from '@datadog/browser-core';\n// Maximum duration for click actions\nexport const CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport const interactionSelectorCache = new Map();\nexport function getInteractionSelector(relativeTimestamp) {\n    const selector = interactionSelectorCache.get(relativeTimestamp);\n    interactionSelectorCache.delete(relativeTimestamp);\n    return selector;\n}\nexport function updateInteractionSelector(relativeTimestamp, selector) {\n    interactionSelectorCache.set(relativeTimestamp, selector);\n    interactionSelectorCache.forEach((_, relativeTimestamp) => {\n        if (elapsed(relativeTimestamp, relativeNow()) > CLICK_ACTION_MAX_DURATION) {\n            interactionSelectorCache.delete(relativeTimestamp);\n        }\n    });\n}\n//# sourceMappingURL=interactionSelectorCache.js.map","import { timeStampNow, Observable, getRelativeTime, ONE_MINUTE, generateUUID, clocksNow, elapsed, createValueHistory, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../waitPageActivityEnd';\nimport { getSelectorFromElement } from '../getSelectorFromElement';\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '../privacy';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\nimport { CLICK_ACTION_MAX_DURATION, updateInteractionSelector } from './interactionSelectorCache';\nexport const ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    const history = createValueHistory({ expireDelay: ACTION_CONTEXT_TIME_OUT_DELAY });\n    const stopObservable = new Observable();\n    let currentClickChain;\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        history.reset();\n    });\n    lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    const { stop: stopActionEventsListener } = listenActionEvents(configuration, {\n        onPointerDown: (pointerDownEvent) => processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable),\n        onPointerUp: ({ clickActionBase, hadActivityOnPointerDown }, startEvent, getUserActivity) => {\n            startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    });\n    const actionContexts = {\n        findActionId: (startTime) => history.findAll(startTime),\n    };\n    return {\n        stop: () => {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            const rageClick = click.clone();\n            currentClickChain = createClickChain(click, (clicks) => {\n                finalizeClicks(clicks, rageClick);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable) {\n    const nodePrivacyLevel = configuration.enablePrivacyForActionName\n        ? getNodePrivacyLevel(pointerDownEvent.target, configuration.defaultPrivacyLevel)\n        : NodePrivacyLevel.ALLOW;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return undefined;\n    }\n    const clickActionBase = computeClickActionBase(pointerDownEvent, nodePrivacyLevel, configuration);\n    let hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (pageActivityEndEvent) => {\n        hadActivityOnPointerDown = pageActivityEndEvent.hadActivity;\n    }, \n    // We don't care about the activity duration, we just want to know whether an activity did happen\n    // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n    PAGE_ACTIVITY_VALIDATION_DELAY);\n    return { clickActionBase, hadActivityOnPointerDown: () => hadActivityOnPointerDown };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var _a;\n    const click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    appendClickToClickChain(click);\n    const selector = (_a = clickActionBase === null || clickActionBase === void 0 ? void 0 : clickActionBase.target) === null || _a === void 0 ? void 0 : _a.selector;\n    if (selector) {\n        updateInteractionSelector(startEvent.timeStamp, selector);\n    }\n    const { stop: stopWaitPageActivityEnd } = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (pageActivityEndEvent) => {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n            // If the clock is looking weird, just discard the click\n            click.discard();\n        }\n        else {\n            if (pageActivityEndEvent.hadActivity) {\n                click.stop(pageActivityEndEvent.end);\n            }\n            else if (hadActivityOnPointerDown()) {\n                click.stop(\n                // using the click start as activity end, so the click will have some activity but its\n                // duration will be 0 (as the activity started before the click start)\n                click.startClocks.timeStamp);\n            }\n            else {\n                click.stop();\n            }\n        }\n    }, CLICK_ACTION_MAX_DURATION);\n    const viewEndedSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, ({ endClocks }) => {\n        click.stop(endClocks.timeStamp);\n    });\n    const stopSubscription = stopObservable.subscribe(() => {\n        click.stop();\n    });\n    click.stopObservable.subscribe(() => {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, nodePrivacyLevel, configuration) {\n    const rect = event.target.getBoundingClientRect();\n    const selector = getSelectorFromElement(event.target, configuration.actionNameAttribute);\n    if (selector) {\n        updateInteractionSelector(event.timeStamp, selector);\n    }\n    const actionName = getActionNameFromElement(event.target, configuration, nodePrivacyLevel);\n    return {\n        type: \"click\" /* ActionType.CLICK */,\n        target: {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector,\n        },\n        position: {\n            // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n            x: Math.round(event.clientX - rect.left),\n            y: Math.round(event.clientY - rect.top),\n        },\n        name: actionName.name,\n        nameSource: actionName.nameSource,\n    };\n}\nfunction newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent) {\n    const id = generateUUID();\n    const startClocks = clocksNow();\n    const historyEntry = history.add(id, startClocks.relative);\n    const eventCountsSubscription = trackEventCounts({\n        lifeCycle,\n        isChildEvent: (event) => event.action !== undefined &&\n            (Array.isArray(event.action.id) ? event.action.id.includes(id) : event.action.id === id),\n    });\n    let status = 0 /* ClickStatus.ONGOING */;\n    let activityEndTime;\n    const frustrationTypes = [];\n    const stopObservable = new Observable();\n    function stop(newActivityEndTime) {\n        if (status !== 0 /* ClickStatus.ONGOING */) {\n            return;\n        }\n        activityEndTime = newActivityEndTime;\n        status = 1 /* ClickStatus.STOPPED */;\n        if (activityEndTime) {\n            historyEntry.close(getRelativeTime(activityEndTime));\n        }\n        else {\n            historyEntry.remove();\n        }\n        eventCountsSubscription.stop();\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop,\n        stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity,\n        addFrustration: (frustrationType) => {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks,\n        isStopped: () => status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */,\n        clone: () => newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent),\n        validate: (domEvents) => {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            const { resourceCount, errorCount, longTaskCount } = eventCountsSubscription.eventCounts;\n            const clickAction = {\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks,\n                id,\n                frustrationTypes,\n                counts: {\n                    resourceCount,\n                    errorCount,\n                    longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n                ...clickActionBase,\n            };\n            lifeCycle.notify(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n        discard: () => {\n            stop();\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    const { isRage } = computeFrustration(clicks, rageClick);\n    if (isRage) {\n        clicks.forEach((click) => click.discard());\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map((click) => click.event));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach((click) => click.validate());\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, hooks, domMutationObservable, windowOpenObservable, configuration) {\n    lifeCycle.subscribe(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, (action) => lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action)));\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        if (eventType !== \"error\" /* RumEventType.ERROR */ &&\n            eventType !== \"resource\" /* RumEventType.RESOURCE */ &&\n            eventType !== \"long_task\" /* RumEventType.LONG_TASK */) {\n            return;\n        }\n        const actionId = actionContexts.findActionId(startTime);\n        if (!actionId) {\n            return;\n        }\n        return {\n            type: eventType,\n            action: { id: actionId },\n        };\n    });\n    let actionContexts = { findActionId: noop };\n    let stop = noop;\n    if (configuration.trackUserInteractions) {\n        ;\n        ({ actionContexts, stop } = trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration));\n    }\n    return {\n        addAction: (action, savedCommonContext) => {\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                savedCommonContext,\n                ...processAction(action),\n            });\n        },\n        actionContexts,\n        stop,\n    };\n}\nfunction processAction(action) {\n    const autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                id: action.id,\n                loading_time: discardNegativeDuration(toServerDuration(action.duration)),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\n                    name_source: action.nameSource,\n                },\n            },\n        }\n        : undefined;\n    const actionEvent = combine({\n        action: { id: generateUUID(), target: { name: action.name }, type: action.type },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* RumEventType.ACTION */,\n    }, autoActionProperties);\n    const duration = isAutoAction(action) ? action.duration : undefined;\n    const customerContext = !isAutoAction(action) ? action.context : undefined;\n    const domainContext = isAutoAction(action)\n        ? { events: action.events }\n        : { handlingStack: action.handlingStack };\n    return {\n        customerContext,\n        rawRumEvent: actionEvent,\n        duration,\n        startTime: action.startClocks.relative,\n        domainContext,\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* ActionType.CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","import { instrumentMethod } from '../../tools/instrumentMethod';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nimport { computeStackTrace, computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace';\nimport { computeRawError, isError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError(errorObservable) {\n    const handleRuntimeError = (stackTrace, originalError) => {\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        errorObservable.notify(rawError);\n    };\n    const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError);\n    const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError);\n    return {\n        stop: () => {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        },\n    };\n}\nexport function instrumentOnError(callback) {\n    return instrumentMethod(window, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {\n        let stackTrace;\n        if (isError(errorObj)) {\n            stackTrace = computeStackTrace(errorObj);\n        }\n        else {\n            stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column);\n        }\n        callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);\n    });\n}\nexport function instrumentUnhandledRejection(callback) {\n    return instrumentMethod(window, 'onunhandledrejection', ({ parameters: [e] }) => {\n        const reason = e.reason || 'Empty reason';\n        const stack = computeStackTrace(reason);\n        callback(stack, reason);\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { flattenErrorCauses, isError, tryToGetFingerprint, tryToGetErrorContext } 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, toStackTraceString, 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    let error;\n    if (api === ConsoleApiName.error) {\n        const firstErrorParam = params.find(isError);\n        error = {\n            stack: firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined,\n            fingerprint: tryToGetFingerprint(firstErrorParam),\n            causes: firstErrorParam ? flattenErrorCauses(firstErrorParam, 'console') : undefined,\n            startClocks: clocksNow(),\n            message,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            handlingStack,\n            context: tryToGetErrorContext(firstErrorParam),\n        };\n    }\n    return {\n        api,\n        message,\n        error,\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 { ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, isError, combine, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, configuration) {\n    const errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(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, customerContext, savedCommonContext }) => {\n        customerContext = combine(error.context, customerContext);\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n            customerContext,\n            savedCommonContext,\n            ...processError(error),\n        });\n    });\n    return {\n        addError: ({ error, handlingStack, componentStack, startClocks, context: customerContext }, savedCommonContext) => {\n            const stackTrace = isError(error) ? computeStackTrace(error) : undefined;\n            const rawError = computeRawError({\n                stackTrace,\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            lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, {\n                customerContext,\n                savedCommonContext,\n                error: rawError,\n            });\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: \"error\" /* RumEventType.ERROR */,\n    };\n    const domainContext = {\n        error: error.originalError,\n        handlingStack: error.handlingStack,\n    };\n    return {\n        rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext,\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { initConsoleObservable, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    const subscription = initConsoleObservable([ConsoleApiName.error]).subscribe((consoleLog) => errorObservable.notify(consoleLog.error));\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(configuration, errorObservable) {\n    const subscription = initReportObservable(configuration, [\n        RawReportType.cspViolation,\n        RawReportType.intervention,\n    ]).subscribe((rawError) => errorObservable.notify(rawError));\n    return {\n        stop: () => {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { ONE_SECOND } from './utils/timeUtils';\nimport { requestIdleCallback } from './requestIdleCallback';\n/**\n * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long\n * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose\n * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt\n * performance.\n */\nconst IDLE_CALLBACK_TIMEOUT = ONE_SECOND;\n/**\n * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is\n * reached. We should not run tasks for too long as it will hurt performance, but we should still\n * run some tasks to avoid postponing them forever.\n *\n * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.\n */\nexport const MAX_EXECUTION_TIME_ON_TIMEOUT = 30;\nexport function createTaskQueue() {\n    const pendingTasks = [];\n    function run(deadline) {\n        let executionTimeRemaining;\n        if (deadline.didTimeout) {\n            const start = performance.now();\n            executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start);\n        }\n        else {\n            executionTimeRemaining = deadline.timeRemaining.bind(deadline);\n        }\n        while (executionTimeRemaining() > 0 && pendingTasks.length) {\n            pendingTasks.shift()();\n        }\n        if (pendingTasks.length) {\n            scheduleNextRun();\n        }\n    }\n    function scheduleNextRun() {\n        requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT });\n    }\n    return {\n        push(task) {\n            if (pendingTasks.push(task) === 1) {\n                scheduleNextRun();\n            }\n        },\n    };\n}\n//# sourceMappingURL=taskQueue.js.map","import { addDuration } from '@datadog/browser-core';\nimport { hasValidResourceEntryDuration, hasValidResourceEntryTimings } from './resourceUtils';\nconst alreadyMatchedEntries = new WeakSet();\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - filter out timing that were already matched to a request\n * - then, if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestResourceEntry(request) {\n    if (!performance || !('getEntriesByName' in performance)) {\n        return;\n    }\n    const sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    const candidates = sameNameEntries\n        .filter((entry) => !alreadyMatchedEntries.has(entry))\n        .filter((entry) => hasValidResourceEntryDuration(entry) && hasValidResourceEntryTimings(entry))\n        .filter((entry) => isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration })));\n    if (candidates.length === 1) {\n        alreadyMatchedEntries.add(candidates[0]);\n        return candidates[0].toJSON();\n    }\n    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    const errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestResourceEntry.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\nexport const INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    const data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);\n    if (!data || data.traceTime <= dateNow() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n        return undefined;\n    }\n    return data.traceId;\n}\nexport function getDocumentTraceDataFromMeta(document) {\n    const traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    const traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    const comment = findTraceComment(document);\n    if (!comment) {\n        return undefined;\n    }\n    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));\n}\nexport function createDocumentTraceData(traceId, rawTraceTime) {\n    const traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId,\n        traceTime,\n    };\n}\nexport function findTraceComment(document) {\n    // 1. Try to find the comment as a direct child of the document\n    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n    // value is not an array or string (here, a NodeList).\n    for (let i = 0; i < document.childNodes.length; i += 1) {\n        const comment = getTraceCommentFromNode(document.childNodes[i]);\n        if (comment) {\n            return comment;\n        }\n    }\n    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n    // reverse order, stopping if we come across a non-text node.\n    if (document.body) {\n        for (let i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            const node = document.body.childNodes[i];\n            const comment = getTraceCommentFromNode(node);\n            if (comment) {\n                return comment;\n            }\n            if (!isTextNode(node)) {\n                break;\n            }\n        }\n    }\n}\nfunction getTraceCommentFromNode(node) {\n    if (node && isCommentNode(node)) {\n        const match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { getRelativeTime, isNumber } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent, } from './performanceObservable';\nexport function getNavigationEntry() {\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n        const navigationEntry = performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION)[0];\n        if (navigationEntry) {\n            return navigationEntry;\n        }\n    }\n    const timings = computeTimingsFromDeprecatedPerformanceTiming();\n    const entry = {\n        entryType: RumPerformanceEntryType.NAVIGATION,\n        initiatorType: 'navigation',\n        name: window.location.href,\n        startTime: 0,\n        duration: timings.loadEventEnd,\n        decodedBodySize: 0,\n        encodedBodySize: 0,\n        transferSize: 0,\n        workerStart: 0,\n        toJSON: () => ({ ...entry, toJSON: undefined }),\n        ...timings,\n    };\n    return entry;\n}\nexport function computeTimingsFromDeprecatedPerformanceTiming() {\n    const result = {};\n    const timing = performance.timing;\n    for (const key in timing) {\n        if (isNumber(timing[key])) {\n            const numberKey = key;\n            const timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=performanceUtils.js.map","import { runOnReadyState } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceObservable';\nimport { getDocumentTraceId } from '../tracing/getDocumentTraceId';\nimport { getNavigationEntry } from '../../browser/performanceUtils';\nimport { FAKE_INITIAL_DOCUMENT } from './resourceUtils';\nexport function retrieveInitialDocumentResourceTiming(configuration, callback, getNavigationEntryImpl = getNavigationEntry) {\n    runOnReadyState(configuration, 'interactive', () => {\n        const navigationEntry = getNavigationEntryImpl();\n        const entry = Object.assign(navigationEntry.toJSON(), {\n            entryType: RumPerformanceEntryType.RESOURCE,\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            // The ResourceTiming duration entry should be `responseEnd - startTime`. With\n            // NavigationTiming entries, `startTime` is always 0, so set it to `responseEnd`.\n            duration: navigationEntry.responseEnd,\n            traceId: getDocumentTraceId(document),\n            toJSON: () => ({ ...entry, toJSON: undefined }),\n        });\n        callback(entry);\n    });\n}\n//# sourceMappingURL=retrieveInitialDocumentResourceTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, createTaskQueue, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, createPerformanceObservable, } from '../../browser/performanceObservable';\nimport { createSpanIdentifier } from '../tracing/identifier';\nimport { matchRequestResourceEntry } from './matchRequestResourceEntry';\nimport { computeResourceEntryDetails, computeResourceEntryDuration, computeResourceEntryType, computeResourceEntrySize, computeResourceEntryProtocol, computeResourceEntryDeliveryType, isResourceEntryRequestType, isLongDataUrl, sanitizeDataUrl, } from './resourceUtils';\nimport { retrieveInitialDocumentResourceTiming } from './retrieveInitialDocumentResourceTiming';\nexport function startResourceCollection(lifeCycle, configuration, pageStateHistory, taskQueue = createTaskQueue(), retrieveInitialDocumentResourceTimingImpl = retrieveInitialDocumentResourceTiming) {\n    lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, (request) => {\n        handleResource(() => processRequest(request, configuration, pageStateHistory));\n    });\n    const performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.RESOURCE,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            if (!isResourceEntryRequestType(entry)) {\n                handleResource(() => processResourceEntry(entry, configuration));\n            }\n        }\n    });\n    retrieveInitialDocumentResourceTimingImpl(configuration, (timing) => {\n        handleResource(() => processResourceEntry(timing, configuration));\n    });\n    function handleResource(computeRawEvent) {\n        taskQueue.push(() => {\n            const rawEvent = computeRawEvent();\n            if (rawEvent) {\n                lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, rawEvent);\n            }\n        });\n    }\n    return {\n        stop: () => {\n            performanceResourceSubscription.unsubscribe();\n        },\n    };\n}\nfunction processRequest(request, configuration, pageStateHistory) {\n    const matchingTiming = matchRequestResourceEntry(request);\n    const startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    const tracingInfo = computeRequestTracingInfo(request, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    const type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.FETCH */;\n    const correspondingTimingOverrides = matchingTiming ? computeResourceEntryMetrics(matchingTiming) : undefined;\n    const duration = matchingTiming\n        ? computeResourceEntryDuration(matchingTiming)\n        : computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    const resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type,\n            duration: toServerDuration(duration),\n            method: request.method,\n            status_code: request.status,\n            protocol: matchingTiming && computeResourceEntryProtocol(matchingTiming),\n            url: isLongDataUrl(request.url) ? sanitizeDataUrl(request.url) : request.url,\n            delivery_type: matchingTiming && computeResourceEntryDeliveryType(matchingTiming),\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n        _dd: {\n            discarded: !configuration.trackResources,\n        },\n    }, tracingInfo, correspondingTimingOverrides);\n    return {\n        startTime: startClocks.relative,\n        duration,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming,\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n            isAborted: request.isAborted,\n            handlingStack: request.handlingStack,\n        },\n    };\n}\nfunction processResourceEntry(entry, configuration) {\n    const startClocks = relativeToClocks(entry.startTime);\n    const tracingInfo = computeResourceEntryTracingInfo(entry, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    const type = computeResourceEntryType(entry);\n    const entryMetrics = computeResourceEntryMetrics(entry);\n    const duration = computeResourceEntryDuration(entry);\n    const resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type,\n            duration: toServerDuration(duration),\n            url: entry.name,\n            status_code: discardZeroStatus(entry.responseStatus),\n            protocol: computeResourceEntryProtocol(entry),\n            delivery_type: computeResourceEntryDeliveryType(entry),\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n        _dd: {\n            discarded: !configuration.trackResources,\n        },\n    }, tracingInfo, entryMetrics);\n    return {\n        startTime: startClocks.relative,\n        duration,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: entry,\n        },\n    };\n}\nfunction computeResourceEntryMetrics(entry) {\n    const { renderBlockingStatus } = entry;\n    return {\n        resource: {\n            render_blocking_status: renderBlockingStatus,\n            ...computeResourceEntrySize(entry),\n            ...computeResourceEntryDetails(entry),\n        },\n    };\n}\nfunction computeRequestTracingInfo(request, configuration) {\n    const hasBeenTraced = request.traceSampled && request.traceId && request.spanId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            span_id: request.spanId.toString(),\n            trace_id: request.traceId.toString(),\n            rule_psr: configuration.rulePsr,\n        },\n    };\n}\nfunction computeResourceEntryTracingInfo(entry, configuration) {\n    const hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            span_id: createSpanIdentifier().toString(),\n            rule_psr: configuration.rulePsr,\n        },\n    };\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, startClocks.relative, duration)\n        ? duration\n        : undefined;\n}\n/**\n * The status is 0 for cross-origin resources without CORS headers, so the status is meaningless, and we shouldn't report it\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus#cross-origin_response_status_codes\n */\nfunction discardZeroStatus(statusCode) {\n    return statusCode === 0 ? undefined : statusCode;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { ONE_MINUTE } 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//# sourceMappingURL=trackFirstContentfulPaint.js.map","import { setTimeout, relativeNow, runOnReadyState, clearTimeout } from '@datadog/browser-core';\nimport { getNavigationEntry } from '../../../browser/performanceUtils';\nexport function trackNavigationTimings(configuration, callback, getNavigationEntryImpl = getNavigationEntry) {\n    return waitAfterLoadEvent(configuration, () => {\n        const entry = getNavigationEntryImpl();\n        if (!isIncompleteNavigation(entry)) {\n            callback(processNavigationEntry(entry));\n        }\n    });\n}\nfunction processNavigationEntry(entry) {\n    return {\n        domComplete: entry.domComplete,\n        domContentLoaded: entry.domContentLoadedEventEnd,\n        domInteractive: entry.domInteractive,\n        loadEvent: entry.loadEventEnd,\n        // In some cases the value reported is negative or is larger\n        // than the current page time. Ignore these cases:\n        // https://github.com/GoogleChrome/web-vitals/issues/137\n        // https://github.com/GoogleChrome/web-vitals/issues/162\n        firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\n    };\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.loadEventEnd <= 0;\n}\nfunction waitAfterLoadEvent(configuration, callback) {\n    let timeoutId;\n    const { stop: stopOnReadyState } = runOnReadyState(configuration, 'complete', () => {\n        // Invoke the callback a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        timeoutId = setTimeout(() => callback());\n    });\n    return {\n        stop: () => {\n            stopOnReadyState();\n            clearTimeout(timeoutId);\n        },\n    };\n}\n//# sourceMappingURL=trackNavigationTimings.js.map","import { ONE_MINUTE, addEventListeners, findLast } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts\n */\nexport function trackLargestContentfulPaint(configuration, firstHidden, eventTarget, callback) {\n    // Ignore entries that come after the first user interaction. According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    let firstInteractionTimestamp = Infinity;\n    const { stop: stopEventListener } = addEventListeners(configuration, eventTarget, [\"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */], (event) => {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true });\n    let biggestLcpSize = 0;\n    const performanceLcpSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n        buffered: true,\n    }).subscribe((entries) => {\n        const lcpEntry = findLast(entries, (entry) => entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n            entry.startTime < firstInteractionTimestamp &&\n            entry.startTime < firstHidden.timeStamp &&\n            entry.startTime < LCP_MAXIMUM_DELAY &&\n            // Ensure to get the LCP entry with the biggest size, see\n            // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655\n            entry.size > biggestLcpSize);\n        if (lcpEntry) {\n            let lcpTargetSelector;\n            if (lcpEntry.element) {\n                lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);\n            }\n            callback({\n                value: lcpEntry.startTime,\n                targetSelector: lcpTargetSelector,\n                resourceUrl: computeLcpEntryUrl(lcpEntry),\n            });\n            biggestLcpSize = lcpEntry.size;\n        }\n    });\n    return {\n        stop: () => {\n            stopEventListener();\n            performanceLcpSubscription.unsubscribe();\n        },\n    };\n}\n// The property url report an empty string if the value is not available, we shouldn't report it in this case.\nfunction computeLcpEntryUrl(entry) {\n    return entry.url === '' ? undefined : entry.url;\n}\n//# sourceMappingURL=trackLargestContentfulPaint.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function trackFirstHidden(configuration, eventTarget = window) {\n    let timeStamp;\n    let stopListeners;\n    if (document.visibilityState === 'hidden') {\n        timeStamp = 0;\n    }\n    else {\n        timeStamp = Infinity;\n        ({ stop: stopListeners } = 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                stopListeners();\n            }\n        }, { capture: true }));\n    }\n    return {\n        get timeStamp() {\n            return timeStamp;\n        },\n        stop() {\n            stopListeners === null || stopListeners === void 0 ? void 0 : stopListeners();\n        },\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, 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);\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","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';\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 = getFirstElementAttribution(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 getFirstElementAttribution(sources) {\n    return sources.find((source) => !!source.node && isElementNode(source.node));\n}\nfunction asRumRect({ x, y, width, height }) {\n    return { x, y, width, height };\n}\nexport const MAX_WINDOW_DURATION = 5 * ONE_SECOND;\nconst MAX_UPDATE_GAP = ONE_SECOND;\nfunction slidingSessionWindow() {\n    let cumulatedValue = 0;\n    let startTime;\n    let endTime;\n    let maxValue = 0;\n    return {\n        update: (entry) => {\n            const shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= MAX_UPDATE_GAP ||\n                entry.startTime - startTime >= MAX_WINDOW_DURATION;\n            let isMaxValue;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                maxValue = cumulatedValue = entry.value;\n                isMaxValue = true;\n            }\n            else {\n                cumulatedValue += entry.value;\n                endTime = entry.startTime;\n                isMaxValue = entry.value > maxValue;\n                if (isMaxValue) {\n                    maxValue = entry.value;\n                }\n            }\n            return {\n                cumulatedValue,\n                isMaxValue,\n            };\n        },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window;\n}\n//# sourceMappingURL=trackCumulativeLayoutShift.js.map","/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\nimport { monitor } from '@datadog/browser-core';\nlet observer;\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\nexport function initInteractionCountPolyfill() {\n    if ('interactionCount' in performance || observer) {\n        return;\n    }\n    observer = new window.PerformanceObserver(monitor((entries) => {\n        entries.getEntries().forEach((e) => {\n            const entry = e;\n            if (entry.interactionId) {\n                minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);\n                maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);\n                interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;\n            }\n        });\n    }));\n    observer.observe({ type: 'event', buffered: true, durationThreshold: 0 });\n}\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport const getInteractionCount = () => observer ? interactionCountEstimate : window.performance.interactionCount || 0;\n//# sourceMappingURL=interactionCountPolyfill.js.map","import { elapsed, noop, ONE_MINUTE } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType, supportPerformanceTimingEvent, } from '../../../browser/performanceObservable';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { getInteractionSelector } from '../../action/interactionSelectorCache';\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill';\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nconst MAX_INTERACTION_ENTRIES = 10;\n// Arbitrary value to cap INP outliers\nexport const MAX_INP_VALUE = (1 * ONE_MINUTE);\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(configuration, viewStart, viewLoadingType) {\n    if (!isInteractionToNextPaintSupported()) {\n        return {\n            getInteractionToNextPaint: () => undefined,\n            setViewEnd: noop,\n            stop: noop,\n        };\n    }\n    const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);\n    let viewEnd = Infinity;\n    const longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    let interactionToNextPaint = -1;\n    let interactionToNextPaintTargetSelector;\n    let interactionToNextPaintStartTime;\n    function handleEntries(entries) {\n        for (const entry of entries) {\n            if (entry.interactionId &&\n                // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).\n                entry.startTime >= viewStart &&\n                entry.startTime <= viewEnd) {\n                longestInteractions.process(entry);\n            }\n        }\n        const newInteraction = longestInteractions.estimateP98Interaction();\n        if (newInteraction && newInteraction.duration !== interactionToNextPaint) {\n            interactionToNextPaint = newInteraction.duration;\n            interactionToNextPaintStartTime = elapsed(viewStart, newInteraction.startTime);\n            interactionToNextPaintTargetSelector = getInteractionSelector(newInteraction.startTime);\n            if (!interactionToNextPaintTargetSelector && newInteraction.target && isElementNode(newInteraction.target)) {\n                interactionToNextPaintTargetSelector = getSelectorFromElement(newInteraction.target, configuration.actionNameAttribute);\n            }\n        }\n    }\n    const firstInputSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.FIRST_INPUT,\n        buffered: true,\n    }).subscribe(handleEntries);\n    const eventSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.EVENT,\n        // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n        // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L202-L210\n        durationThreshold: 40,\n        buffered: true,\n    }).subscribe(handleEntries);\n    return {\n        getInteractionToNextPaint: () => {\n            // If no INP duration where captured because of the performanceObserver 40ms threshold\n            // but the view interaction count > 0 then report 0\n            if (interactionToNextPaint >= 0) {\n                return {\n                    value: Math.min(interactionToNextPaint, MAX_INP_VALUE),\n                    targetSelector: interactionToNextPaintTargetSelector,\n                    time: interactionToNextPaintStartTime,\n                };\n            }\n            else if (getViewInteractionCount()) {\n                return {\n                    value: 0,\n                };\n            }\n        },\n        setViewEnd: (viewEndTime) => {\n            viewEnd = viewEndTime;\n            stopViewInteractionCount();\n        },\n        stop: () => {\n            eventSubscription.unsubscribe();\n            firstInputSubscription.unsubscribe();\n        },\n    };\n}\nfunction trackLongestInteractions(getViewInteractionCount) {\n    const longestInteractions = [];\n    function sortAndTrimLongestInteractions() {\n        longestInteractions.sort((a, b) => b.duration - a.duration).splice(MAX_INTERACTION_ENTRIES);\n    }\n    return {\n        /**\n         * Process the performance entry:\n         * - if its duration is long enough, add the performance entry to the list of worst interactions\n         * - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions\n         */\n        process(entry) {\n            const interactionIndex = longestInteractions.findIndex((interaction) => entry.interactionId === interaction.interactionId);\n            const minLongestInteraction = longestInteractions[longestInteractions.length - 1];\n            if (interactionIndex !== -1) {\n                if (entry.duration > longestInteractions[interactionIndex].duration) {\n                    longestInteractions[interactionIndex] = entry;\n                    sortAndTrimLongestInteractions();\n                }\n            }\n            else if (longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n                entry.duration > minLongestInteraction.duration) {\n                longestInteractions.push(entry);\n                sortAndTrimLongestInteractions();\n            }\n        },\n        /**\n         * Compute the p98 longest interaction.\n         * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n         */\n        estimateP98Interaction() {\n            const interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));\n            return longestInteractions[interactionIndex];\n        },\n    };\n}\nexport function trackViewInteractionCount(viewLoadingType) {\n    initInteractionCountPolyfill();\n    const previousInteractionCount = viewLoadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */ ? 0 : getInteractionCount();\n    let state = { stopped: false };\n    function computeViewInteractionCount() {\n        return getInteractionCount() - previousInteractionCount;\n    }\n    return {\n        getViewInteractionCount: () => {\n            if (state.stopped) {\n                return state.interactionCount;\n            }\n            return computeViewInteractionCount();\n        },\n        stopViewInteractionCount: () => {\n            state = { stopped: true, interactionCount: computeViewInteractionCount() };\n        },\n    };\n}\nexport function isInteractionToNextPaintSupported() {\n    return (supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n        window.PerformanceEventTiming &&\n        'interactionId' in PerformanceEventTiming.prototype);\n}\n//# sourceMappingURL=trackInteractionToNextPaint.js.map","export function getScrollX() {\n    let scrollX;\n    const visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    let scrollY;\n    const visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=scroll.js.map","import { Observable, throttle, addEventListener } from '@datadog/browser-core';\nlet viewportObservable;\nexport function initViewportObservable(configuration) {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable(configuration);\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable(configuration) {\n    return new Observable((observable) => {\n        const { throttled: updateDimension } = throttle(() => {\n            observable.notify(getViewportDimension());\n        }, 200);\n        return addEventListener(configuration, window, \"resize\" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true })\n            .stop;\n    });\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    const visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { Observable, ONE_SECOND, elapsed, relativeNow, throttle, addEventListener, monitor, } from '@datadog/browser-core';\nimport { getScrollY } from '../../../browser/scroll';\nimport { getViewportDimension } from '../../../browser/viewportObservable';\n/** Arbitrary scroll throttle duration */\nexport const THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackScrollMetrics(configuration, viewStart, callback, scrollValues = createScrollValuesObservable(configuration)) {\n    let maxScrollDepth = 0;\n    let maxScrollHeight = 0;\n    let maxScrollHeightTime = 0;\n    const subscription = scrollValues.subscribe(({ scrollDepth, scrollTop, scrollHeight }) => {\n        let shouldUpdate = false;\n        if (scrollDepth > maxScrollDepth) {\n            maxScrollDepth = scrollDepth;\n            shouldUpdate = true;\n        }\n        if (scrollHeight > maxScrollHeight) {\n            maxScrollHeight = scrollHeight;\n            const now = relativeNow();\n            maxScrollHeightTime = elapsed(viewStart.relative, now);\n            shouldUpdate = true;\n        }\n        if (shouldUpdate) {\n            callback({\n                maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n                maxDepthScrollTop: scrollTop,\n                maxScrollHeight,\n                maxScrollHeightTime,\n            });\n        }\n    });\n    return {\n        stop: () => subscription.unsubscribe(),\n    };\n}\nexport function computeScrollValues() {\n    const scrollTop = getScrollY();\n    const { height } = getViewportDimension();\n    const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);\n    const scrollDepth = Math.round(height + scrollTop);\n    return {\n        scrollHeight,\n        scrollDepth,\n        scrollTop,\n    };\n}\nexport function createScrollValuesObservable(configuration, throttleDuration = THROTTLE_SCROLL_DURATION) {\n    return new Observable((observable) => {\n        function notify() {\n            observable.notify(computeScrollValues());\n        }\n        if (window.ResizeObserver) {\n            const throttledNotify = throttle(notify, throttleDuration, {\n                leading: false,\n                trailing: true,\n            });\n            const observerTarget = document.scrollingElement || document.documentElement;\n            const resizeObserver = new ResizeObserver(monitor(throttledNotify.throttled));\n            if (observerTarget) {\n                resizeObserver.observe(observerTarget);\n            }\n            const eventListener = addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, throttledNotify.throttled, {\n                passive: true,\n            });\n            return () => {\n                throttledNotify.cancel();\n                resizeObserver.disconnect();\n                eventListener.stop();\n            };\n        }\n    });\n}\n//# sourceMappingURL=trackScrollMetrics.js.map","import { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift';\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint';\nimport { trackLoadingTime } from './trackLoadingTime';\nimport { trackScrollMetrics } from './trackScrollMetrics';\nexport function trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    const commonViewMetrics = {};\n    const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {\n        commonViewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    });\n    const { stop: stopScrollMetricsTracking } = trackScrollMetrics(configuration, viewStart, (newScrollMetrics) => {\n        commonViewMetrics.scroll = newScrollMetrics;\n    });\n    const { stop: stopCLSTracking } = trackCumulativeLayoutShift(configuration, viewStart.relative, (cumulativeLayoutShift) => {\n        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n        scheduleViewUpdate();\n    });\n    const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd, } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType);\n    return {\n        stop: () => {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        stopINPTracking,\n        setLoadEvent,\n        setViewEnd,\n        getCommonViewMetrics: () => {\n            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();\n            return commonViewMetrics;\n        },\n    };\n}\n//# sourceMappingURL=trackCommonViewMetrics.js.map","import { elapsed } from '@datadog/browser-core';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { trackFirstHidden } from './trackFirstHidden';\nexport function trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadType, viewStart, callback) {\n    let isWaitingForLoadEvent = loadType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */;\n    let isWaitingForActivityLoadingTime = true;\n    const loadingTimeCandidates = [];\n    const firstHidden = trackFirstHidden(configuration);\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            const loadingTime = Math.max(...loadingTimeCandidates);\n            if (loadingTime < firstHidden.timeStamp) {\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 { noop, PageExitReason, shallowClone, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, setTimeout, Observable, createContextManager, } from '@datadog/browser-core';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nimport { trackInitialViewMetrics } from './viewMetrics/trackInitialViewMetrics';\nimport { trackCommonViewMetrics } from './viewMetrics/trackCommonViewMetrics';\nexport const THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport const SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\n// Some events or metrics can be captured after the end of the view. To avoid missing those;\n// an arbitrary delay is added for stopping their tracking after the view ends.\n//\n// Ideally, we would not stop and keep tracking events or metrics until the end of the session.\n// But this might have a small performance impact if there are many many views.\n// So let's have a fairly short delay improving the situation in most cases and avoid impacting performances too much.\nexport const KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, windowOpenObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    const activeViews = new Set();\n    let currentView = startNewView(\"initial_load\" /* ViewLoadingType.INITIAL_LOAD */, clocksOrigin(), initialViewOptions);\n    startViewLifeCycle();\n    let locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        const newlyCreatedView = newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, location, loadingType, startClocks, viewOptions);\n        activeViews.add(newlyCreatedView);\n        newlyCreatedView.stopObservable.subscribe(() => {\n            activeViews.delete(newlyCreatedView);\n        });\n        return newlyCreatedView;\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n            // Renew view on session renewal\n            currentView = startNewView(\"route_change\" /* 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        // End the current view on page unload\n        lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, (pageExitEvent) => {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n                currentView.end();\n            }\n        });\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(({ oldLocation, newLocation }) => {\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */);\n            }\n        });\n    }\n    return {\n        addTiming: (name, time = timeStampNow()) => {\n            currentView.addTiming(name, time);\n        },\n        startView: (options, startClocks) => {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(\"route_change\" /* 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            currentView.end();\n            activeViews.forEach((view) => view.stop());\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, initialLocation, loadingType, startClocks = clocksNow(), viewOptions) {\n    // Setup initial values\n    const id = generateUUID();\n    const stopObservable = new Observable();\n    const customTimings = {};\n    let documentVersion = 0;\n    let endClocks;\n    const location = shallowClone(initialLocation);\n    const contextManager = createContextManager();\n    let sessionIsActive = true;\n    let name = viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.name;\n    const service = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.service) || configuration.service;\n    const version = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.version) || configuration.version;\n    const context = viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.context;\n    if (context) {\n        contextManager.setContext(context);\n    }\n    const viewCreatedEvent = {\n        id,\n        name,\n        startClocks,\n        service,\n        version,\n        context,\n    };\n    lifeCycle.notify(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, viewCreatedEvent);\n    lifeCycle.notify(2 /* LifeCycleEventType.VIEW_CREATED */, viewCreatedEvent);\n    // Update the view every time the measures are changing\n    const { throttled, cancel: cancelScheduleViewUpdate } = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    });\n    const { setLoadEvent, setViewEnd, stop: stopCommonViewMetricsTracking, stopINPTracking, getCommonViewMetrics, } = trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, startClocks);\n    const { stop: stopInitialViewMetricsTracking, initialViewMetrics } = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewMetrics(configuration, setLoadEvent, scheduleViewUpdate)\n        : { stop: noop, initialViewMetrics: {} };\n    const { stop: stopEventCountsTracking, eventCounts } = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate);\n    // Session keep alive\n    const keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\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        });\n    }\n    function scheduleViewUpdate() {\n        triggerBeforeViewUpdate();\n        throttled();\n    }\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        triggerBeforeViewUpdate();\n        documentVersion += 1;\n        const currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(4 /* LifeCycleEventType.VIEW_UPDATED */, {\n            customTimings,\n            documentVersion,\n            id,\n            name,\n            service,\n            version,\n            context: contextManager.getContext(),\n            loadingType,\n            location,\n            startClocks,\n            commonViewMetrics: getCommonViewMetrics(),\n            initialViewMetrics,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive,\n            eventCounts,\n        });\n    }\n    return {\n        get name() {\n            return name;\n        },\n        service,\n        version,\n        contextManager,\n        stopObservable,\n        end(options = {}) {\n            var _a, _b;\n            if (endClocks) {\n                // view already ended\n                return;\n            }\n            endClocks = (_a = options.endClocks) !== null && _a !== void 0 ? _a : clocksNow();\n            sessionIsActive = (_b = options.sessionIsActive) !== null && _b !== void 0 ? _b : true;\n            lifeCycle.notify(5 /* LifeCycleEventType.VIEW_ENDED */, { endClocks });\n            lifeCycle.notify(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, { endClocks });\n            clearInterval(keepAliveIntervalId);\n            setViewEnd(endClocks.relative);\n            stopCommonViewMetricsTracking();\n            triggerViewUpdate();\n            setTimeout(() => {\n                this.stop();\n            }, KEEP_TRACKING_AFTER_VIEW_DELAY);\n        },\n        stop() {\n            stopInitialViewMetricsTracking();\n            stopEventCountsTracking();\n            stopINPTracking();\n            stopObservable.notify();\n        },\n        addTiming(name, time) {\n            if (endClocks) {\n                return;\n            }\n            const relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\n        },\n        setViewName(updatedName) {\n            name = updatedName;\n            triggerViewUpdate();\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    const sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(`Invalid timing name: ${name}, sanitized to: ${sanitized}`);\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    const correspondingId = hash.substring(1);\n    // check if the correspondingId is empty because on Firefox an empty string passed to getElementById() prints a consol warning\n    return correspondingId !== '' && !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    const index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { trackEventCounts } from '../trackEventCounts';\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    const { stop, eventCounts } = trackEventCounts({\n        lifeCycle,\n        isChildEvent: (event) => event.view.id === viewId,\n        onChange,\n    });\n    return {\n        stop,\n        eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { isEmptyObject, mapValues, toServerDuration } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, hooks, configuration, location, domMutationObservable, pageOpenObservable, locationChangeObservable, recorderApi, viewHistory, initialViewOptions) {\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_UPDATED */, (view) => lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, recorderApi)));\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        const { service, version, id, name, context } = viewHistory.findView(startTime);\n        return {\n            type: eventType,\n            service,\n            version,\n            context,\n            view: {\n                id,\n                name,\n            },\n        };\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, pageOpenObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, configuration, recorderApi) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;\n    const replayStats = recorderApi.getReplayStats(view.id);\n    const clsDevicePixelRatio = (_b = (_a = view.commonViewMetrics) === null || _a === void 0 ? void 0 : _a.cumulativeLayoutShift) === null || _b === void 0 ? void 0 : _b.devicePixelRatio;\n    const viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            cls: clsDevicePixelRatio\n                ? {\n                    device_pixel_ratio: clsDevicePixelRatio,\n                }\n                : undefined,\n            configuration: {\n                start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n            },\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* 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        session: {\n            has_replay: replayStats ? true : undefined,\n            is_active: view.sessionIsActive ? undefined : false,\n        },\n        privacy: {\n            replay_level: configuration.defaultPrivacyLevel,\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        duration: view.duration,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\nfunction computeViewPerformanceData({ cumulativeLayoutShift, interactionToNextPaint }, { firstContentfulPaint, firstInput, largestContentfulPaint }) {\n    return {\n        cls: cumulativeLayoutShift && {\n            score: cumulativeLayoutShift.value,\n            timestamp: toServerDuration(cumulativeLayoutShift.time),\n            target_selector: cumulativeLayoutShift.targetSelector,\n            previous_rect: cumulativeLayoutShift.previousRect,\n            current_rect: cumulativeLayoutShift.currentRect,\n        },\n        fcp: firstContentfulPaint && { timestamp: toServerDuration(firstContentfulPaint) },\n        fid: firstInput && {\n            duration: toServerDuration(firstInput.delay),\n            timestamp: toServerDuration(firstInput.time),\n            target_selector: firstInput.targetSelector,\n        },\n        inp: interactionToNextPaint && {\n            duration: toServerDuration(interactionToNextPaint.value),\n            timestamp: toServerDuration(interactionToNextPaint.time),\n            target_selector: interactionToNextPaint.targetSelector,\n        },\n        lcp: largestContentfulPaint && {\n            timestamp: toServerDuration(largestContentfulPaint.value),\n            target_selector: largestContentfulPaint.targetSelector,\n            resource_url: largestContentfulPaint.resourceUrl,\n        },\n    };\n}\n//# sourceMappingURL=viewCollection.js.map","import { Observable } from '../../tools/observable';\nimport { createValueHistory } from '../../tools/valueHistory';\nimport { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { clearInterval, setInterval } from '../../tools/timer';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nexport const VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nconst SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nlet stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeSessionState, 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, computeSessionState);\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();\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        return {\n            id: sessionStore.getSession().id,\n            trackingType: sessionStore.getSession()[productKey],\n            isReplayForced: !!sessionStore.getSession().forcedReplay,\n            anonymousId: sessionStore.getSession().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}\n//# sourceMappingURL=sessionManager.js.map","import { Observable, 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) => computeSessionState(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 || !isTypeTracked(session.trackingType)) {\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 computeSessionState(configuration, rawTrackingType) {\n    let trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sessionSampleRate)) {\n        trackingType = \"0\" /* RumTrackingType.NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.sessionReplaySampleRate)) {\n        trackingType = \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    else {\n        trackingType = \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;\n    }\n    return {\n        trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\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}\nfunction isTypeTracked(rumSessionType) {\n    return (rumSessionType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */ ||\n        rumSessionType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageExitObservable';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nexport function createBatch({ encoder, request, flushController, messageBytesLimit, }) {\n    let upsertBuffer = {};\n    const flushSubscription = flushController.flushObservable.subscribe((event) => flush(event));\n    function push(serializedMessage, estimatedMessageBytesCount, key) {\n        flushController.notifyBeforeAddMessage(estimatedMessageBytesCount);\n        if (key !== undefined) {\n            upsertBuffer[key] = serializedMessage;\n            flushController.notifyAfterAddMessage();\n        }\n        else {\n            encoder.write(encoder.isEmpty ? serializedMessage : `\\n${serializedMessage}`, (realMessageBytesCount) => {\n                flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount);\n            });\n        }\n    }\n    function hasMessageFor(key) {\n        return key !== undefined && upsertBuffer[key] !== undefined;\n    }\n    function remove(key) {\n        const removedMessage = upsertBuffer[key];\n        delete upsertBuffer[key];\n        const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage);\n        flushController.notifyAfterRemoveMessage(messageBytesCount);\n    }\n    function addOrUpdate(message, key) {\n        const serializedMessage = jsonStringify(message);\n        const estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage);\n        if (estimatedMessageBytesCount >= messageBytesLimit) {\n            display.warn(`Discarded a message whose size was bigger than the maximum allowed size ${messageBytesLimit}KB. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#technical-limitations`);\n            return;\n        }\n        if (hasMessageFor(key)) {\n            remove(key);\n        }\n        push(serializedMessage, estimatedMessageBytesCount, key);\n    }\n    function flush(event) {\n        const upsertMessages = objectValues(upsertBuffer).join('\\n');\n        upsertBuffer = {};\n        const isPageExit = isPageExitReason(event.reason);\n        const send = isPageExit ? request.sendOnExit : request.send;\n        if (isPageExit &&\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 { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController({ messagesLimit, bytesLimit, durationLimit, pageExitObservable, sessionExpireObservable, }) {\n    const pageExitSubscription = pageExitObservable.subscribe((event) => flush(event.reason));\n    const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'));\n    const flushObservable = new Observable(() => () => {\n        pageExitSubscription.unsubscribe();\n        sessionExpireSubscription.unsubscribe();\n    });\n    let currentBytesCount = 0;\n    let currentMessagesCount = 0;\n    function flush(flushReason) {\n        if (currentMessagesCount === 0) {\n            return;\n        }\n        const messagesCount = currentMessagesCount;\n        const bytesCount = currentBytesCount;\n        currentMessagesCount = 0;\n        currentBytesCount = 0;\n        cancelDurationLimitTimeout();\n        flushObservable.notify({\n            reason: flushReason,\n            messagesCount,\n            bytesCount,\n        });\n    }\n    let durationLimitTimeoutId;\n    function scheduleDurationLimitTimeout() {\n        if (durationLimitTimeoutId === undefined) {\n            durationLimitTimeoutId = setTimeout(() => {\n                flush('duration_limit');\n            }, durationLimit);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable,\n        get messagesCount() {\n            return currentMessagesCount;\n        },\n        /**\n         * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right before adding the message, so no flush\n         * event can happen after `notifyBeforeAddMessage` and before adding the message.\n         *\n         * @param estimatedMessageBytesCount: an estimation of the message bytes count once it is\n         * actually added.\n         */\n        notifyBeforeAddMessage(estimatedMessageBytesCount) {\n            if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n            // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n            // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n            // to notify when a flush is needed (for example on page exit).\n            currentMessagesCount += 1;\n            currentBytesCount += estimatedMessageBytesCount;\n            scheduleDurationLimitTimeout();\n        },\n        /**\n         * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n         *\n         * This function can be called asynchronously after the message was added, but in this case it\n         * should not be called if a flush event occurred in between.\n         *\n         * @param messageBytesCountDiff: the difference between the estimated message bytes count and\n         * its actual bytes count once added to the pool.\n         */\n        notifyAfterAddMessage(messageBytesCountDiff = 0) {\n            currentBytesCount += messageBytesCountDiff;\n            if (currentMessagesCount >= messagesLimit) {\n                flush('messages_limit');\n            }\n            else if (currentBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n        },\n        /**\n         * Notifies that a message was removed from a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right after removing the message, so no flush\n         * event can happen after removing the message and before `notifyAfterRemoveMessage`.\n         *\n         * @param messageBytesCount: the message bytes count that was added to the pool. Should\n         * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and\n         * `notifyAfterAddMessage`.\n         */\n        notifyAfterRemoveMessage(messageBytesCount) {\n            currentBytesCount -= messageBytesCount;\n            currentMessagesCount -= 1;\n            if (currentMessagesCount === 0) {\n                cancelDurationLimitTimeout();\n            }\n        },\n    };\n}\n//# sourceMappingURL=flushController.js.map","import { combine, isTelemetryReplicationAllowed, startBatchWithReplica, } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable, sessionExpireObservable, createEncoder) {\n    const replica = configuration.replica;\n    const batch = startBatchWithReplica(configuration, {\n        endpoint: configuration.rumEndpointBuilder,\n        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),\n    }, replica && {\n        endpoint: replica.rumEndpointBuilder,\n        transformMessage: (message) => combine(message, { application: { id: replica.applicationId } }),\n        encoder: createEncoder(3 /* DeflateEncoderStreamId.RUM_REPLICA */),\n    }, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {\n        if (serverRumEvent.type === \"view\" /* RumEventType.VIEW */) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    telemetryEventObservable.subscribe((event) => batch.add(event, isTelemetryReplicationAllowed(configuration)));\n    return batch;\n}\n//# sourceMappingURL=startRumBatch.js.map","import { createBatch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nimport { createFlushController } from './flushController';\nexport function startBatchWithReplica(configuration, primary, replica, reportError, pageExitObservable, sessionExpireObservable, batchFactoryImp = createBatch) {\n    const primaryBatch = createBatchFromConfig(configuration, primary);\n    const replicaBatch = replica && createBatchFromConfig(configuration, replica);\n    function createBatchFromConfig(configuration, { endpoint, encoder }) {\n        return batchFactoryImp({\n            encoder,\n            request: createHttpRequest(endpoint, configuration.batchBytesLimit, reportError),\n            flushController: createFlushController({\n                messagesLimit: configuration.batchMessagesLimit,\n                bytesLimit: configuration.batchBytesLimit,\n                durationLimit: configuration.flushTimeout,\n                pageExitObservable,\n                sessionExpireObservable,\n            }),\n            messageBytesLimit: configuration.messageBytesLimit,\n        });\n    }\n    return {\n        flushObservable: primaryBatch.flushController.flushObservable,\n        add(message, replicated = true) {\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message);\n            }\n        },\n        upsert: (message, key) => {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key);\n            }\n        },\n        stop: () => {\n            primaryBatch.stop();\n            if (replicaBatch) {\n                replicaBatch.stop();\n            }\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, createValueHistory } from '@datadog/browser-core';\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\nexport const URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, hooks, locationChangeObservable, location) {\n    const urlContextHistory = createValueHistory({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY });\n    let previousViewUrl;\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, ({ startClocks }) => {\n        const viewUrl = location.href;\n        urlContextHistory.add(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, ({ endClocks }) => {\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    const locationChangeSubscription = locationChangeObservable.subscribe(({ newLocation }) => {\n        const current = urlContextHistory.find();\n        if (current) {\n            const changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext({ url, referrer }) {\n        return {\n            url,\n            referrer,\n        };\n    }\n    hooks.register(0 /* HookNames.Assemble */, ({ startTime, eventType }) => {\n        const { url, referrer } = urlContextHistory.find(startTime);\n        return {\n            type: eventType,\n            view: {\n                url,\n                referrer,\n            },\n        };\n    });\n    return {\n        findUrl: (startTime) => urlContextHistory.find(startTime),\n        getAllEntries: () => urlContextHistory.getAllEntries(),\n        getDeletedEntries: () => urlContextHistory.getDeletedEntries(),\n        stop: () => {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { addEventListener, instrumentMethod, Observable, shallowClone } from '@datadog/browser-core';\nexport function createLocationChangeObservable(configuration, location) {\n    let currentLocation = shallowClone(location);\n    return new Observable((observable) => {\n        const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange);\n        const { stop: stopHashTracking } = trackHash(configuration, onLocationChange);\n        function onLocationChange() {\n            if (currentLocation.href === location.href) {\n                return;\n            }\n            const newLocation = shallowClone(location);\n            observable.notify({\n                newLocation,\n                oldLocation: currentLocation,\n            });\n            currentLocation = newLocation;\n        }\n        return () => {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n}\nfunction trackHistory(configuration, onHistoryChange) {\n    const { stop: stopInstrumentingPushState } = instrumentMethod(getHistoryInstrumentationTarget('pushState'), 'pushState', ({ onPostCall }) => {\n        onPostCall(onHistoryChange);\n    });\n    const { stop: stopInstrumentingReplaceState } = instrumentMethod(getHistoryInstrumentationTarget('replaceState'), 'replaceState', ({ onPostCall }) => {\n        onPostCall(onHistoryChange);\n    });\n    const { stop: removeListener } = addEventListener(configuration, window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange);\n    return {\n        stop: () => {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(configuration, onHashChange) {\n    return addEventListener(configuration, window, \"hashchange\" /* DOM_EVENT.HASH_CHANGE */, onHashChange);\n}\nfunction getHistoryInstrumentationTarget(methodName) {\n    // Ideally we should always instument the method on the prototype, however some frameworks (e.g [Next.js](https://github.com/vercel/next.js/blob/d3f5532065f3e3bb84fb54bd2dfd1a16d0f03a21/packages/next/src/client/components/app-router.tsx#L429))\n    // are wrapping the instance method. In that case we should also wrap the instance method.\n    return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype;\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { SESSION_TIME_OUT_DELAY, createValueHistory, isEmptyObject } from '@datadog/browser-core';\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, customerDataTracker) {\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        customerDataTracker.resetCustomerData();\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            \"view\" /* RumEventType.VIEW */,\n            \"error\" /* RumEventType.ERROR */,\n        ]);\n        if (!trackFeatureFlagsForEvents.includes(eventType)) {\n            return;\n        }\n        const featureFlagContext = featureFlagContexts.find(startTime);\n        if (!featureFlagContext || isEmptyObject(featureFlagContext)) {\n            return;\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                customerDataTracker.updateCustomerData(currentContext);\n            }\n        },\n        stop: () => customerDataTracker.stop(),\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { performDraw, ONE_SECOND, addTelemetryDebug, setInterval } from '@datadog/browser-core';\nexport const MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nlet currentPeriodMeasures;\nlet currentBatchMeasures;\nlet batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batchFlushObservable) {\n    const customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate);\n    if (!customerDataTelemetryEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    initCurrentBatchMeasures();\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 */, (event) => {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */).getBytesCount());\n        updateMeasure(currentBatchMeasures.userContextBytes, customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */).getBytesCount());\n        updateMeasure(currentBatchMeasures.featureFlagBytes, [\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */].includes(event.type)\n            ? customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */).getBytesCount()\n            : 0);\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        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);\n        mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes);\n        mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes);\n        mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes);\n        initCurrentBatchMeasures();\n    });\n    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    addTelemetryDebug('Customer data measures', 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 mergeMeasure(target, source) {\n    target.sum += source.sum;\n    target.min = Math.min(target.min, source.min);\n    target.max = Math.max(target.max, source.max);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\nfunction initCurrentBatchMeasures() {\n    batchHasRumEvent = false;\n    currentBatchMeasures = {\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { elapsed, createValueHistory, SESSION_TIME_OUT_DELAY, toServerDuration, addEventListeners, relativeNow, } from '@datadog/browser-core';\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    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 === \"view\" /* 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 === \"action\" /* RumEventType.ACTION */ || eventType === \"error\" /* RumEventType.ERROR */) {\n            return {\n                type: eventType,\n                view: { in_foreground: wasInPageStateDuringPeriod(\"active\" /* PageState.ACTIVE */, startTime, 0) },\n            };\n        }\n    });\n    return {\n        wasInPageStateDuringPeriod,\n        addPageState,\n        stop: () => {\n            stopEventListeners();\n            pageStateEntryHistory.stop();\n        },\n    };\n}\nfunction processPageStates(pageStateEntries, eventStartTime, maxPageStateEntriesSelectable) {\n    if (pageStateEntries.length === 0) {\n        return;\n    }\n    return pageStateEntries\n        .slice(-maxPageStateEntriesSelectable)\n        .reverse()\n        .map(({ state, startTime }) => ({\n        state,\n        start: toServerDuration(elapsed(eventStartTime, startTime)),\n    }));\n}\nfunction computePageState(event) {\n    if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */) {\n        return event.persisted ? \"frozen\" /* PageState.FROZEN */ : \"terminated\" /* PageState.TERMINATED */;\n    }\n    return getPageState();\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* PageState.HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* PageState.ACTIVE */;\n    }\n    return \"passive\" /* PageState.PASSIVE */;\n}\n//# sourceMappingURL=pageStateHistory.js.map","import { setInterval, clearInterval, Observable, addEventListener, ONE_SECOND, findCommaSeparatedValue, } from '@datadog/browser-core';\nexport function createCookieObservable(configuration, cookieName) {\n    const detectCookieChangeStrategy = window.cookieStore\n        ? listenToCookieStoreChange(configuration)\n        : watchCookieFallback;\n    return new Observable((observable) => detectCookieChangeStrategy(cookieName, (event) => observable.notify(event)));\n}\nfunction listenToCookieStoreChange(configuration) {\n    return (cookieName, callback) => {\n        const listener = addEventListener(configuration, window.cookieStore, \"change\" /* DOM_EVENT.CHANGE */, (event) => {\n            // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.\n            // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226\n            const changeEvent = event.changed.find((event) => event.name === cookieName) ||\n                event.deleted.find((event) => event.name === cookieName);\n            if (changeEvent) {\n                callback(changeEvent.value);\n            }\n        });\n        return listener.stop;\n    };\n}\nexport const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND;\nfunction watchCookieFallback(cookieName, callback) {\n    const previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n    const watchCookieIntervalId = setInterval(() => {\n        const cookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n        if (cookieValue !== previousCookieValue) {\n            callback(cookieValue);\n        }\n    }, WATCH_COOKIE_INTERVAL_DELAY);\n    return () => {\n        clearInterval(watchCookieIntervalId);\n    };\n}\n//# sourceMappingURL=cookieObservable.js.map","import { getInitCookie } 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;\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 { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from '@datadog/browser-core';\nexport function startSyntheticsContext(hooks) {\n    hooks.register(0 /* HookNames.Assemble */, ({ eventType }) => {\n        const testId = getSyntheticsTestId();\n        const resultId = getSyntheticsResultId();\n        if (!testId || !resultId) {\n            return;\n        }\n        return {\n            type: eventType,\n            session: {\n                type: \"synthetics\" /* SessionType.SYNTHETICS */,\n            },\n            synthetics: {\n                test_id: testId,\n                result_id: resultId,\n                injected: willSyntheticsInjectRum(),\n            },\n        };\n    });\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { sendToExtension, createPageExitObservable, startTelemetry, canUseEventBridge, getEventBridge, addTelemetryDebug, drainPreStartTelemetry, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { createWindowOpenObservable } from '../browser/windowOpenObservable';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewHistory } from '../domain/contexts/viewHistory';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/action/actionCollection';\nimport { startErrorCollection } from '../domain/error/errorCollection';\nimport { startResourceCollection } from '../domain/resource/resourceCollection';\nimport { startViewCollection } from '../domain/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { startDisplayContext } from '../domain/contexts/displayContext';\nimport { startVitalCollection } from '../domain/vital/vitalCollection';\nimport { startCiVisibilityContext } from '../domain/contexts/ciVisibilityContext';\nimport { startLongAnimationFrameCollection } from '../domain/longAnimationFrame/longAnimationFrameCollection';\nimport { RumPerformanceEntryType } from '../browser/performanceObservable';\nimport { startLongTaskCollection } from '../domain/longTask/longTaskCollection';\nimport { createHooks } from '../hooks';\nimport { startSyntheticsContext } from '../domain/contexts/syntheticsContext';\nexport function startRum(configuration, recorderApi, customerDataTrackerManager, getCommonContext, 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) {\n    var _a;\n    const cleanupTasks = [];\n    const lifeCycle = new LifeCycle();\n    const hooks = createHooks();\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (event) => sendToExtension('rum', event));\n    const telemetry = startRumTelemetry(configuration);\n    telemetry.setContextProvider(() => {\n        var _a, _b;\n        return ({\n            application: {\n                id: configuration.applicationId,\n            },\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n            view: {\n                id: (_b = viewHistory.findView()) === null || _b === void 0 ? void 0 : _b.id,\n            },\n            action: {\n                id: actionContexts.findActionId(),\n            },\n        });\n    });\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const pageExitObservable = createPageExitObservable(configuration);\n    const pageExitSubscription = pageExitObservable.subscribe((event) => {\n        lifeCycle.notify(11 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    cleanupTasks.push(() => pageExitSubscription.unsubscribe());\n    const session = !canUseEventBridge()\n        ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n        : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        const batch = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable, createEncoder);\n        cleanupTasks.push(() => batch.stop());\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batch.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    const domMutationObservable = createDOMMutationObservable();\n    const locationChangeObservable = createLocationChangeObservable(configuration, location);\n    const pageStateHistory = startPageStateHistory(hooks, configuration);\n    const viewHistory = startViewHistory(lifeCycle);\n    const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location);\n    const featureFlagContexts = startFeatureFlagContexts(lifeCycle, hooks, configuration, customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */));\n    cleanupTasks.push(() => featureFlagContexts.stop());\n    const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable();\n    cleanupTasks.push(stopWindowOpen);\n    const { actionContexts, addAction, stop: stopRumEventCollection, } = startRumEventCollection(lifeCycle, hooks, configuration, session, pageStateHistory, domMutationObservable, windowOpenObservable, urlContexts, viewHistory, getCommonContext, reportError);\n    cleanupTasks.push(stopRumEventCollection);\n    drainPreStartTelemetry();\n    const { addTiming, startView, setViewName, setViewContext, setViewContextProperty, getViewContext, stop: stopViewCollection, } = startViewCollection(lifeCycle, hooks, configuration, location, domMutationObservable, windowOpenObservable, locationChangeObservable, recorderApi, viewHistory, initialViewOptions);\n    cleanupTasks.push(stopViewCollection);\n    const { stop: stopResourceCollection } = startResourceCollection(lifeCycle, configuration, pageStateHistory);\n    cleanupTasks.push(stopResourceCollection);\n    if (configuration.trackLongTasks) {\n        if ((_a = PerformanceObserver.supportedEntryTypes) === null || _a === void 0 ? void 0 : _a.includes(RumPerformanceEntryType.LONG_ANIMATION_FRAME)) {\n            const { stop: stopLongAnimationFrameCollection } = startLongAnimationFrameCollection(lifeCycle, configuration);\n            cleanupTasks.push(stopLongAnimationFrameCollection);\n        }\n        else {\n            startLongTaskCollection(lifeCycle, configuration);\n        }\n    }\n    const { addError } = startErrorCollection(lifeCycle, configuration);\n    startRequestCollection(lifeCycle, configuration, session);\n    const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState);\n    const internalContext = startInternalContext(configuration.applicationId, session, viewHistory, actionContexts, urlContexts);\n    return {\n        addAction,\n        addError,\n        addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView,\n        setViewContext,\n        setViewContextProperty,\n        getViewContext,\n        setViewName,\n        lifeCycle,\n        viewHistory,\n        session,\n        stopSession: () => session.expire(),\n        getInternalContext: internalContext.get,\n        startDurationVital: vitalCollection.startDurationVital,\n        stopDurationVital: vitalCollection.stopDurationVital,\n        addDurationVital: vitalCollection.addDurationVital,\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n    };\n}\nfunction startRumTelemetry(configuration) {\n    const telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration);\n    if (canUseEventBridge()) {\n        const bridge = getEventBridge();\n        telemetry.observable.subscribe((event) => bridge.send('internal_telemetry', event));\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, hooks, configuration, sessionManager, pageStateHistory, domMutationObservable, windowOpenObservable, urlContexts, viewHistory, getCommonContext, reportError) {\n    const actionCollection = startActionCollection(lifeCycle, hooks, domMutationObservable, windowOpenObservable, configuration);\n    const displayContext = startDisplayContext(configuration);\n    const ciVisibilityContext = startCiVisibilityContext(configuration, hooks);\n    startSyntheticsContext(hooks);\n    startRumAssembly(configuration, lifeCycle, hooks, sessionManager, viewHistory, urlContexts, displayContext, getCommonContext, reportError);\n    return {\n        pageStateHistory,\n        addAction: actionCollection.addAction,\n        actionContexts: actionCollection.actionContexts,\n        stop: () => {\n            actionCollection.stop();\n            ciVisibilityContext.stop();\n            displayContext.stop();\n            viewHistory.stop();\n            pageStateHistory.stop();\n            urlContexts.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { combine } from '@datadog/browser-core';\nexport function createHooks() {\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 = hookCallbacks.map((callback) => callback(param));\n            return combine(...results);\n        },\n    };\n}\n//# sourceMappingURL=hooks.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 { 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 { monitor } from '@datadog/browser-core';\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nexport function startDisplayContext(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    return {\n        get: () => (viewport ? { viewport } : undefined),\n        stop: () => {\n            unsubscribeViewport();\n            if (animationFrameId) {\n                cancelAnimationFrame(animationFrameId);\n            }\n        },\n    };\n}\n//# sourceMappingURL=displayContext.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable';\nexport function startLongAnimationFrameCollection(lifeCycle, configuration) {\n    const performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_ANIMATION_FRAME,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            const startClocks = relativeToClocks(entry.startTime);\n            const rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    entry_type: \"long-animation-frame\" /* RumLongTaskEntryType.LONG_ANIMATION_FRAME */,\n                    duration: toServerDuration(entry.duration),\n                    blocking_duration: toServerDuration(entry.blockingDuration),\n                    first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),\n                    render_start: toServerDuration(entry.renderStart),\n                    style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),\n                    start_time: toServerDuration(entry.startTime),\n                    scripts: entry.scripts.map((script) => ({\n                        duration: toServerDuration(script.duration),\n                        pause_duration: toServerDuration(script.pauseDuration),\n                        forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),\n                        start_time: toServerDuration(script.startTime),\n                        execution_start: toServerDuration(script.executionStart),\n                        source_url: script.sourceURL,\n                        source_function_name: script.sourceFunctionName,\n                        source_char_position: script.sourceCharPosition,\n                        invoker: script.invoker,\n                        invoker_type: script.invokerType,\n                        window_attribution: script.windowAttribution,\n                    })),\n                },\n                type: \"long_task\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent,\n                startTime: startClocks.relative,\n                duration: entry.duration,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return { stop: () => performanceResourceSubscription.unsubscribe() };\n}\n//# sourceMappingURL=longAnimationFrameCollection.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable';\nexport function startLongTaskCollection(lifeCycle, configuration) {\n    const performanceLongTaskSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_TASK,\n        buffered: true,\n    }).subscribe((entries) => {\n        for (const entry of entries) {\n            if (entry.entryType !== RumPerformanceEntryType.LONG_TASK) {\n                break;\n            }\n            if (!configuration.trackLongTasks) {\n                break;\n            }\n            const startClocks = relativeToClocks(entry.startTime);\n            const rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    entry_type: \"long-task\" /* RumLongTaskEntryType.LONG_TASK */,\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent,\n                startTime: startClocks.relative,\n                duration: entry.duration,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return {\n        stop() {\n            performanceLongTaskSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=longTaskCollection.js.map","/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, viewHistory, actionContexts, urlContexts) {\n    return {\n        get: (startTime) => {\n            const viewContext = viewHistory.findView(startTime);\n            const urlContext = urlContexts.findUrl(startTime);\n            const session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                const actionId = actionContexts.findActionId(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionId ? { id: actionId } : undefined,\n                    view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, { session, viewContext, errorType, }) {\n    const sessionId = session ? session.id : 'no-session-id';\n    const parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(`error-type=${errorType}`);\n    }\n    if (viewContext) {\n        parameters.push(`seed=${viewContext.id}`);\n        parameters.push(`from=${viewContext.startClocks.timeStamp}`);\n    }\n    const origin = getDatadogSiteUrl(configuration);\n    const path = `/rum/replay/sessions/${sessionId}`;\n    return `${origin}${path}?${parameters.join('&')}`;\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    const site = rumConfiguration.site;\n    const subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return `https://${subdomain ? `${subdomain}.` : ''}${site}`;\n}\nfunction getSiteDefaultSubdomain(configuration) {\n    switch (configuration.site) {\n        case INTAKE_SITE_US1:\n        case INTAKE_SITE_EU1:\n            return 'app';\n        case INTAKE_SITE_STAGING:\n            return 'dd';\n        default:\n            return undefined;\n    }\n}\n//# sourceMappingURL=getSessionReplayUrl.js.map","import { display } from '../display';\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { detachToJsonMethod } from './jsonStringify';\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nconst SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nconst JSON_PATH_ROOT_ELEMENT = '$';\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nconst KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {\n    // Unbind any toJSON function we may have on [] or {} prototypes\n    const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    const containerQueue = [];\n    const visitedObjectsWithPath = new WeakMap();\n    const sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n    const serializedSanitizedData = JSON.stringify(sanitizedData);\n    let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0;\n    if (accumulatedCharacterCount > maxCharacterCount) {\n        warnOverCharacterLimit(maxCharacterCount, 'discarded', source);\n        return undefined;\n    }\n    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n        const containerToProcess = containerQueue.shift();\n        let separatorLength = 0; // 0 for the first element, 1 for subsequent elements\n        // Arrays and Objects have to be handled distinctly to ensure\n        // we do not pick up non-numerical properties from Arrays\n        if (Array.isArray(containerToProcess.source)) {\n            for (let key = 0; key < containerToProcess.source.length; key++) {\n                const targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                if (targetData !== undefined) {\n                    accumulatedCharacterCount += JSON.stringify(targetData).length;\n                }\n                else {\n                    // When an element of an Array (targetData) is undefined, it is serialized as null:\n                    // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n                    accumulatedCharacterCount += 4;\n                }\n                accumulatedCharacterCount += separatorLength;\n                separatorLength = 1;\n                if (accumulatedCharacterCount > maxCharacterCount) {\n                    warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                    break;\n                }\n                ;\n                containerToProcess.target[key] = targetData;\n            }\n        }\n        else {\n            for (const key in containerToProcess.source) {\n                if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n                    const targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                    // When a property of an object has an undefined value, it will be dropped during serialization:\n                    // JSON.stringify({a:undefined}) => '{}'\n                    if (targetData !== undefined) {\n                        accumulatedCharacterCount +=\n                            JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;\n                        separatorLength = 1;\n                    }\n                    if (accumulatedCharacterCount > maxCharacterCount) {\n                        warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                        break;\n                    }\n                    ;\n                    containerToProcess.target[key] = targetData;\n                }\n            }\n        }\n    }\n    // Rebind detached toJSON functions\n    restoreObjectPrototypeToJson();\n    restoreArrayPrototypeToJson();\n    return sanitizedData;\n}\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {\n    // Start by handling toJSON, as we want to sanitize its output\n    const sourceToSanitize = tryToApplyToJSON(source);\n    if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n        return sanitizePrimitivesAndFunctions(sourceToSanitize);\n    }\n    const sanitizedSource = sanitizeObjects(sourceToSanitize);\n    if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n        return sanitizedSource;\n    }\n    // Handle potential cyclic references\n    // We need to use source as sourceToSanitize could be a reference to a new object\n    // At this stage, we know the source is an object type\n    const sourceAsObject = source;\n    if (visitedObjectsWithPath.has(sourceAsObject)) {\n        return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)}]`;\n    }\n    // Add processed source to queue\n    const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath;\n    const target = Array.isArray(sourceToSanitize) ? [] : {};\n    visitedObjectsWithPath.set(sourceAsObject, currentPath);\n    queue.push({ source: sourceToSanitize, target, path: currentPath });\n    return target;\n}\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value) {\n    // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n    if (typeof value === 'bigint') {\n        return `[BigInt] ${value.toString()}`;\n    }\n    // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n    // so it won't prevent stringify from serializing later\n    if (typeof value === 'function') {\n        return `[Function] ${value.name || 'unknown'}`;\n    }\n    // JSON.stringify() does not serialize symbols.\n    if (typeof value === 'symbol') {\n        return `[Symbol] ${value.description || value.toString()}`;\n    }\n    return value;\n}\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n */\nfunction sanitizeObjects(value) {\n    try {\n        if (value instanceof Event) {\n            return sanitizeEvent(value);\n        }\n        if (value instanceof RegExp) {\n            return `[RegExp] ${value.toString()}`;\n        }\n        // Handle all remaining object types in a generic way\n        const result = Object.prototype.toString.call(value);\n        const match = result.match(/\\[object (.*)\\]/);\n        if (match && match[1]) {\n            return `[${match[1]}]`;\n        }\n    }\n    catch (_a) {\n        // If the previous serialization attempts failed, and we cannot convert using\n        // Object.prototype.toString, declare the value unserializable\n    }\n    return '[Unserializable]';\n}\nfunction sanitizeEvent(event) {\n    return {\n        type: event.type,\n        isTrusted: event.isTrusted,\n        currentTarget: event.currentTarget ? sanitizeObjects(event.currentTarget) : null,\n        target: event.target ? sanitizeObjects(event.target) : null,\n    };\n}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n    const object = value;\n    if (object && typeof object.toJSON === 'function') {\n        try {\n            return object.toJSON();\n        }\n        catch (_a) {\n            // If toJSON fails, we continue by trying to serialize the value manually\n        }\n    }\n    return value;\n}\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount, changeType, source) {\n    display.warn(`The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`, source);\n}\n//# sourceMappingURL=sanitize.js.map","import { setTimeout, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n    const needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    let inWaitPeriod = false;\n    let pendingExecutionWithParameters;\n    let pendingTimeoutId;\n    return {\n        throttled: (...parameters) => {\n            if (inWaitPeriod) {\n                pendingExecutionWithParameters = parameters;\n                return;\n            }\n            if (needLeadingExecution) {\n                fn(...parameters);\n            }\n            else {\n                pendingExecutionWithParameters = parameters;\n            }\n            inWaitPeriod = true;\n            pendingTimeoutId = setTimeout(() => {\n                if (needTrailingExecution && pendingExecutionWithParameters) {\n                    fn(...pendingExecutionWithParameters);\n                }\n                inWaitPeriod = false;\n                pendingExecutionWithParameters = undefined;\n            }, wait);\n        },\n        cancel: () => {\n            clearTimeout(pendingTimeoutId);\n            inWaitPeriod = false;\n            pendingExecutionWithParameters = undefined;\n        },\n    };\n}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() { }\n//# sourceMappingURL=functionUtils.js.map","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';\nimport { monitor } from './monitor';\nimport { getGlobalObject } from './getGlobalObject';\nexport function setTimeout(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay);\n}\nexport function clearTimeout(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);\n}\nexport function setInterval(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId);\n}\n//# sourceMappingURL=timer.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nimport { createHandlingStack } from './stackTrace/handlingStack';\n/**\n * Instruments a method on a object, calling the given callback before the original method is\n * invoked. The callback receives an object with information about the method call.\n *\n * This function makes sure that we are \"good citizens\" regarding third party instrumentations: when\n * removing the instrumentation, the original method is usually restored, but if a third party\n * instrumentation was set after ours, we keep it in place and just replace our instrumentation with\n * a noop.\n *\n * Note: it is generally better to instrument methods that are \"owned\" by the object instead of ones\n * that are inherited from the prototype chain. Example:\n * * do:    `instrumentMethod(Array.prototype, 'push', ...)`\n * * don't: `instrumentMethod([], 'push', ...)`\n *\n * This method is also used to set event handler properties (ex: window.onerror = ...), as it has\n * the same requirements as instrumenting a method:\n * * if the event handler is already set by a third party, we need to call it and not just blindly\n * override it.\n * * if the event handler is set by a third party after us, we need to keep it in place when\n * removing ours.\n *\n * @example\n *\n *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {\n *    console.log('Before calling fetch on', target, 'with parameters', parameters)\n *\n *    onPostCall((result) => {\n *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)\n *    })\n *  })\n */\nexport function instrumentMethod(targetPrototype, method, onPreCall, { computeHandlingStack } = {}) {\n    let original = targetPrototype[method];\n    if (typeof original !== 'function') {\n        if (method in targetPrototype && method.startsWith('on')) {\n            original = noop;\n        }\n        else {\n            return { stop: noop };\n        }\n    }\n    let stopped = false;\n    const instrumentation = function () {\n        if (stopped) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n            return original.apply(this, arguments);\n        }\n        const parameters = Array.from(arguments);\n        let postCallCallback;\n        callMonitored(onPreCall, null, [\n            {\n                target: this,\n                parameters,\n                onPostCall: (callback) => {\n                    postCallCallback = callback;\n                },\n                handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,\n            },\n        ]);\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        const result = original.apply(this, parameters);\n        if (postCallCallback) {\n            callMonitored(postCallCallback, null, [result]);\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return result;\n    };\n    targetPrototype[method] = instrumentation;\n    return {\n        stop: () => {\n            stopped = true;\n            // If the instrumentation has been removed by a third party, keep the last one\n            if (targetPrototype[method] === instrumentation) {\n                targetPrototype[method] = original;\n            }\n        },\n    };\n}\nexport function instrumentSetter(targetPrototype, property, after) {\n    const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    const stoppedInstrumentation = noop;\n    let instrumentation = (target, value) => {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(() => {\n            if (instrumentation !== stoppedInstrumentation) {\n                after(target, value);\n            }\n        }, 0);\n    };\n    const instrumentationWrapper = function (value) {\n        originalDescriptor.set.call(this, value);\n        instrumentation(this, value);\n    };\n    Object.defineProperty(targetPrototype, property, {\n        set: instrumentationWrapper,\n    });\n    return {\n        stop: () => {\n            var _a;\n            if (((_a = Object.getOwnPropertyDescriptor(targetPrototype, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n                Object.defineProperty(targetPrototype, property, originalDescriptor);\n            }\n            instrumentation = stoppedInstrumentation;\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { sanitize } from '../../tools/serialisation/sanitize';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nexport const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError({ stackTrace, originalError, handlingStack, componentStack, startClocks, nonErrorPrefix, source, handling, }) {\n    const isErrorInstance = isError(originalError);\n    const message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);\n    const stack = hasUsableStack(isErrorInstance, stackTrace)\n        ? toStackTraceString(stackTrace)\n        : NO_ERROR_STACK_PRESENT_MESSAGE;\n    const causes = isErrorInstance ? flattenErrorCauses(originalError, source) : undefined;\n    const type = stackTrace ? stackTrace.name : undefined;\n    const fingerprint = tryToGetFingerprint(originalError);\n    const context = tryToGetErrorContext(originalError);\n    return {\n        startClocks,\n        source,\n        handling,\n        handlingStack,\n        componentStack,\n        originalError,\n        type,\n        message,\n        stack,\n        causes,\n        fingerprint,\n        context,\n    };\n}\nfunction computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {\n    // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n    // TODO rework tracekit integration to avoid scattering error building logic\n    return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name)\n        ? stackTrace.message\n        : !isErrorInstance\n            ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))}`\n            : 'Empty message';\n}\nfunction hasUsableStack(isErrorInstance, stackTrace) {\n    if (stackTrace === undefined) {\n        return false;\n    }\n    if (isErrorInstance) {\n        return true;\n    }\n    // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]\n    // TODO rework tracekit integration to avoid generating those unusable stack\n    return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined);\n}\nexport function tryToGetFingerprint(originalError) {\n    return isError(originalError) && 'dd_fingerprint' in originalError ? String(originalError.dd_fingerprint) : undefined;\n}\nexport function tryToGetErrorContext(originalError) {\n    if (originalError !== null && typeof originalError === 'object' && 'dd_context' in originalError) {\n        return originalError.dd_context;\n    }\n}\nexport function getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function isError(error) {\n    return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]';\n}\nexport function flattenErrorCauses(error, parentSource) {\n    let currentError = error;\n    const causes = [];\n    while (isError(currentError === null || currentError === void 0 ? void 0 : currentError.cause) && causes.length < 10) {\n        const stackTrace = computeStackTrace(currentError.cause);\n        causes.push({\n            message: currentError.cause.message,\n            source: parentSource,\n            type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n            stack: stackTrace && toStackTraceString(stackTrace),\n        });\n        currentError = currentError.cause;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.js.map","import { setTimeout, clearTimeout } from './timer';\nimport { monitor } from './monitor';\nimport { dateNow } from './utils/timeUtils';\n/**\n * 'requestIdleCallback' with a shim.\n */\nexport function requestIdleCallback(callback, opts) {\n    // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n    if (window.requestIdleCallback && window.cancelIdleCallback) {\n        const id = window.requestIdleCallback(monitor(callback), opts);\n        return () => window.cancelIdleCallback(id);\n    }\n    return requestIdleCallbackShim(callback);\n}\nexport const MAX_TASK_TIME = 50;\n/*\n * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback\n * Note: there is no simple way to support the \"timeout\" option, so we ignore it.\n */\nexport function requestIdleCallbackShim(callback) {\n    const start = dateNow();\n    const timeoutId = setTimeout(() => {\n        callback({\n            didTimeout: false,\n            timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),\n        });\n    }, 0);\n    return () => clearTimeout(timeoutId);\n}\n//# sourceMappingURL=requestIdleCallback.js.map","export function isChromium() {\n    return detectBrowserCached() === 0 /* Browser.CHROMIUM */;\n}\nexport function isSafari() {\n    return detectBrowserCached() === 1 /* Browser.SAFARI */;\n}\nlet browserCache;\nfunction detectBrowserCached() {\n    return browserCache !== null && browserCache !== void 0 ? browserCache : (browserCache = detectBrowser());\n}\n// Exported only for tests\nexport function detectBrowser(browserWindow = window) {\n    var _a;\n    const userAgent = browserWindow.navigator.userAgent;\n    if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) {\n        return 0 /* Browser.CHROMIUM */;\n    }\n    if (\n    // navigator.vendor is deprecated, but it is the most resilient way we found to detect\n    // \"Apple maintained browsers\" (AKA Safari). If one day it gets removed, we still have the\n    // useragent test as a semi-working fallback.\n    ((_a = browserWindow.navigator.vendor) === null || _a === void 0 ? void 0 : _a.indexOf('Apple')) === 0 ||\n        (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))) {\n        return 1 /* Browser.SAFARI */;\n    }\n    return 2 /* Browser.OTHER */;\n}\n//# sourceMappingURL=browserDetection.js.map","/**\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//# sourceMappingURL=getGlobalObject.js.map","import { noop } from '../utils/functionUtils';\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n    if (typeof value !== 'object' || value === null) {\n        return JSON.stringify(value);\n    }\n    // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n    // subclasses.\n    const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    const restoreValueToJson = detachToJsonMethod(value);\n    try {\n        return JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        return '<error: unable to serialize object>';\n    }\n    finally {\n        restoreObjectPrototypeToJson();\n        restoreArrayPrototypeToJson();\n        restoreValuePrototypeToJson();\n        restoreValueToJson();\n    }\n}\nexport function detachToJsonMethod(value) {\n    const object = value;\n    const objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return () => {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\n//# sourceMappingURL=jsonStringify.js.map","import { callMonitored } from '../monitor';\nimport { computeStackTrace } from './computeStackTrace';\n/**\n * Creates a stacktrace without SDK internal frames.\n * Constraints:\n * - Has to be called at the utmost position of the call stack.\n * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack(type) {\n    /**\n     * Skip the two internal frames:\n     * - SDK API (console.error, ...)\n     * - this function\n     * in order to keep only the user calls\n     */\n    const internalFramesToSkip = 2;\n    const error = new Error(type);\n    error.name = 'HandlingStack';\n    let formattedStack;\n    callMonitored(() => {\n        const stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\nexport function toStackTraceString(stack) {\n    let result = formatErrorMessage(stack);\n    stack.stack.forEach((frame) => {\n        const func = frame.func === '?' ? '<anonymous>' : frame.func;\n        const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : '';\n        const line = frame.line ? `:${frame.line}` : '';\n        const column = frame.line && frame.column ? `:${frame.column}` : '';\n        result += `\\n  at ${func}${args} @ ${frame.url}${line}${column}`;\n    });\n    return result;\n}\nexport function formatErrorMessage(stack) {\n    return `${stack.name || 'Error'}: ${stack.message}`;\n}\n//# sourceMappingURL=handlingStack.js.map","import { jsonStringify } from '../serialisation/jsonStringify';\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 supportedURL = getSupportedUrl();\n    if (supportedURL) {\n        try {\n            return base !== undefined ? new supportedURL(url, base) : new supportedURL(url);\n        }\n        catch (error) {\n            throw new Error(`Failed to construct URL: ${String(error)} ${jsonStringify({ url, base })}`);\n        }\n    }\n    if (base === undefined && !/:/.test(url)) {\n        throw new Error(`Invalid URL: '${url}'`);\n    }\n    let doc = document;\n    const anchorElement = doc.createElement('a');\n    if (base !== undefined) {\n        doc = document.implementation.createHTMLDocument('');\n        const baseElement = doc.createElement('base');\n        baseElement.href = base;\n        doc.head.appendChild(baseElement);\n        doc.body.appendChild(anchorElement);\n    }\n    anchorElement.href = url;\n    return anchorElement;\n}\nconst originalURL = URL;\nlet isURLSupported;\nfunction getSupportedUrl() {\n    if (isURLSupported === undefined) {\n        try {\n            const url = new originalURL('http://test/path');\n            isURLSupported = url.href === 'http://test/path';\n        }\n        catch (_a) {\n            isURLSupported = false;\n        }\n    }\n    return isURLSupported ? originalURL : undefined;\n}\n//# sourceMappingURL=urlPolyfill.js.map","import { getGlobalObject } from '../tools/getGlobalObject';\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 { 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 = 3 * 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) {\n    if (state.transportStatus === 0 /* TransportStatus.UP */ &&\n        state.queuedPayloads.size() === 0 &&\n        state.bandwidthMonitor.canHandle(payload)) {\n        send(payload, state, sendStrategy, {\n            onSuccess: () => retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, trackType, reportError),\n            onFailure: () => {\n                state.queuedPayloads.enqueue(payload);\n                scheduleRetry(state, sendStrategy, trackType, reportError);\n            },\n        });\n    }\n    else {\n        state.queuedPayloads.enqueue(payload);\n    }\n}\nfunction scheduleRetry(state, sendStrategy, trackType, reportError) {\n    if (state.transportStatus !== 2 /* TransportStatus.DOWN */) {\n        return;\n    }\n    setTimeout(() => {\n        const payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, {\n            onSuccess: () => {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, trackType, reportError);\n            },\n            onFailure: () => {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, trackType, reportError);\n            },\n        });\n    }, state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, { 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            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            onFailure();\n        }\n    });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError) {\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);\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;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\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    };\n}\n//# sourceMappingURL=sendWithRetryStrategy.js.map","import { addTelemetryError } from '../domain/telemetry';\nimport { monitor } from '../tools/monitor';\nimport { addEventListener } from '../browser/addEventListener';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(endpointBuilder, bytesLimit, reportError) {\n    const retryState = newRetryState();\n    const sendStrategyForRetry = (payload, onResponse) => fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse);\n    return {\n        send: (payload) => {\n            sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.trackType, reportError);\n        },\n        /**\n         * Since fetch keepalive behaves like regular fetch on Firefox,\n         * keep using sendBeaconStrategy on exit\n         */\n        sendOnExit: (payload) => {\n            sendBeaconStrategy(endpointBuilder, bytesLimit, payload);\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    const xhrUrl = endpointBuilder.build('xhr', payload);\n    sendXHR(xhrUrl, payload.data);\n}\nlet hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse) {\n    const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        const fetchUrl = endpointBuilder.build('fetch', payload);\n        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(monitor((response) => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type })), monitor(() => {\n            const xhrUrl = endpointBuilder.build('xhr', payload);\n            // failed to queue the request\n            sendXHR(xhrUrl, payload.data, onResponse);\n        }));\n    }\n    else {\n        const xhrUrl = endpointBuilder.build('xhr', payload);\n        sendXHR(xhrUrl, payload.data, onResponse);\n    }\n}\nfunction isKeepAliveSupported() {\n    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n    try {\n        return window.Request && 'keepalive' in new Request('http://a');\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function sendXHR(url, data, onResponse) {\n    const request = new XMLHttpRequest();\n    request.open('POST', url, true);\n    if (data instanceof Blob) {\n        // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header\n        // automatically, so the intake request ends up being rejected with an HTTP status 415\n        // Defining the header manually fixes this issue.\n        request.setRequestHeader('Content-Type', data.type);\n    }\n    addEventListener(\n    // allow untrusted event to acount for synthetic event dispatched by third party xhr wrapper\n    { allowUntrustedEvents: true }, request, 'loadend', () => {\n        onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: request.status });\n    }, {\n        // prevent multiple onResponse callbacks\n        // if the xhr instance is reused by a third party\n        once: true,\n    });\n    request.send(data);\n}\n//# sourceMappingURL=httpRequest.js.map","export const ONE_KIBI_BYTE = 1024;\nexport const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nconst HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n    // Accurate bytes count computations can degrade performances when there is a lot of events to process\n    if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n        return candidate.length;\n    }\n    if (window.TextEncoder !== undefined) {\n        return new TextEncoder().encode(candidate).length;\n    }\n    return new Blob([candidate]).size;\n}\nexport function concatBuffers(buffers) {\n    const length = buffers.reduce((total, buffer) => total + buffer.length, 0);\n    const result = new Uint8Array(length);\n    let offset = 0;\n    for (const buffer of buffers) {\n        result.set(buffer, offset);\n        offset += buffer.length;\n    }\n    return result;\n}\n//# sourceMappingURL=byteUtils.js.map","import { getGlobalObject } from './getGlobalObject';\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n    const browserWindow = getGlobalObject();\n    let original;\n    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n        original = target[browserWindow.Zone.__symbol__(name)];\n    }\n    if (!original) {\n        original = target[name];\n    }\n    return original;\n}\n//# sourceMappingURL=getZoneJsOriginalValue.js.map","export const TelemetryType = {\n    log: 'log',\n    configuration: 'configuration',\n    usage: 'usage',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } 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 { createBoundedBuffer } from '../../tools/boundedBuffer';\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 TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\n// eslint-disable-next-line local-rules/disallow-side-effects\nlet preStartTelemetryBuffer = createBoundedBuffer();\nlet onRawTelemetryEventCollected = (event) => {\n    preStartTelemetryBuffer.add(() => onRawTelemetryEventCollected(event));\n};\nexport function startTelemetry(telemetryService, configuration) {\n    let contextProvider;\n    const observable = new Observable();\n    const alreadySentEvents = new Set();\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    };\n    const runtimeEnvInfo = getRuntimeEnvInfo();\n    onRawTelemetryEventCollected = (rawEvent) => {\n        const stringifiedEvent = jsonStringify(rawEvent);\n        if (telemetryEnabledPerType[rawEvent.type] &&\n            alreadySentEvents.size < configuration.maxTelemetryEventsPerPage &&\n            !alreadySentEvents.has(stringifiedEvent)) {\n            const event = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo);\n            observable.notify(event);\n            sendToExtension('telemetry', event);\n            alreadySentEvents.add(stringifiedEvent);\n        }\n    };\n    startMonitorErrorCollection(addTelemetryError);\n    function toTelemetryEvent(telemetryService, event, runtimeEnvInfo) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: telemetryService,\n            version: \"6.5.1\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: combine(event, {\n                runtime_env: runtimeEnvInfo,\n                connectivity: getConnectivity(),\n                sdk_setup: \"npm\",\n            }),\n            experimental_features: Array.from(getExperimentalFeatures()),\n        }, contextProvider !== undefined ? contextProvider() : {});\n    }\n    return {\n        setContextProvider: (provider) => {\n            contextProvider = provider;\n        },\n        observable,\n        enabled: telemetryEnabled,\n    };\n}\nfunction getRuntimeEnvInfo() {\n    return {\n        is_local_file: window.location.protocol === 'file:',\n        is_worker: 'WorkerGlobalScope' in self,\n    };\n}\nexport function startFakeTelemetry() {\n    const events = [];\n    onRawTelemetryEventCollected = (event) => {\n        events.push(event);\n    };\n    return events;\n}\n// need to be called after telemetry context is provided and observers are registered\nexport function drainPreStartTelemetry() {\n    preStartTelemetryBuffer.drain();\n}\nexport function resetTelemetry() {\n    preStartTelemetryBuffer = createBoundedBuffer();\n    onRawTelemetryEventCollected = (event) => {\n        preStartTelemetryBuffer.add(() => onRawTelemetryEventCollected(event));\n    };\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nexport function isTelemetryReplicationAllowed(configuration) {\n    return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n    displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n    onRawTelemetryEventCollected({\n        type: TelemetryType.log,\n        message,\n        status: \"debug\" /* StatusType.debug */,\n        ...context,\n    });\n}\nexport function addTelemetryError(e, context) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.log,\n        status: \"error\" /* StatusType.error */,\n        ...formatError(e),\n        ...context,\n    });\n}\nexport function addTelemetryConfiguration(configuration) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.configuration,\n        configuration,\n    });\n}\nexport function addTelemetryUsage(usage) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.usage,\n        usage,\n    });\n}\nexport function formatError(e) {\n    if (isError(e)) {\n        const stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(scrubCustomerFrames(stackTrace)),\n            },\n            message: stackTrace.message,\n        };\n    }\n    return {\n        error: {\n            stack: NO_ERROR_STACK_PRESENT_MESSAGE,\n        },\n        message: `${\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */} ${jsonStringify(e)}`,\n    };\n}\nexport function scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter((frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => frame.url.startsWith(allowedFrameUrl)));\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { getType } from './utils/typeUtils';\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker = createCircularReferenceChecker()) {\n    // ignore the source if it is undefined\n    if (source === undefined) {\n        return destination;\n    }\n    if (typeof source !== 'object' || source === null) {\n        // primitive values - just return source\n        return source;\n    }\n    else if (source instanceof Date) {\n        return new Date(source.getTime());\n    }\n    else if (source instanceof RegExp) {\n        const flags = source.flags ||\n            // old browsers compatibility\n            [\n                source.global ? 'g' : '',\n                source.ignoreCase ? 'i' : '',\n                source.multiline ? 'm' : '',\n                source.sticky ? 'y' : '',\n                source.unicode ? 'u' : '',\n            ].join('');\n        return new RegExp(source.source, flags);\n    }\n    if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n        // remove circular references\n        return undefined;\n    }\n    else if (Array.isArray(source)) {\n        const merged = Array.isArray(destination) ? destination : [];\n        for (let i = 0; i < source.length; ++i) {\n            merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker);\n        }\n        return merged;\n    }\n    const merged = getType(destination) === 'object' ? destination : {};\n    for (const key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n            merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);\n        }\n    }\n    return merged;\n}\n/**\n * A simplistic implementation of a deep clone algorithm.\n * Caveats:\n * - It doesn't maintain prototype chains - don't use with instances of custom classes.\n * - It doesn't handle Map and Set\n */\nexport function deepClone(value) {\n    return mergeInto(undefined, value);\n}\nexport function combine(...sources) {\n    let destination;\n    for (const source of sources) {\n        // Ignore any undefined or null sources.\n        if (source === undefined || source === null) {\n            continue;\n        }\n        destination = mergeInto(destination, source);\n    }\n    return destination;\n}\nfunction createCircularReferenceChecker() {\n    if (typeof WeakSet !== 'undefined') {\n        const set = new WeakSet();\n        return {\n            hasAlreadyBeenSeen(value) {\n                const has = set.has(value);\n                if (!has) {\n                    set.add(value);\n                }\n                return has;\n            },\n        };\n    }\n    const array = [];\n    return {\n        hasAlreadyBeenSeen(value) {\n            const has = array.indexOf(value) >= 0;\n            if (!has) {\n                array.push(value);\n            }\n            return has;\n        },\n    };\n}\n//# sourceMappingURL=mergeInto.js.map","export function shallowClone(object) {\n    return { ...object };\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some((key) => object[key] === value);\n}\nexport function isEmptyObject(object) {\n    return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n    const newObject = {};\n    for (const key of Object.keys(object)) {\n        newObject[key] = fn(object[key]);\n    }\n    return newObject;\n}\n//# sourceMappingURL=objectUtils.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { display } from '../tools/display';\nexport function makePublicApi(stub) {\n    const publicApi = {\n        version: \"6.5.1\",\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 { removeItem } from './utils/arrayUtils';\nconst BUFFER_LIMIT = 500;\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","export const ErrorSource = {\n    AGENT: 'agent',\n    CONSOLE: 'console',\n    CUSTOM: 'custom',\n    LOGGER: 'logger',\n    NETWORK: 'network',\n    SOURCE: 'source',\n    REPORT: 'report',\n};\n//# sourceMappingURL=error.types.js.map","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\nconst UNKNOWN_FUNCTION = '?';\nexport function computeStackTrace(ex) {\n    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    return {\n        message: tryToGetString(ex, 'message'),\n        name: tryToGetString(ex, 'name'),\n        stack,\n    };\n}\nconst fileUrl = '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nconst filePosition = '(?::(\\\\d+))';\nconst CHROME_LINE_RE = new RegExp(`^\\\\s*at (.*?) ?\\\\(${fileUrl}${filePosition}?${filePosition}?\\\\)?\\\\s*$`, 'i');\nconst CHROME_EVAL_RE = new RegExp(`\\\\((\\\\S*)${filePosition}${filePosition}\\\\)`);\nfunction parseChromeLine(line) {\n    const parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    const submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = submatch[1]; // url\n        parts[3] = submatch[2]; // line\n        parts[4] = submatch[3]; // column\n    }\n    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nconst CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\\\s*at ?${fileUrl}${filePosition}?${filePosition}??\\\\s*$`, 'i');\nfunction parseChromeAnonymousLine(line) {\n    const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[3] ? +parts[3] : undefined,\n        func: UNKNOWN_FUNCTION,\n        line: parts[2] ? +parts[2] : undefined,\n        url: parts[1],\n    };\n}\nconst WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    const parts = WINJS_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: +parts[3],\n        url: parts[2],\n    };\n}\nconst GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    const parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    const submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    const value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\nexport function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {\n    const stack = [{ url, column, line }];\n    const { name, message } = tryToParseMessage(messageObj);\n    return {\n        name,\n        message,\n        stack,\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//# sourceMappingURL=computeStackTrace.js.map","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n    return (...args) => {\n        try {\n            return fn(...args);\n        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","/**\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[\"WRITABLE_RESOURCE_GRAPHQL\"] = \"writable_resource_graphql\";\n    ExperimentalFeature[\"MISSING_URL_CONTEXT_TELEMETRY\"] = \"missing_url_context_telemetry\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nconst enabledExperimentalFeatures = new Set();\nexport function initFeatureFlags(enableExperimentalFeatures) {\n    if (Array.isArray(enableExperimentalFeatures)) {\n        addExperimentalFeatures(enableExperimentalFeatures.filter((flag) => objectHasValue(ExperimentalFeature, flag)));\n    }\n}\nexport function addExperimentalFeatures(enabledFeatures) {\n    enabledFeatures.forEach((flag) => {\n        enabledExperimentalFeatures.add(flag);\n    });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n    return enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n    enabledExperimentalFeatures.clear();\n}\nexport function getExperimentalFeatures() {\n    return enabledExperimentalFeatures;\n}\n//# sourceMappingURL=experimentalFeatures.js.map","/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n    return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n    return +num.toFixed(decimals);\n}\nexport function isPercentage(value) {\n    return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n    return typeof value === 'number';\n}\n//# sourceMappingURL=numberUtils.js.map","import { isNumber, round } from './numberUtils';\nexport const ONE_SECOND = 1000;\nexport const ONE_MINUTE = 60 * ONE_SECOND;\nexport const ONE_HOUR = 60 * ONE_MINUTE;\nexport const ONE_DAY = 24 * ONE_HOUR;\nexport const ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n    return { relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nexport function timeStampToClocks(timeStamp) {\n    return { relative: getRelativeTime(timeStamp), timeStamp };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    const correctedOrigin = (dateNow() - performance.now());\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        return Math.round(addDuration(correctedOrigin, relativeTime));\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now()));\n}\nexport function toServerDuration(duration) {\n    if (!isNumber(duration)) {\n        return duration;\n    }\n    return round(duration * 1e6, 0);\n}\nexport function dateNow() {\n    // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n    // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n    // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n    // case ourselves.\n    // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n    return new Date().getTime();\n}\nexport function timeStampNow() {\n    return dateNow();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { relative: relativeNow(), timeStamp: timeStampNow() };\n}\nexport function clocksOrigin() {\n    return { relative: 0, timeStamp: getNavigationStart() };\n}\nexport function elapsed(start, end) {\n    return (end - start);\n}\nexport function addDuration(a, b) {\n    return a + b;\n}\n// Get the time since the navigation was started.\nexport function getRelativeTime(timestamp) {\n    return (timestamp - getNavigationStart());\n}\nexport function getTimeStamp(relativeTime) {\n    return Math.round(addDuration(getNavigationStart(), relativeTime));\n}\nexport function looksLikeRelativeTime(time) {\n    return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nlet navigationStart;\n/**\n * Notes: this does not use `performance.timeOrigin` because:\n * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,\n * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)\n * - It is not supported in Safari <15\n */\nfunction getNavigationStart() {\n    if (navigationStart === undefined) {\n        navigationStart = performance.timing.navigationStart;\n    }\n    return navigationStart;\n}\n//# sourceMappingURL=timeUtils.js.map","import { Observable } from '../tools/observable';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { addEventListeners, addEventListener } from './addEventListener';\nexport const PageExitReason = {\n    HIDDEN: 'visibility_hidden',\n    UNLOADING: 'before_unload',\n    PAGEHIDE: 'page_hide',\n    FROZEN: 'page_frozen',\n};\nexport function createPageExitObservable(configuration) {\n    return new Observable((observable) => {\n        const { stop: stopListeners } = addEventListeners(configuration, window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */], (event) => {\n            if (event.type === \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */ && document.visibilityState === 'hidden') {\n                /**\n                 * Only event that guarantee to fire on mobile devices when the page transitions to background state\n                 * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n                 */\n                observable.notify({ reason: PageExitReason.HIDDEN });\n            }\n            else if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n                /**\n                 * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n                 * Allow to collect events happening between hidden and frozen state.\n                 */\n                observable.notify({ reason: PageExitReason.FROZEN });\n            }\n        }, { capture: true });\n        const stopBeforeUnloadListener = addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, () => {\n            observable.notify({ reason: PageExitReason.UNLOADING });\n        }).stop;\n        return () => {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n}\nexport function isPageExitReason(reason) {\n    return objectValues(PageExitReason).includes(reason);\n}\n//# sourceMappingURL=pageExitObservable.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","// 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](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))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import { addEventListener, addTelemetryDebug, concatBuffers } from '@datadog/browser-core';\nexport function createDeflateEncoder(configuration, worker, streamId) {\n    let rawBytesCount = 0;\n    let compressedData = [];\n    let compressedDataTrailer;\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        rawBytesCount += workerResponse.additionalBytesCount;\n        compressedData.push(workerResponse.result);\n        compressedDataTrailer = workerResponse.trailer;\n        const nextPendingAction = pendingWriteActions.shift();\n        if (nextPendingAction && nextPendingAction.id === workerResponse.id) {\n            if (nextPendingAction.writeCallback) {\n                nextPendingAction.writeCallback(workerResponse.result.byteLength);\n            }\n            else if (nextPendingAction.finishCallback) {\n                nextPendingAction.finishCallback();\n            }\n        }\n        else {\n            removeMessageListener();\n            addTelemetryDebug('Worker responses received out of order.');\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 (nextWriteActionId > 0) {\n            worker.postMessage({\n                action: 'reset',\n                streamId,\n            });\n            nextWriteActionId = 0;\n        }\n    }\n    return {\n        isAsync: true,\n        get isEmpty() {\n            return nextWriteActionId === 0;\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            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\n                .map((pendingWriteAction) => {\n                // Make sure we do not call any write or finish callback\n                delete pendingWriteAction.writeCallback;\n                delete pendingWriteAction.finishCallback;\n                return pendingWriteAction.data;\n            })\n                .join('');\n            return { ...consumeResult(), pendingData };\n        },\n        estimateEncodedBytesCount(data) {\n            // This is a rough estimation of the data size once it'll be encoded by deflate. We observed\n            // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but\n            // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce\n            // requests of the expected size.\n            return data.length / 8;\n        },\n        stop() {\n            removeMessageListener();\n        },\n    };\n}\n//# sourceMappingURL=deflateEncoder.js.map","import { addTelemetryError, display, DOCS_ORIGIN } from '@datadog/browser-core';\nexport function reportScriptLoadingError({ configuredUrl, error, source, scriptType, }) {\n    display.error(`${source} failed to start: an error occurred while initializing the ${scriptType}:`, error);\n    if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n        let baseMessage;\n        if (configuredUrl) {\n            baseMessage = `Please make sure the ${scriptType} URL ${configuredUrl} is correct and CSP is correctly configured.`;\n        }\n        else {\n            baseMessage = 'Please make sure CSP is correctly configured.';\n        }\n        display.error(`${baseMessage} See documentation at ${DOCS_ORIGIN}/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay`);\n    }\n    else if (scriptType === 'worker') {\n        addTelemetryError(error);\n    }\n}\nfunction isMessageCspRelated(message) {\n    return (message.includes('Content Security Policy') ||\n        // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n        message.includes(\"requires 'TrustedScriptURL'\"));\n}\n//# sourceMappingURL=scriptLoadingError.js.map","import { addTelemetryError, display, addEventListener, setTimeout, ONE_SECOND } from '@datadog/browser-core';\nimport { reportScriptLoadingError } from '../scriptLoadingError';\nexport const INITIALIZATION_TIME_OUT_DELAY = 30 * ONE_SECOND;\nfunction createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"(()=>{\\\"use strict\\\";function t(t){const e=t.reduce(((t,e)=>t+e.length),0),a=new Uint8Array(e);let n=0;for(const e of t)a.set(e,n),n+=e.length;return a}function e(t){for(var e=t.length;--e>=0;)t[e]=0}var a=256,n=286,r=30,i=15,s=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]),h=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]),l=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),_=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),o=new Array(576);e(o);var d=new Array(60);e(d);var u=new Array(512);e(u);var f=new Array(256);e(f);var c=new Array(29);e(c);var p,g,w,v=new Array(r);function b(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 m(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}e(v);var y=function(t){return t<256?u[t]:u[256+(t>>>7)]},k=function(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},z=function(t,e,a){t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,k(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)},x=function(t,e,a){z(t,a[2*e],a[2*e+1])},A=function(t,e){var a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},U=function(t,e,a){var n,r,s=new Array(16),h=0;for(n=1;n<=i;n++)s[n]=h=h+a[n-1]<<1;for(r=0;r<=e;r++){var l=t[2*r+1];0!==l&&(t[2*r]=A(s[l]++,l))}},I=function(t){var e;for(e=0;e<n;e++)t.dyn_ltree[2*e]=0;for(e=0;e<r;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},B=function(t){t.bi_valid>8?k(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},E=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]},S=function(t,e,a){for(var n=t.heap[a],r=a<<1;r<=t.heap_len&&(r<t.heap_len&&E(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!E(e,n,t.heap[r],t.depth));)t.heap[a]=t.heap[r],a=r,r<<=1;t.heap[a]=n},C=function(t,e,n){var r,i,l,_,o=0;if(0!==t.last_lit)do{r=t.pending_buf[t.d_buf+2*o]<<8|t.pending_buf[t.d_buf+2*o+1],i=t.pending_buf[t.l_buf+o],o++,0===r?x(t,i,e):(l=f[i],x(t,l+a+1,e),0!==(_=s[l])&&(i-=c[l],z(t,i,_)),r--,l=y(r),x(t,l,n),0!==(_=h[l])&&(r-=v[l],z(t,r,_)))}while(o<t.last_lit);x(t,256,e)},D=function(t,e){var a,n,r,s=e.dyn_tree,h=e.stat_desc.static_tree,l=e.stat_desc.has_stree,_=e.stat_desc.elems,o=-1;for(t.heap_len=0,t.heap_max=573,a=0;a<_;a++)0!==s[2*a]?(t.heap[++t.heap_len]=o=a,t.depth[a]=0):s[2*a+1]=0;for(;t.heap_len<2;)s[2*(r=t.heap[++t.heap_len]=o<2?++o:0)]=1,t.depth[r]=0,t.opt_len--,l&&(t.static_len-=h[2*r+1]);for(e.max_code=o,a=t.heap_len>>1;a>=1;a--)S(t,s,a);r=_;do{a=t.heap[1],t.heap[1]=t.heap[t.heap_len--],S(t,s,1),n=t.heap[1],t.heap[--t.heap_max]=a,t.heap[--t.heap_max]=n,s[2*r]=s[2*a]+s[2*n],t.depth[r]=(t.depth[a]>=t.depth[n]?t.depth[a]:t.depth[n])+1,s[2*a+1]=s[2*n+1]=r,t.heap[1]=r++,S(t,s,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var a,n,r,s,h,l,_=e.dyn_tree,o=e.max_code,d=e.stat_desc.static_tree,u=e.stat_desc.has_stree,f=e.stat_desc.extra_bits,c=e.stat_desc.extra_base,p=e.stat_desc.max_length,g=0;for(s=0;s<=i;s++)t.bl_count[s]=0;for(_[2*t.heap[t.heap_max]+1]=0,a=t.heap_max+1;a<573;a++)(s=_[2*_[2*(n=t.heap[a])+1]+1]+1)>p&&(s=p,g++),_[2*n+1]=s,n>o||(t.bl_count[s]++,h=0,n>=c&&(h=f[n-c]),l=_[2*n],t.opt_len+=l*(s+h),u&&(t.static_len+=l*(d[2*n+1]+h)));if(0!==g){do{for(s=p-1;0===t.bl_count[s];)s--;t.bl_count[s]--,t.bl_count[s+1]+=2,t.bl_count[p]--,g-=2}while(g>0);for(s=p;0!==s;s--)for(n=t.bl_count[s];0!==n;)(r=t.heap[--a])>o||(_[2*r+1]!==s&&(t.opt_len+=(s-_[2*r+1])*_[2*r],_[2*r+1]=s),n--)}}(t,e),U(s,o,t.bl_count)},j=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))},M=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{x(t,r,t.bl_tree)}while(0!=--h);else 0!==r?(r!==i&&(x(t,r,t.bl_tree),h--),x(t,16,t.bl_tree),z(t,h-3,2)):h<=10?(x(t,17,t.bl_tree),z(t,h-3,3)):(x(t,18,t.bl_tree),z(t,h-11,7));h=0,i=r,0===s?(l=138,_=3):r===s?(l=6,_=3):(l=7,_=4)}},L=!1,T=function(t,e,a,n){z(t,0+(n?1:0),3),function(t,e,a,n){B(t),n&&(k(t,a),k(t,~a)),t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a}(t,e,a,!0)},H=function(t,e,n,r){var i,s,h=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=function(t){var e,n=4093624447;for(e=0;e<=31;e++,n>>>=1)if(1&n&&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<a;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0}(t)),D(t,t.l_desc),D(t,t.d_desc),h=function(t){var e;for(j(t,t.dyn_ltree,t.l_desc.max_code),j(t,t.dyn_dtree,t.d_desc.max_code),D(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*_[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e}(t),i=t.opt_len+3+7>>>3,(s=t.static_len+3+7>>>3)<=i&&(i=s)):i=s=n+5,n+4<=i&&-1!==e?T(t,e,n,r):4===t.strategy||s===i?(z(t,2+(r?1:0),3),C(t,o,d)):(z(t,4+(r?1:0),3),function(t,e,a,n){var r;for(z(t,e-257,5),z(t,a-1,5),z(t,n-4,4),r=0;r<n;r++)z(t,t.bl_tree[2*_[r]+1],3);M(t,t.dyn_ltree,e-1),M(t,t.dyn_dtree,a-1)}(t,t.l_desc.max_code+1,t.d_desc.max_code+1,h+1),C(t,t.dyn_ltree,t.dyn_dtree)),I(t),r&&B(t)},R={_tr_init:function(t){L||(!function(){var t,e,a,_,m,y=new Array(16);for(a=0,_=0;_<28;_++)for(c[_]=a,t=0;t<1<<s[_];t++)f[a++]=_;for(f[a-1]=_,m=0,_=0;_<16;_++)for(v[_]=m,t=0;t<1<<h[_];t++)u[m++]=_;for(m>>=7;_<r;_++)for(v[_]=m<<7,t=0;t<1<<h[_]-7;t++)u[256+m++]=_;for(e=0;e<=i;e++)y[e]=0;for(t=0;t<=143;)o[2*t+1]=8,t++,y[8]++;for(;t<=255;)o[2*t+1]=9,t++,y[9]++;for(;t<=279;)o[2*t+1]=7,t++,y[7]++;for(;t<=287;)o[2*t+1]=8,t++,y[8]++;for(U(o,287,y),t=0;t<r;t++)d[2*t+1]=5,d[2*t]=A(t,5);p=new b(o,s,257,n,i),g=new b(d,h,0,r,i),w=new b(new Array(0),l,0,19,7)}(),L=!0),t.l_desc=new m(t.dyn_ltree,p),t.d_desc=new m(t.dyn_dtree,g),t.bl_desc=new m(t.bl_tree,w),t.bi_buf=0,t.bi_valid=0,I(t)},_tr_stored_block:T,_tr_flush_block:H,_tr_tally:function(t,e,n){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&n,t.last_lit++,0===e?t.dyn_ltree[2*n]++:(t.matches++,e--,t.dyn_ltree[2*(f[n]+a+1)]++,t.dyn_dtree[2*y(e)]++),t.last_lit===t.lit_bufsize-1},_tr_align:function(t){z(t,2,3),x(t,256,o),function(t){16===t.bi_valid?(k(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)}},K=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},N=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}()),O=function(t,e,a,n){var r=N,i=n+a;t^=-1;for(var s=n;s<i;s++)t=t>>>8^r[255&(t^e[s])];return~t},q={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\\\"},F=0,G=2,J=3,P=4,Q=0,V=1,W=-1,X=0,Y=8,Z=R._tr_init,$=R._tr_stored_block,tt=R._tr_flush_block,et=R._tr_tally,at=R._tr_align,nt=F,rt=1,it=J,st=P,ht=5,lt=Q,_t=V,ot=-2,dt=-3,ut=-5,ft=W,ct=1,pt=2,gt=3,wt=4,vt=X,bt=2,mt=Y,yt=258,kt=262,zt=103,xt=113,At=666,Ut=function(t,e){return t.msg=q[e],e},It=function(t){return(t<<1)-(t>4?9:0)},Bt=function(t){for(var e=t.length;--e>=0;)t[e]=0},Et=function(t,e,a){return(e<<t.hash_shift^a)&t.hash_mask},St=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))},Ct=function(t,e){tt(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,St(t.strm)},Dt=function(t,e){t.pending_buf[t.pending++]=e},jt=function(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},Mt=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-kt?t.strstart-(t.w_size-kt):0,_=t.window,o=t.w_mask,d=t.prev,u=t.strstart+yt,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=yt-(u-i),i=u-yt,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},Lt=function(t){var e,a,n,r,i,s,h,l,_,o,d=t.w_size;do{if(r=t.window_size-t.lookahead-t.strstart,t.strstart>=d+(d-kt)){t.window.set(t.window.subarray(d,d+d),0),t.match_start-=d,t.strstart-=d,t.block_start-=d,e=a=t.hash_size;do{n=t.head[--e],t.head[e]=n>=d?n-d:0}while(--a);e=a=d;do{n=t.prev[--e],t.prev[e]=n>=d?n-d:0}while(--a);r+=d}if(0===t.strm.avail_in)break;if(s=t.strm,h=t.window,l=t.strstart+t.lookahead,_=r,o=void 0,(o=s.avail_in)>_&&(o=_),a=0===o?0:(s.avail_in-=o,h.set(s.input.subarray(s.next_in,s.next_in+o),l),1===s.state.wrap?s.adler=K(s.adler,h,o,l):2===s.state.wrap&&(s.adler=O(s.adler,h,o,l)),s.next_in+=o,s.total_in+=o,o),t.lookahead+=a,t.lookahead+t.insert>=3)for(i=t.strstart-t.insert,t.ins_h=t.window[i],t.ins_h=Et(t,t.ins_h,t.window[i+1]);t.insert&&(t.ins_h=Et(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<kt&&0!==t.strm.avail_in)},Tt=function(t,e){for(var a,n;;){if(t.lookahead<kt){if(Lt(t),t.lookahead<kt&&e===nt)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=Et(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-kt&&(t.match_length=Mt(t,a)),t.match_length>=3)if(n=et(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=Et(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=Et(t,t.ins_h,t.window[t.strstart+1]);else n=et(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(n&&(Ct(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===st?(Ct(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Ct(t,!1),0===t.strm.avail_out)?1:2},Ht=function(t,e){for(var a,n,r;;){if(t.lookahead<kt){if(Lt(t),t.lookahead<kt&&e===nt)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=Et(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-kt&&(t.match_length=Mt(t,a),t.match_length<=5&&(t.strategy===ct||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=et(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=Et(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&&(Ct(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if((n=et(t,0,t.window[t.strstart-1]))&&Ct(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=et(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===st?(Ct(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Ct(t,!1),0===t.strm.avail_out)?1:2};function Rt(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 Kt=[new Rt(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(Lt(t),0===t.lookahead&&e===nt)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,Ct(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-kt&&(Ct(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===st?(Ct(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(Ct(t,!1),t.strm.avail_out),1)})),new Rt(4,4,8,4,Tt),new Rt(4,5,16,8,Tt),new Rt(4,6,32,32,Tt),new Rt(4,4,16,16,Ht),new Rt(8,16,32,32,Ht),new Rt(8,16,128,128,Ht),new Rt(8,32,128,256,Ht),new Rt(32,128,258,1024,Ht),new Rt(32,258,258,4096,Ht)];function Nt(){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=mt,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),Bt(this.dyn_ltree),Bt(this.dyn_dtree),Bt(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),Bt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),Bt(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}var Ot=function(t){if(!t||!t.state)return Ut(t,ot);t.total_in=t.total_out=0,t.data_type=bt;var e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:xt,t.adler=2===e.wrap?0:1,e.last_flush=nt,Z(e),lt},qt=function(t){var e,a=Ot(t);return a===lt&&((e=t.state).window_size=2*e.w_size,Bt(e.head),e.max_lazy_match=Kt[e.level].max_lazy,e.good_match=Kt[e.level].good_length,e.nice_match=Kt[e.level].nice_length,e.max_chain_length=Kt[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),a},Ft=function(t,e,a,n,r,i){if(!t)return ot;var s=1;if(e===ft&&(e=6),n<0?(s=0,n=-n):n>15&&(s=2,n-=16),r<1||r>9||a!==mt||n<8||n>15||e<0||e>9||i<0||i>wt)return Ut(t,ot);8===n&&(n=9);var h=new Nt;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,qt(t)},Gt={deflateInit:function(t,e){return Ft(t,e,mt,15,8,vt)},deflateInit2:Ft,deflateReset:qt,deflateResetKeep:Ot,deflateSetHeader:function(t,e){return t&&t.state?2!==t.state.wrap?ot:(t.state.gzhead=e,lt):ot},deflate:function(t,e){var a,n;if(!t||!t.state||e>ht||e<0)return t?Ut(t,ot):ot;var r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===At&&e!==st)return Ut(t,0===t.avail_out?ut:ot);r.strm=t;var i=r.last_flush;if(r.last_flush=e,42===r.status)if(2===r.wrap)t.adler=0,Dt(r,31),Dt(r,139),Dt(r,8),r.gzhead?(Dt(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)),Dt(r,255&r.gzhead.time),Dt(r,r.gzhead.time>>8&255),Dt(r,r.gzhead.time>>16&255),Dt(r,r.gzhead.time>>24&255),Dt(r,9===r.level?2:r.strategy>=pt||r.level<2?4:0),Dt(r,255&r.gzhead.os),r.gzhead.extra&&r.gzhead.extra.length&&(Dt(r,255&r.gzhead.extra.length),Dt(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(t.adler=O(t.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=69):(Dt(r,0),Dt(r,0),Dt(r,0),Dt(r,0),Dt(r,0),Dt(r,9===r.level?2:r.strategy>=pt||r.level<2?4:0),Dt(r,3),r.status=xt);else{var s=mt+(r.w_bits-8<<4)<<8;s|=(r.strategy>=pt||r.level<2?0:r.level<6?1:6===r.level?2:3)<<6,0!==r.strstart&&(s|=32),s+=31-s%31,r.status=xt,jt(r,s),0!==r.strstart&&(jt(r,t.adler>>>16),jt(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=O(t.adler,r.pending_buf,r.pending-a,a)),St(t),a=r.pending,r.pending!==r.pending_buf_size));)Dt(r,255&r.gzhead.extra[r.gzindex]),r.gzindex++;r.gzhead.hcrc&&r.pending>a&&(t.adler=O(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=O(t.adler,r.pending_buf,r.pending-a,a)),St(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,Dt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=O(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=O(t.adler,r.pending_buf,r.pending-a,a)),St(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,Dt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=O(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.status=zt)}else r.status=zt;if(r.status===zt&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&St(t),r.pending+2<=r.pending_buf_size&&(Dt(r,255&t.adler),Dt(r,t.adler>>8&255),t.adler=0,r.status=xt)):r.status=xt),0!==r.pending){if(St(t),0===t.avail_out)return r.last_flush=-1,lt}else if(0===t.avail_in&&It(e)<=It(i)&&e!==st)return Ut(t,ut);if(r.status===At&&0!==t.avail_in)return Ut(t,ut);if(0!==t.avail_in||0!==r.lookahead||e!==nt&&r.status!==At){var h=r.strategy===pt?function(t,e){for(var a;;){if(0===t.lookahead&&(Lt(t),0===t.lookahead)){if(e===nt)return 1;break}if(t.match_length=0,a=et(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(Ct(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===st?(Ct(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Ct(t,!1),0===t.strm.avail_out)?1:2}(r,e):r.strategy===gt?function(t,e){for(var a,n,r,i,s=t.window;;){if(t.lookahead<=yt){if(Lt(t),t.lookahead<=yt&&e===nt)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+yt;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=yt-(i-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=et(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=et(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(Ct(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===st?(Ct(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(Ct(t,!1),0===t.strm.avail_out)?1:2}(r,e):Kt[r.level].func(r,e);if(3!==h&&4!==h||(r.status=At),1===h||3===h)return 0===t.avail_out&&(r.last_flush=-1),lt;if(2===h&&(e===rt?at(r):e!==ht&&($(r,0,0,!1),e===it&&(Bt(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),St(t),0===t.avail_out))return r.last_flush=-1,lt}return e!==st?lt:r.wrap<=0?_t:(2===r.wrap?(Dt(r,255&t.adler),Dt(r,t.adler>>8&255),Dt(r,t.adler>>16&255),Dt(r,t.adler>>24&255),Dt(r,255&t.total_in),Dt(r,t.total_in>>8&255),Dt(r,t.total_in>>16&255),Dt(r,t.total_in>>24&255)):(jt(r,t.adler>>>16),jt(r,65535&t.adler)),St(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?lt:_t)},deflateEnd:function(t){if(!t||!t.state)return ot;var e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==zt&&e!==xt&&e!==At?Ut(t,ot):(t.state=null,e===xt?Ut(t,dt):lt)},deflateSetDictionary:function(t,e){var a=e.length;if(!t||!t.state)return ot;var n=t.state,r=n.wrap;if(2===r||1===r&&42!==n.status||n.lookahead)return ot;if(1===r&&(t.adler=K(t.adler,e,a,0)),n.wrap=0,a>=n.w_size){0===r&&(Bt(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,Lt(n);n.lookahead>=3;){var _=n.strstart,o=n.lookahead-2;do{n.ins_h=Et(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,Lt(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,lt},deflateInfo:\\\"pako deflate (from Nodeca project)\\\"};for(var Jt=new Uint8Array(256),Pt=0;Pt<256;Pt++)Jt[Pt]=Pt>=252?6:Pt>=248?5:Pt>=240?4:Pt>=224?3:Pt>=192?2:1;Jt[254]=Jt[254]=1;var Qt=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},Vt=Object.prototype.toString,Wt=F,Xt=G,Yt=J,Zt=P,$t=Q,te=V,ee=W,ae=X,ne=Y;function re(){this.options={level:ee,method:ne,chunkSize:16384,windowBits:15,memLevel:8,strategy:ae};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 Qt,this.strm.avail_out=0;var e=Gt.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(e!==$t)throw new Error(q[e]);if(t.header&&Gt.deflateSetHeader(this.strm,t.header),t.dictionary){var a;if(a=\\\"[object ArrayBuffer]\\\"===Vt.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,(e=Gt.deflateSetDictionary(this.strm,a))!==$t)throw new Error(q[e]);this._dict_set=!0}}function ie(t,e,a){try{t.postMessage({type:\\\"errored\\\",error:e,streamId:a})}catch(n){t.postMessage({type:\\\"errored\\\",error:String(e),streamId:a})}}function se(t){const e=t.strm.adler;return new Uint8Array([3,0,e>>>24&255,e>>>16&255,e>>>8&255,255&e])}re.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?Zt:Wt,\\\"[object ArrayBuffer]\\\"===Vt.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),(n===Xt||n===Yt)&&r.avail_out<=6)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else{if((a=Gt.deflate(r,n))===te)return r.next_out>0&&this.onData(r.output.subarray(0,r.next_out)),a=Gt.deflateEnd(this.strm),this.onEnd(a),this.ended=!0,a===$t;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},re.prototype.onData=function(t){this.chunks.push(t)},re.prototype.onEnd=function(t){t===$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.5.1\\\"};case\\\"write\\\":{let n=e.get(a.streamId);n||(n=new re,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,G),{type:\\\"wrote\\\",id:a.id,streamId:a.streamId,result:t(n.chunks.slice(r)),trailer:se(n),additionalBytesCount:i.length}}case\\\"reset\\\":e.delete(a.streamId)}}(a,n.data);r&&e.postMessage(r)}catch(t){ie(e,t,n.data&&\\\"streamId\\\"in n.data?n.data.streamId:void 0)}}))}catch(t){ie(e,t)}}()})();\"])));\n}\nlet state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(configuration, source, onInitializationFailure, createDeflateWorkerImpl = createDeflateWorker) {\n    if (state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n        doStartDeflateWorker(configuration, source, createDeflateWorkerImpl);\n    }\n    switch (state.status) {\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.initializationFailureCallbacks.push(onInitializationFailure);\n            return state.worker;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            return state.worker;\n    }\n}\nexport function resetDeflateWorkerState() {\n    if (state.status === 3 /* DeflateWorkerStatus.Initialized */ || state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.stop();\n    }\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\n}\nexport function getDeflateWorkerStatus() {\n    return state.status;\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(configuration, source, createDeflateWorkerImpl = createDeflateWorker) {\n    try {\n        const worker = createDeflateWorkerImpl(configuration);\n        const { stop: removeErrorListener } = addEventListener(configuration, worker, 'error', (error) => {\n            onError(configuration, source, error);\n        });\n        const { stop: removeMessageListener } = addEventListener(configuration, worker, 'message', ({ data }) => {\n            if (data.type === 'errored') {\n                onError(configuration, source, data.error, data.streamId);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(data.version);\n            }\n        });\n        worker.postMessage({ action: 'init' });\n        setTimeout(() => onTimeout(source), INITIALIZATION_TIME_OUT_DELAY);\n        const stop = () => {\n            removeErrorListener();\n            removeMessageListener();\n        };\n        state = { status: 1 /* DeflateWorkerStatus.Loading */, worker, stop, initializationFailureCallbacks: [] };\n    }\n    catch (error) {\n        onError(configuration, source, error);\n    }\n}\nfunction onTimeout(source) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error(`${source} failed to start: a timeout occurred while initializing the Worker`);\n        state.initializationFailureCallbacks.forEach((callback) => callback());\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n}\nfunction onInitialized(version) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: state.worker, stop: state.stop, version };\n    }\n}\nfunction onError(configuration, source, error, streamId) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */ || state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        reportScriptLoadingError({\n            configuredUrl: configuration.workerUrl,\n            error,\n            source,\n            scriptType: 'worker',\n        });\n        if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n            state.initializationFailureCallbacks.forEach((callback) => callback());\n        }\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error, {\n            worker_version: state.status === 3 /* DeflateWorkerStatus.Initialized */ && state.version,\n            stream_id: streamId,\n        });\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map","/**\n * Test for Browser features used while recording\n */\nexport function isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' &&\n        typeof CSSSupportsRule === 'function' &&\n        typeof URL.createObjectURL === 'function' &&\n        'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=isBrowserSupported.js.map","import { getSessionReplayUrl } from '@datadog/browser-rum-core';\nimport { isBrowserSupported } from '../boot/isBrowserSupported';\nexport function getSessionReplayLink(configuration, sessionManager, viewHistory, isRecordingStarted) {\n    const session = sessionManager.findTrackedSession();\n    const errorType = getErrorType(session, isRecordingStarted);\n    const viewContext = viewHistory.findView();\n    return getSessionReplayUrl(configuration, {\n        viewContext,\n        errorType,\n        session,\n    });\n}\nfunction getErrorType(session, isRecordingStarted) {\n    if (!isBrowserSupported()) {\n        return 'browser-not-supported';\n    }\n    if (!session) {\n        // possibilities:\n        // - rum sampled out\n        // - session expired (edge case)\n        return 'rum-not-tracked';\n    }\n    if (session.sessionReplay === 0 /* SessionReplayState.OFF */) {\n        // possibilities\n        // - replay sampled out\n        return 'incorrect-session-plan';\n    }\n    if (!isRecordingStarted) {\n        return 'replay-not-started';\n    }\n}\n//# sourceMappingURL=getSessionReplayLink.js.map","import { asyncRunOnReadyState, monitorError, PageExitReason } from '@datadog/browser-core';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nexport function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder) {\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    // Stop the recorder on page unload to avoid sending records after the page is ended.\n    lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, (pageExitEvent) => {\n        if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n            stop();\n        }\n    });\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {\n        if (status === 1 /* RecorderStatus.IntentToStart */) {\n            start();\n        }\n    });\n    const doStart = async () => {\n        const [startRecordingImpl] = await Promise.all([loadRecorder(), asyncRunOnReadyState(configuration, 'interactive')]);\n        if (status !== 2 /* RecorderStatus.Starting */) {\n            return;\n        }\n        const deflateEncoder = getOrCreateDeflateEncoder();\n        if (!deflateEncoder || !startRecordingImpl) {\n            status = 0 /* RecorderStatus.Stopped */;\n            return;\n        }\n        ;\n        ({ stop: stopRecording } = startRecordingImpl(lifeCycle, configuration, sessionManager, viewHistory, deflateEncoder));\n        status = 3 /* RecorderStatus.Started */;\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        // Intentionally not awaiting doStart() to keep it asynchronous\n        doStart().catch(monitorError);\n        if (shouldForceReplay(session, options)) {\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}\n//# sourceMappingURL=postStartStrategy.js.map","import { reportScriptLoadingError } from '../domain/scriptLoadingError';\nexport async function lazyLoadRecorder(importRecorderImpl = importRecorder) {\n    try {\n        return await importRecorderImpl();\n    }\n    catch (error) {\n        reportScriptLoadingError({\n            error,\n            source: 'Recorder',\n            scriptType: 'module',\n        });\n    }\n}\nasync function importRecorder() {\n    const module = await import(/* webpackChunkName: \"recorder\" */ './startRecording');\n    return module.startRecording;\n}\n//# sourceMappingURL=lazyLoadRecorder.js.map","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { makeRecorderApi } from '../boot/recorderApi';\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate';\nimport { lazyLoadRecorder } from '../boot/lazyLoadRecorder';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nconst recorderApi = makeRecorderApi(lazyLoadRecorder);\nexport const datadogRum = makeRumPublicApi(startRum, recorderApi, { startDeflateWorker, createDeflateEncoder });\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { canUseEventBridge, noop, bridgeSupports, } from '@datadog/browser-core';\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats';\nimport { createDeflateEncoder, getDeflateWorkerStatus, startDeflateWorker, } from '../domain/deflate';\nimport { isBrowserSupported } from './isBrowserSupported';\nimport { createPostStartStrategy } from './postStartStrategy';\nimport { createPreStartStrategy } from './preStartStrategy';\nexport function makeRecorderApi(loadRecorder, createDeflateWorkerImpl) {\n    if ((canUseEventBridge() && !bridgeSupports(\"records\" /* BridgeCapability.RECORDS */)) || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: () => undefined,\n            onRumStart: noop,\n            isRecording: () => false,\n            getSessionReplayLink: () => undefined,\n        };\n    }\n    // eslint-disable-next-line prefer-const\n    let { strategy, shouldStartImmediately } = createPreStartStrategy();\n    return {\n        start: (options) => strategy.start(options),\n        stop: () => strategy.stop(),\n        getSessionReplayLink: () => strategy.getSessionReplayLink(),\n        onRumStart,\n        isRecording: () => \n        // The worker is started optimistically, meaning we could have started to record but its\n        // initialization fails a bit later. This could happen when:\n        // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n        // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n        // * the browser fails to load the worker in case the workerUrl is used\n        // * an unexpected error occurs in the Worker before initialization, ex:\n        //   * a runtime exception collected by monitor()\n        //   * a syntax error notified by the browser via an error event\n        // * the worker is unresponsive for some reason and timeouts\n        //\n        // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n        // an important part of the Datadog App:\n        // * If we have a false positive (we set has_replay: true even if no replay data is present),\n        // we might display broken links to the Session Replay player.\n        // * If we have a false negative (we don't set has_replay: true even if replay data is\n        // available), it is less noticeable because no link will be displayed.\n        //\n        // Thus, it is better to have false negative, so let's make sure the worker is correctly\n        // initialized before advertizing that we are recording.\n        //\n        // In the future, when the compression worker will also be used for RUM data, this will be\n        // less important since no RUM event will be sent when the worker fails to initialize.\n        getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ && strategy.isRecording(),\n        getReplayStats: (viewId) => getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ ? getReplayStatsImpl(viewId) : undefined,\n    };\n    function onRumStart(lifeCycle, configuration, sessionManager, viewHistory, worker) {\n        let cachedDeflateEncoder;\n        function getOrCreateDeflateEncoder() {\n            if (!cachedDeflateEncoder) {\n                worker !== null && worker !== void 0 ? worker : (worker = startDeflateWorker(configuration, 'Datadog Session Replay', () => {\n                    strategy.stop();\n                }, createDeflateWorkerImpl));\n                if (worker) {\n                    cachedDeflateEncoder = createDeflateEncoder(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */);\n                }\n            }\n            return cachedDeflateEncoder;\n        }\n        strategy = createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder);\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 { datadogRum } from \"@datadog/browser-rum\"\n\nif (window.datadogEnvironment) {\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  })\n}\n"],"names":["MAX_STATS_HISTORY","statsPerView","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addSegment","addRecord","records_count","addWroteData","additionalBytesCount","segments_total_raw_size","getReplayStats","get","replayStats","Map","has","set","size","toDelete","keys","next","value","delete","deleteOldestStats","serializedNodeIds","WeakMap","hasSerializedNode","node","getSerializedNodeId","getElementInputValue","element","nodePrivacyLevel","tagName","type","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","replace","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","url","test","quote","baseUrl","href","_a","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","toLowerCase","trim","censoredImageForSize","width","height","RecordType","FullSnapshot","IncrementalSnapshot","Meta","Focus","ViewEnd","VisualViewport","FrustrationRecord","NodeType","Document","DocumentType","Element","Text","CDATA","DocumentFragment","IncrementalSource","Mutation","MouseMove","MouseInteraction","Scroll","ViewportResize","Input","TouchMove","MediaInteraction","StyleSheetRule","MouseInteractionType","MouseUp","MouseDown","Click","ContextMenu","DblClick","Blur","TouchStart","TouchEnd","MediaInteractionType","Play","Pause","serializeStyleSheets","cssStyleSheets","undefined","length","map","cssStyleSheet","rules","cssRules","Array","from","cssRule","disabled","media","serializeAttribute","attributeName","configuration","HIDDEN","attributeValue","getAttribute","MASK","includes","actionNameAttribute","image","naturalWidth","naturalHeight","getBoundingClientRect","startsWith","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","join","rule","isCSSStyleRule","selectorText","escapeColon","isCSSImportRule","styleSheet","serializeNodeWithId","options","serializedNode","nodeType","DOCUMENT_NODE","document","childNodes","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","DOCUMENT_FRAGMENT_NODE","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","name","publicId","systemId","ELEMENT_NODE","isSVG","el","SVGElement","parentNodePrivacyLevel","attributes","rr_width","rr_height","IGNORE","safeAttrs","doc","ownerDocument","i","item","formValue","ALLOW","optionElement","selected","stylesheet","styleSheets","find","s","_cssText","sheet","inputElement","checked","mediaElement","rr_mediaState","paused","scrollTop","scrollLeft","status","Math","round","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","serializeAttributes","childNodesSerializationOptions","ignoreWhiteSpace","serializeElementNode","TEXT_NODE","textNode","textContent","serializeTextNode","CDATA_SECTION_NODE","serializeNode","id","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","add","result","childNode","serializedChildNode","push","serializeDocument","defaultPrivacyLevel","isTouchEvent","event","Boolean","changedTouches","getEventTarget","composed","target","composedPath","convertMouseEventToLayoutCoordinates","clientX","clientY","visualViewport","window","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","scale","assembleIncrementalSnapshot","source","data","timestamp","MOUSE_MOVE_OBSERVER_THRESHOLD","trackMove","moveCb","throttled","updatePosition","cancel","cancelThrottle","coordinates","tryToComputeCoordinates","position","timeOffset","x","y","positions","trailing","stop","removeListener","addEventListener","capture","passive","Number","isFinite","isTrusted","eventTypeToMouseInteraction","trackMouseInteraction","mouseInteractionCb","recordIds","Object","interaction","record","getIdForEvent","SCROLL_OBSERVER_THRESHOLD","trackScroll","scrollCb","scrollPositions","VISUAL_VIEWPORT_OBSERVER_THRESHOLD","trackViewportResize","viewportResizeCb","viewportResizeSubscription","subscribe","unsubscribe","trackVisualViewportResize","visualViewportResizeCb","updateDimension","trackMediaInteraction","mediaInteractionCb","trackStyleSheet","styleSheetCb","checkStyleSheetAndCallback","callback","ownerNode","instrumentationStoppers","instrumentMethod","CSSStyleSheet","prototype","parameters","index","adds","removes","instrumentGroupingCSSRuleClass","cls","parentStyleSheet","path","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","forEach","stopper","currentRule","parentRule","indexOf","unshift","trackFocus","focusCb","has_focus","hasFocus","trackFrustration","lifeCycle","frustrationCb","frustrationSubscription","_b","rawRumEvent","action","frustration","domainContext","events","date","frustrationTypes","e","trackViewEnd","viewEndCb","viewEndSubscription","trackInput","inputCb","lastInputStateMap","stopEventListeners","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","onElementChange","stopPropertySetterInstrumentation","inputState","isChecked","text","cbWithDedup","querySelectorAll","CSS","escape","lastInputState","MUTATION_PROCESS_MAX_DELAY","MUTATION_PROCESS_MIN_DELAY","trackMutation","mutationCallback","MutationObserver","flush","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","throttledFlush","leading","addMutations","mutations","requestIdleCallback","timeout","createMutationBatch","nodePrivacyLevelCache","filter","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","isConnected","current","nodeAndAncestorsHaveSerializedNode","hasBeenSerialized","addedAndMovedNodes","Set","addedNodes","sortedAddedAndMovedNodes","nodes","sort","a","b","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","parentNode","nextId","getNextSibling","parentId","removedNodeMutations","parent","nextSibling","processChildListMutations","texts","textMutations","handledNodes","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","privacyLevel","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","concat","observer","takeRecords","monitor","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","disconnect","shadowDomRemovedCallback","shadowRoot","initShadowRootsController","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","entry","emit","Error","emitAndComputeStats","sendToExtension","view","viewHistory","findView","scrollPositionsByElement","scrollingElement","createElementsScrollPositions","stopFullSnapshots","flushMutations","fullSnapshotCallback","takeFullSnapshot","records","location","initialOffset","left","top","startClocks","timeStamp","startFullSnapshots","initRecordIds","trackers","viewEndRecord","tracker","createSegment","context","creationReason","encoder","encodedBytesCount","metadata","start","Infinity","end","creation_reason","has_full_snapshot","index_in_view","min","max","prefix","isEmpty","write","JSON","stringify","additionalEncodedBytesCount","slice","finish","encoderResult","rawBytesCount","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","sessionManager","httpRequest","getSegmentContext","state","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","pageExitEvent","reason","flushReason","segment","payload","rawSegmentBytesCount","formData","FormData","append","Blob","session","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","bytesCount","buildReplayPayload","output","sendOnExit","send","expirationTimeoutId","doStartSegmentCollection","applicationId","findTrackedSession","viewContext","application","computeSegmentContext","startRecording","cleanupTasks","replayRequest","sessionReplayEndpointBuilder","error","notify","message","bridge","startRecordBridge","segmentCollection","stopRecording","task","eventTarget","eventName","listener","addEventListeners","eventNames","once","listenerWithMonitor","__ddIsTrusted","allowUntrustedEvents","listenerTarget","EventTarget","remove","call","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_US1_FED","PCI_INTAKE_HOST_US1","INTAKE_URL_PARAMETERS","getConnectivity","navigator","onLine","interfaces","connection","effective_type","effectiveType","runOnReadyState","expectedReadyState","readyState","asyncRunOnReadyState","Promise","resolve","getType","isArray","isServerError","tryToClone","response","clone","onMonitorErrorCollected","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","fn","callMonitored","this","arguments","args","apply","monitorError","displayIfDebugEnabled","ConsoleApiName","log","debug","info","warn","globalConsole","console","originalConsoleMethods","PREFIX","display","bind","DOCS_ORIGIN","DOCS_TROUBLESHOOTING","MORE_DETAILS","removeItem","array","splice","__ddBrowserSdkExtensionCallback","Observable","constructor","onFirstSubscribe","observers","f","onLastUnsubscribe","other","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","CUSTOMER_DATA_BYTES_LIMIT","CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT","BYTES_COMPUTATION_THROTTLING_DELAY","createCustomerDataTrackerManager","compressionStatus","customerDataTrackers","alreadyWarned","checkCustomerDataLimit","initialBytesCount","bytesCountLimit","getBytesCount","displayCustomerDataLimitReachedWarning","createDetachedTracker","createCustomerDataTracker","getOrCreateTracker","setCompressionStatus","newCompressionStatus","getCompressionStatus","clear","bytesCountCache","computeBytesCountThrottled","cancelComputeBytesCount","jsonStringify","resetBytesCount","updateCustomerData","resetCustomerData","ensureProperties","propertiesConfig","newContext","key","required","entries","String","createContextManager","customerDataTracker","changeObservable","contextManager","getContext","setContext","maybeContext","isValid","checkContext","clearContext","sanitize","setContextProperty","property","removeContextProperty","TrackingConsent","GRANTED","NOT_GRANTED","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","productKey","customerDataType","storageKey","buildStorageKey","getFromStorage","localStorage","setItem","contextFromStorage","rawContext","getItem","parse","createIdentityEncoder","outputBytesCount","isAsync","finishSync","pendingData","estimateEncodedBytesCount","displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","generateUUID","placeholder","parseInt","random","toString","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","match","exec","safeTruncate","candidate","suffix","lastChar","charCodeAt","correctedLength","startVitalCollection","pageStateHistory","customVitalsState","addDurationVital","vital","wasInPageStateDuringPeriod","relative","duration","valueComputedBySdk","description","_dd","computed_value","startTime","customerContext","processVital","startDurationVital","stopDurationVital","nameOrRef","vitalsByName","vitalsByReference","reference","__dd_vital_reference","stopCallback","vitalStart","stopOptions","stopClocks","buildDurationVital","callPluginsMethod","plugins","methodName","parameter","plugin","method","fetchObservable","initFetchObservable","fetch","onPostCall","handlingStack","input","init","methodFromParams","Request","toUpperCase","responsePromise","startContext","reportFetch","partialContext","assign","then","responseType","isAborted","signal","aborted","DOMException","code","ABORT_ERR","afterSend","beforeSend","computeHandlingStack","setCookie","expireDelay","Date","setTime","getTime","expires","toUTCString","sameSite","crossSite","domain","secure","partitioned","cookie","getCookie","initCookieParsed","getCurrentSiteCache","getInitCookie","findCommaSeparatedValues","deleteCookie","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","_DATADOG_SYNTHETICS_INJECTS_RUM","SESSION_STORE_KEY","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_COOKIE_EXPIRATION_DELAY","SessionPersistence","COOKIE","LOCAL_STORAGE","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","EXPIRED","getExpiredSessionState","previousSessionState","expiredSessionState","isExpired","trackAnonymousUser","anonymousId","isSessionInNotStartedState","isSessionStarted","isSessionInExpiredState","sessionState","created","expire","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","split","matches","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","selectCookieStrategy","cookieOptions","useSecureSessionCookie","usePartitionedCrossSiteSessionCookie","trackSessionAcrossSubdomains","testCookieName","testCookieValue","domainLevels","hostname","candidateDomain","pop","getCurrentSite","buildCookieOptions","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","isLockEnabled","persistSession","retrieveSession","retrieveSessionCookie","expireSession","expireSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","LOCAL_STORAGE_TEST_KEY","selectLocalStorageStrategy","testKey","retrievedId","initLocalStorageStrategy","persistInLocalStorage","retrieveSessionFromLocalStorage","expireSessionFromLocalStorage","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","bufferedOperations","ongoingOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","persistWithLock","lock","currentLock","retrieveStore","currentStore","retryLater","processedSession","process","after","sessionStore","currentNumberOfRetries","nextOperations","shift","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionPersistence","sessionStoreStrategyType","allowFallbackToLocalStorage","startSessionStore","computeSessionState","renewObservable","expireObservable","sessionStateUpdateObservable","watchSessionTimeoutId","synchronizeSession","sessionCache","startSession","throttledExpandOrRenewSession","cancelExpandOrRenewSession","synchronizedSession","trackingType","isTracked","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","isSessionInCacheOutdated","previousState","newState","expandOrRenewSession","expandSession","getSession","restartSession","updateSessionState","partialSessionState","createEndpointBuilder","trackType","configurationTags","buildUrlWithParameters","proxy","normalizedProxyUrl","encodeURIComponent","host","buildEndpointHost","createEndpointUrlWithParametersBuilder","build","api","clientToken","internalAnalyticsSubdomain","retry","encoding","tags","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","site","usePciIntake","domainParts","extension","TAG_SIZE_LIMIT","buildTag","rawValue","valueSizeLimit","RegExp","supportUnicodePropertyEscapes","hasForbiddenCharacters","computeTransportConfiguration","env","service","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","computeEndpointBuilders","replicaConfiguration","replica","replicaEndpointBuilders","computeReplicaConfiguration","DefaultPrivacyLevel","MASK_USER_INPUT","TraceContextInjection","ALL","SAMPLED","isString","tag","isSampleRate","sampleRate","validateAndBuildConfiguration","_c","_d","_e","_f","sessionSampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","telemetryUsageSampleRate","trackingConsent","catchUserErrors","storeContextsAcrossPages","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","isMatchOption","itemType","matchList","list","useStartsWith","some","createSpanIdentifier","createIdentifier","bits","buffer","crypto","getRandomValues","Uint32Array","radix","high","low","str","mod","floor","toPaddedHexadecimalString","padStart","sampleDecisionCache","isTraceSampled","sessionId","decision","BigInt","identifier","knuthFactor","twoPow64","sampleUsingKnuthFactor","clearTracingIfNeeded","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","inject","tracingOption","allowedTracingUrls","traceSampleRate","traceContextInjection","propagatorTypes","tracingHeaders","propagatorType","traceparent","tracestate","b3","makeTracingHeaders","DEFAULT_PROPAGATOR_TYPES","validateAndBuildRumConfiguration","trackFeatureFlagsForEvents","sessionReplaySampleRate","excludedActivityUrls","tracingOptions","option","expectedItem","isTracingOption","validateAndBuildTracingOptions","baseConfiguration","startSessionReplayRecordingManually","rulePsr","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackLongTasks","subdomain","enablePrivacyForActionName","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","REMOTE_CONFIGURATION_VERSION","fetchAndApplyRemoteConfiguration","xhr","XMLHttpRequest","remoteConfiguration","responseText","rum","displayRemoteConfigurationFetchingError","open","remoteConfigurationId","buildEndpoint","fetchRemoteConfiguration","remoteInitConfiguration","applyRemoteConfiguration","createPreStartStrategy","ignoreInitIfSyntheticsWillInjectRum","startDeflateWorker","getCommonContext","trackingConsentState","doStartRum","bufferApiCalls","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","trackingConsentStateSubscription","tryStartRum","emptyContext","isGranted","initialViewOptions","startRumResult","drain","doInit","eventBridgeAvailable","getPrivacyLevel","overrideInitConfigurationForBridge","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","session_replay_sample_rate","start_session_replay_recording_manually","trace_sample_rate","trace_context_injection","action_name_attribute","use_allowed_tracing_urls","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","getConfigurationTelemetry","track_feature_flags_for_events","serializeRumConfiguration","tryToInit","publicApi","enableExperimentalFeatures","getInternalContext","stopSession","addTiming","time","startView","setViewName","setViewContext","setViewContextProperty","getViewContext","addAction","commonContext","addError","providedError","addFeatureFlagEvaluation","RUM_STORAGE_KEY","makeRumPublicApi","startRumImpl","recorderApi","customerDataTrackerManager","globalContextManager","userContextManager","email","accountContextManager","currentConsent","update","createTrackingConsentState","user","account","hasReplay","isRecording","buildCommonContext","strategy","createDeflateEncoder","streamId","onRumStart","preStartStrategy","createPostStartStrategy","sanitizedOptions","feature","rumPublicApi","m","setTrackingConsent","setGlobalContext","getGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","getInitConfiguration","setUser","newUser","getUser","setUserProperty","removeUserProperty","clearUser","setAccount","getAccount","setAccountProperty","removeAccountProperty","clearAccount","getSessionReplayLink","startSessionReplayRecording","force","stopSessionReplayRecording","getMutationObserverConstructor","browserWindow","Zone","getZoneJsOriginalValue","patchedInstance","originalInstance","createEventRateLimiter","eventType","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","AGENT","limitModification","object","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","hooks","urlContexts","displayContext","reportError","WRITABLE_RESOURCE_GRAPHQL","eventRateLimiters","savedCommonContext","viewHistoryEntry","urlContext","findUrl","MISSING_URL_CONTEXT_TELEMETRY","urlEntries","getAllEntries","urlDeletedEntries","getDeletedEntries","viewEntries","viewDeletedEntries","rumContext","format_version","drift","browser_sdk_version","connectivity","serverRumEvent","triggerHook","has_replay","sampled_for_replay","sessionReplay","anonymous_id","usr","rateLimitReached","shouldSend","LifeCycle","callbacks","eventCallbacks","END_OF_TIMES","CLEAR_OLD_VALUES_INTERVAL","cleanupHistoriesInterval","createValueHistory","maxEntries","deletedEntries","clearExpiredValues","oldTimeThreshold","endTime","close","returnInactive","closeActive","latestEntry","findAll","reset","VIEW_CONTEXT_TIME_OUT_DELAY","xhrObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","areInOrder","numbers","isResourceEntryRequestType","computeResourceEntryDuration","responseEnd","computeResourceEntryDetails","hasValidResourceEntryTimings","fetchStart","workerStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","first_byte","worker","connect","ssl","dns","redirect","hasValidResourceEntryDuration","areCommonTimingsInOrder","areRedirectionTimingsInOrder","hasRedirection","origin","computeResourceEntryProtocol","nextHopProtocol","computeResourceEntryDeliveryType","deliveryType","computeResourceEntrySize","encodedBodySize","decodedBodySize","transferSize","encoded_body_size","decoded_body_size","transfer_size","isAllowedRequestUrl","every","param","isIntakeUrl","DATA_URL_REGEX","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","isLongDataUrl","substring","sanitizeDataUrl","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","Headers","header","traceXhr","setRequestHeader","startTracer","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","body","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer","Uint8Array","offset","chunk","bytesLimit","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","discardNegativeDuration","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","discarded","retrieveFirstInputTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","timing","entryType","processingStart","processingEnd","toJSON","sendTiming","sendTimingIfPointerIsNotCancelled","delay","RumPerformanceEntryType","createPerformanceObservable","PerformanceObserver","handlePerformanceEntries","rumPerformanceEntries","RESOURCE","isForbiddenResource","filterRumPerformanceEntries","timeoutId","isObserverInitializing","getEntries","NAVIGATION","LONG_TASK","PAINT","buffered","performance","getEntriesByType","entryTypes","stopFirstInputTiming","resourceTimingBufferFullListener","clearResourceTimings","manageResourceTimingBufferFull","supportPerformanceTimingEvent","FIRST_INPUT","supportedEntryTypes","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","windowOpenObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","isTextNode","isElementNode","isNodeShadowHost","isNodeShadowRoot","hasChildNodes","forEachChildNodes","child","firstChild","getParentNode","NodePrivacyLevel","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_PREFIX","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","cache","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","autocomplete","endsWith","getPrivacySelector","nodeName","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","hasAttribute","shouldIgnoreElement","shouldMaskNode","isFormElement","censorText","getTextContent","parentTagName","parentElement","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","ACTION_NAME_PLACEHOLDER","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","closest","truncate","normalizeWhitespace","priorityStrategies","userProgrammaticAttribute","labels","getActionNameFromTextualContent","nameSource","privacyEnabledActionName","getActionNameFromStandardAttribute","labelledByAttribute","refElement","getElementById","label","getTextualContent","fallbackStrategies","MAX_PARENTS_TO_CONSIDER","getActionNameFromElementForStrategies","strategies","recursionCounter","actionName","trimmedName","attribute","isContentEditable","innerText","removeTextFromElements","query","textToReplace","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","className","getSelectorFromElement","targetElementSelector","currentElement","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","predicate","childSelector","selectorGetter","elementSelector","currentElementSelector","isSiblingMatching","scopedSelector","querySelector","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","bufferedClicks","maxDurationBetweenClicksTimeoutId","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","isStopped","tryAppend","first","second","sqrt","pow","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","computeFrustration","clicks","rageClick","getUserActivity","scroll","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","CLICK_ACTION_MAX_DURATION","interactionSelectorCache","updateInteractionSelector","relativeTimestamp","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","history","currentClickChain","stopClickChain","stopActionEventsListener","onPointerDown","onPointerUp","selectionEmptyAtPointerDown","clickContext","userActivity","listeners","localUserActivity","listenActionEvents","pointerDownEvent","clickActionBase","rect","defaultActionName","getActionNameFromElement","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","viewEndedSubscription","endClocks","stopSubscription","startClickAction","actionContexts","findActionId","validate","finalizeClicks","historyEntry","eventCountsSubscription","activityEndTime","newActivityEndTime","frustrationType","domEvents","clickAction","counts","processAction","autoActionProperties","isAutoAction","loading_time","long_task","resource","name_source","actionEvent","trackRuntimeError","errorObservable","handleRuntimeError","stackTrace","originalError","rawError","nonErrorPrefix","SOURCE","handling","stopInstrumentingOnError","messageObj","line","column","errorObj","computeStackTrace","stopInstrumentingOnUnhandledRejection","stack","instrumentUnhandledRejection","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","formatConsoleParameters","firstErrorParam","fingerprint","causes","CONSOLE","buildConsoleLog","createConsoleObservable","RawReportType","intervention","deprecation","cspViolation","initReportObservable","blockedURI","effectiveDirective","buildRawReportError","csp","disposition","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportErrorFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportErrorFromReport","types","createReportObservable","partial","REPORT","func","startErrorCollection","consoleLog","trackConsoleError","trackReportError","processError","componentStack","CUSTOM","doStartErrorCollection","handling_stack","component_stack","source_type","IDLE_CALLBACK_TIMEOUT","MAX_EXECUTION_TIME_ON_TIMEOUT","alreadyMatchedEntries","WeakSet","matchRequestResourceEntry","sameNameEntries","getEntriesByName","candidates","errorMargin","isBetween","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","traceIdMeta","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","getNavigationEntry","navigationEntry","timings","numberKey","timingElement","computeTimingsFromDeprecatedPerformanceTiming","loadEventEnd","retrieveInitialDocumentResourceTiming","getNavigationEntryImpl","startResourceCollection","taskQueue","pendingTasks","run","deadline","executionTimeRemaining","didTimeout","now","timeRemaining","scheduleNextRun","createTaskQueue","retrieveInitialDocumentResourceTimingImpl","handleResource","matchingTiming","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","computeRequestTracingInfo","correspondingTimingOverrides","computeResourceEntryMetrics","computeRequestDuration","resourceEvent","status_code","protocol","delivery_type","performanceEntry","requestInput","requestInit","processRequest","performanceResourceSubscription","processResourceEntry","computeRawEvent","rawEvent","computeResourceEntryTracingInfo","isType","computeResourceEntryType","entryMetrics","statusCode","responseStatus","renderBlockingStatus","render_blocking_status","FCP_MAXIMUM_DELAY","trackNavigationTimings","stopOnReadyState","waitAfterLoadEvent","isIncompleteNavigation","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","processNavigationEntry","LCP_MAXIMUM_DELAY","trackFirstHidden","stopListeners","visibilityState","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","navigationTimings","firstHidden","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","biggestLcpSize","performanceLcpSubscription","LARGEST_CONTENTFUL_PAINT","lcpEntry","lcpTargetSelector","targetSelector","resourceUrl","trackLargestContentfulPaint","largestContentfulPaint","stopFIDTracking","performanceFirstInputSubscription","firstInputEntry","firstInputDelay","firstInputTargetSelector","trackFirstInput","firstInput","trackCumulativeLayoutShift","viewStart","LAYOUT_SHIFT","biggestShift","maxClsValue","slidingWindow","cumulatedValue","maxValue","isMaxValue","MAX_UPDATE_GAP","MAX_WINDOW_DURATION","slidingSessionWindow","performanceSubscription","hadRecentInput","attribution","sources","WeakRef","previousRect","currentRect","devicePixelRatio","deref","asRumRect","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","getInteractionCount","interactionCount","MAX_INTERACTION_ENTRIES","MAX_INP_VALUE","trackInteractionToNextPaint","viewLoadingType","EVENT","PerformanceEventTiming","getInteractionToNextPaint","setViewEnd","getViewInteractionCount","stopViewInteractionCount","interactionId","durationThreshold","previousInteractionCount","stopped","computeViewInteractionCount","trackViewInteractionCount","viewEnd","longestInteractions","sortAndTrimLongestInteractions","interactionIndex","findIndex","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaintTargetSelector","interactionToNextPaintStartTime","interactionToNextPaint","handleEntries","newInteraction","getInteractionSelector","firstInputSubscription","eventSubscription","viewEndTime","getScrollX","visual","pageXOffset","getScrollY","pageYOffset","viewportObservable","initViewportObservable","getViewportDimension","createViewportObservable","innerWidth","innerHeight","THROTTLE_SCROLL_DURATION","trackScrollMetrics","scrollValues","throttleDuration","scrollHeight","documentElement","scrollDepth","computeScrollValues","ResizeObserver","throttledNotify","observerTarget","resizeObserver","eventListener","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","maxDepth","maxDepthScrollTop","trackCommonViewMetrics","loadingType","commonViewMetrics","stopLoadingTimeTracking","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","loadingTime","trackLoadingTime","newLoadingTime","stopScrollMetricsTracking","newScrollMetrics","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","getCommonViewMetrics","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","activeViews","locationChangeSubscription","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","customTimings","documentVersion","sessionIsActive","viewCreatedEvent","cancelScheduleViewUpdate","triggerViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","stopEventCountsTracking","trackViewEventCounts","keepAliveIntervalId","triggerBeforeViewUpdate","currentEnd","isActive","relativeTime","sanitized","sanitizeTiming","updatedName","newView","UNLOADING","oldLocation","newLocation","currentLocation","otherLocation","pathname","hash","correspondingId","isHashAnAnchor","getPathFromHash","renewViewOnLocationChange","startViewCollection","pageOpenObservable","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","_s","_t","clsDevicePixelRatio","viewEvent","document_version","replay_stats","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","custom_timings","processViewUpdate","register","score","target_selector","previous_rect","current_rect","fcp","fid","inp","lcp","resource_url","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","isReplayForced","forcedReplay","trackActivity","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","cb","trackResume","findSession","startRumSessionManager","rawTrackingType","hasValidRumSession","isTypeTracked","sessionEntity","setForcedReplay","rumSessionType","createBatch","flushController","upsertBuffer","flushSubscription","flushObservable","upsertMessages","isPageExit","formatPayloadFromEncoder","pendingMessages","addOrUpdate","serializedMessage","estimatedMessageBytesCount","hasMessageFor","removedMessage","messageBytesCount","notifyAfterRemoveMessage","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","upsert","createFlushController","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","pageExitSubscription","sessionExpireSubscription","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","startRumBatch","telemetryEventObservable","createEncoder","batch","primary","batchFactoryImp","primaryBatch","createBatchFromConfig","replicaBatch","endpoint","replicated","transformMessage","startBatchWithReplica","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","getHistoryInstrumentationTarget","stopInstrumentingReplaceState","trackHistory","onLocationChange","stopHashTracking","onHashChange","trackHash","hasOwnProperty","History","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","MEASURES_PERIOD_DURATION","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","MAX_PAGE_STATE_ENTRIES","MAX_PAGE_STATE_ENTRIES_SELECTABLE","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","startPageStateHistory","maxPageStateEntriesSelectable","pageStateEntryHistory","currentPageState","addPageState","getPageState","persisted","computePageState","nextPageState","pageState","page_states","processPageStates","in_foreground","pageStateEntries","eventStartTime","createCookieObservable","cookieName","detectCookieChangeStrategy","changeEvent","changed","deleted","listenToCookieStoreChange","watchCookieFallback","WATCH_COOKIE_INTERVAL_DELAY","previousCookieValue","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","startSyntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsTestId","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","synthetics","test_id","result_id","injected","startRum","hookName","unregister","results","createHooks","telemetry","startRumTelemetry","setContextProvider","startRumSessionManagerStub","startRumEventBridge","batchFlushObservable","enabled","startCustomerDataTelemetry","createDOMMutationObservable","viewValueHistory","buildViewHistoryEntry","viewUpdate","startViewHistory","urlContextHistory","previousViewUrl","viewUrl","buildUrlContext","referrer","changeTime","startUrlContexts","featureFlagContexts","featureFlagContext","feature_flags","currentContext","startFeatureFlagContexts","stopWindowOpen","createWindowOpenObservable","stopRumEventCollection","actionCollection","actionId","startActionCollection","viewport","animationFrameId","requestAnimationFrame","unsubscribeViewport","viewportDimension","cancelAnimationFrame","startDisplayContext","ciVisibilityContext","cookieObservable","testExecutionId","Cypress","cookieObservableSubscription","ci_test","test_execution_id","startCiVisibilityContext","startRumEventCollection","stopViewCollection","stopResourceCollection","LONG_ANIMATION_FRAME","stopLongAnimationFrameCollection","entry_type","blocking_duration","blockingDuration","first_ui_event_timestamp","firstUIEventTimestamp","render_start","renderStart","style_and_layout_start","styleAndLayoutStart","start_time","scripts","script","pause_duration","pauseDuration","forced_style_and_layout_duration","forcedStyleAndLayoutDuration","execution_start","executionStart","source_url","sourceURL","source_function_name","sourceFunctionName","source_char_position","sourceCharPosition","invoker","invoker_type","invokerType","window_attribution","windowAttribution","startLongAnimationFrameCollection","performanceLongTaskSubscription","startLongTaskCollection","vitalCollection","internalContext","application_id","session_id","user_action","startInternalContext","getSessionReplayUrl","errorType","rumConfiguration","getSiteDefaultSubdomain","getDatadogSiteUrl","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","JSON_PATH_ROOT_ELEMENT","KEY_DECORATION_LENGTH","maxCharacterCount","restoreObjectPrototypeToJson","restoreArrayPrototypeToJson","containerQueue","visitedObjectsWithPath","sanitizedData","sanitizeProcessor","serializedSanitizedData","accumulatedCharacterCount","containerToProcess","separatorLength","targetData","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","sanitizePrimitivesAndFunctions","sanitizedSource","sanitizeObjects","sourceAsObject","currentPath","Event","currentTarget","changeType","throttle","wait","needLeadingExecution","needTrailingExecution","pendingExecutionWithParameters","pendingTimeoutId","inWaitPeriod","noop","setTimeout","clearTimeout","setInterval","clearInterval","targetPrototype","onPreCall","original","instrumentation","postCallCallback","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","configurable","stoppedInstrumentation","instrumentationWrapper","defineProperty","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","isErrorInstance","isError","computeMessage","hasUsableStack","flattenErrorCauses","tryToGetFingerprint","tryToGetErrorContext","dd_fingerprint","dd_context","parentSource","currentError","cause","opts","cancelIdleCallback","MAX_TASK_TIME","requestIdleCallbackShim","isChromium","detectBrowserCached","isSafari","browserCache","userAgent","chrome","vendor","detectBrowser","getGlobalObject","globalThis","globalObject","_dd_temp_","self","replacer","space","detachToJsonMethod","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","createHandlingStack","formattedStack","toStackTraceString","formatErrorMessage","frame","normalizeUrl","buildUrl","isValidUrl","getPathName","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","anchorElement","createElement","implementation","createHTMLDocument","baseElement","head","appendChild","URL","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","getAllowedWebViewHosts","bridgeSupports","capability","canUseEventBridge","currentHost","allowedHost","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","sendStrategy","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","dequeue","currentBackoffTime","shouldRetryRequest","ongoingRequestCount","isFull","queueFullReported","previousQueue","newPayloadQueue","createHttpRequest","endpointBuilder","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","canUseKeepAlive","isKeepAliveSupported","fetchUrl","keepalive","mode","sendXHR","fetchKeepAliveStrategy","canUseBeacon","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","xhrUrl","sendBeaconStrategy","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","TextEncoder","encode","concatBuffers","buffers","reduce","total","__symbol__","TelemetryType","usage","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","preStartTelemetryBuffer","onRawTelemetryEventCollected","startTelemetry","telemetryService","contextProvider","alreadySentEvents","telemetryEnabled","telemetryEnabledPerType","runtimeEnvInfo","is_local_file","is_worker","stringifiedEvent","runtime_env","sdk_setup","experimental_features","toTelemetryEvent","addTelemetryError","provider","drainPreStartTelemetry","isTelemetryReplicationAllowed","addTelemetryDebug","formatError","addTelemetryConfiguration","addTelemetryUsage","kind","scrubCustomerFrames","allowedFrameUrl","mergeInto","destination","circularReferenceChecker","hasAlreadyBeenSeen","createCircularReferenceChecker","flags","global","ignoreCase","multiline","sticky","unicode","merged","deepClone","combine","shallowClone","objectHasValue","isEmptyObject","mapValues","newObject","makePublicApi","stub","onReady","enumerable","defineGlobal","existingGlobalVariable","q","BUFFER_LIMIT","createBoundedBuffer","arg","ErrorSource","LOGGER","NETWORK","UNKNOWN_FUNCTION","ex","stackProperty","tryToGetString","exString","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","fileUrl","filePosition","computeStackTraceFromOnErrorMessage","ERROR_TYPES_RE","tryToParseMessage","errorMsg","err","ExperimentalFeature","enabledExperimentalFeatures","initFeatureFlags","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","performDraw","threshold","num","decimals","toFixed","isPercentage","isNumber","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","getCorrectedTimeStamp","timeStampToClocks","getRelativeTime","correctedOrigin","dateNow","getNavigationStart","addDuration","getTimeStamp","currentDrift","toServerDuration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","looksLikeRelativeTime","navigationStart","PageExitReason","PAGEHIDE","FROZEN","createPageExitObservable","stopBeforeUnloadListener","isPageExitReason","findLast","objectValues","values","objectEntries","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","exports","module","__webpack_modules__","d","definition","o","obj","prop","r","Symbol","toStringTag","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","workerResponse","trailer","nextPendingAction","writeCallback","finishCallback","consumeResult","sendResetIfNeeded","postMessage","pendingWriteAction","reportScriptLoadingError","configuredUrl","scriptType","baseMessage","INITIALIZATION_TIME_OUT_DELAY","createDeflateWorker","Worker","createObjectURL","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener","onError","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","worker_version","stream_id","isBrowserSupported","NodeList","isRecordingStarted","getErrorType","loadRecorder","getOrCreateDeflateEncoder","doStart","async","startRecordingImpl","all","deflateEncoder","canStartRecording","isRecordingInProgress","shouldForceReplay","importRecorder","shouldStartImmediately","cachedDeflateEncoder","makeRecorderApi","importRecorderImpl","datadogRum","datadogEnvironment","datadogVersion","datadogSampleRate"],"sourceRoot":""}