{"version":3,"file":"datadog.js","mappings":"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","sources":["webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/getGlobalObject.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/tools/timer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/customerDataTracker.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/context/contextManager.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/trackingConsent.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/addEventListener.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/tools/stackTrace/computeStackTrace.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/stackTrace/handlingStack.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.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/tools/sendToExtension.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/connectivity/connectivity.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/user/user.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-core/esm/transport/eventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.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/tools/utils/browserDetection.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/storeStrategies/sessionInCookie.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/session/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-rum-core/esm/domain/tracing/identifier.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/crypto.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/tracing/sampler.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/domain/plugins.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/domain/eventRateLimiter/createEventRateLimiter.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/limitModification.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.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-rum-core/esm/browser/performanceObservable.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.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/domain/waitPageActivityEnd.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/browser/polyfills.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/requestIdleCallback.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/domain/resource/matchRequestResourceEntry.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.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-core/esm/tools/taskQueue.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/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/trackFirstContentfulPaint.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/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/browser/viewportObservable.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/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/sendWithRetryStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/transport/httpRequest.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/getSessionReplayUrl.js","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/trackers/trackMutation.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/record/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/shadowRootsController.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/domain/deflate/deflateEncoder.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/entries/main.js","webpack://market-storefront/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/preStartStrategy.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://market-storefront/./node_modules/@datadog/browser-rum/esm/domain/startRecordBridge.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/boot/startRum.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://market-storefront/./node_modules/@datadog/browser-rum-core/esm/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/./app/javascript/packs/datadog.js"],"sourcesContent":["/* 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 var 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 var globalConsole = console;\nexport var originalConsoleMethods = {};\nObject.keys(ConsoleApiName).forEach(function (name) {\n    originalConsoleMethods[name] = globalConsole[name];\n});\nvar PREFIX = 'Datadog Browser SDK:';\nexport var 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 var DOCS_ORIGIN = 'https://docs.datadoghq.com';\nexport var DOCS_TROUBLESHOOTING = \"\".concat(DOCS_ORIGIN, \"/real_user_monitoring/browser/troubleshooting\");\nexport var MORE_DETAILS = 'More details:';\n//# sourceMappingURL=display.js.map","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        try {\n            return fn.apply(void 0, args);\n        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { display } from './display';\nvar onMonitorErrorCollected;\nvar 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    var originalMethod = descriptor.value;\n    descriptor.value = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var 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        displayIfDebugEnabled(e);\n        if (onMonitorErrorCollected) {\n            try {\n                onMonitorErrorCollected(e);\n            }\n            catch (e) {\n                displayIfDebugEnabled(e);\n            }\n        }\n    }\n}\nexport function displayIfDebugEnabled() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    if (debugMode) {\n        display.error.apply(display, __spreadArray(['[MONITOR]'], args, false));\n    }\n}\n//# sourceMappingURL=monitor.js.map","export function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\n}\nexport function arrayFrom(arrayLike) {\n    if (Array.from) {\n        return Array.from(arrayLike);\n    }\n    var array = [];\n    if (arrayLike instanceof Set) {\n        arrayLike.forEach(function (item) { return array.push(item); });\n    }\n    else {\n        for (var i = 0; i < arrayLike.length; i++) {\n            array.push(arrayLike[i]);\n        }\n    }\n    return array;\n}\nexport function find(array, predicate) {\n    for (var i = 0; i < array.length; i += 1) {\n        var item = array[i];\n        if (predicate(item, i)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function findLast(array, predicate) {\n    for (var i = array.length - 1; i >= 0; i -= 1) {\n        var item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\nexport function objectValues(object) {\n    return Object.keys(object).map(function (key) { return object[key]; });\n}\nexport function objectEntries(object) {\n    return Object.keys(object).map(function (key) { return [key, object[key]]; });\n}\nexport function startsWith(candidate, search) {\n    return candidate.slice(0, search.length) === search;\n}\nexport function endsWith(candidate, search) {\n    return candidate.slice(-search.length) === search;\n}\nexport function assign(target) {\n    var toAssign = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        toAssign[_i - 1] = arguments[_i];\n    }\n    toAssign.forEach(function (source) {\n        for (var key in source) {\n            if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n            }\n        }\n    });\n    return target;\n}\n//# sourceMappingURL=polyfills.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: function () {\n            return this;\n        },\n        configurable: true,\n    });\n    // @ts-ignore _dd_temp is defined using defineProperty\n    var 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","export var ONE_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nvar 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    var length = buffers.reduce(function (total, buffer) { return total + buffer.length; }, 0);\n    var result = new Uint8Array(length);\n    var offset = 0;\n    for (var _i = 0, buffers_1 = buffers; _i < buffers_1.length; _i++) {\n        var buffer = buffers_1[_i];\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    var browserWindow = getGlobalObject();\n    var 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","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, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n    var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    var inWaitPeriod = false;\n    var pendingExecutionWithParameters;\n    var pendingTimeoutId;\n    return {\n        throttled: function () {\n            var parameters = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                parameters[_i] = arguments[_i];\n            }\n            if (inWaitPeriod) {\n                pendingExecutionWithParameters = parameters;\n                return;\n            }\n            if (needLeadingExecution) {\n                fn.apply(void 0, parameters);\n            }\n            else {\n                pendingExecutionWithParameters = parameters;\n            }\n            inWaitPeriod = true;\n            pendingTimeoutId = setTimeout(function () {\n                if (needTrailingExecution && pendingExecutionWithParameters) {\n                    fn.apply(void 0, pendingExecutionWithParameters);\n                }\n                inWaitPeriod = false;\n                pendingExecutionWithParameters = undefined;\n            }, wait);\n        },\n        cancel: function () {\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 { 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    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    var 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    var object = value;\n    var objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return function () {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\n//# sourceMappingURL=jsonStringify.js.map","import { assign } from './polyfills';\nexport function shallowClone(object) {\n    return assign({}, object);\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some(function (key) { return object[key] === value; });\n}\nexport function isEmptyObject(object) {\n    return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n    var newObject = {};\n    for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {\n        var key = _a[_i];\n        newObject[key] = fn(object[key]);\n    }\n    return newObject;\n}\n//# sourceMappingURL=objectUtils.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 var 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 var CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createCustomerDataTrackerManager(compressionStatus) {\n    if (compressionStatus === void 0) { compressionStatus = 2 /* CustomerDataCompressionStatus.Disabled */; }\n    var customerDataTrackers = new Map();\n    var alreadyWarned = false;\n    function checkCustomerDataLimit(initialBytesCount) {\n        if (initialBytesCount === void 0) { initialBytesCount = 0; }\n        if (alreadyWarned || compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n            return;\n        }\n        var bytesCountLimit = compressionStatus === 2 /* CustomerDataCompressionStatus.Disabled */\n            ? CUSTOMER_DATA_BYTES_LIMIT\n            : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT;\n        var bytesCount = initialBytesCount;\n        customerDataTrackers.forEach(function (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: function () {\n            var tracker = createCustomerDataTracker(function () { return checkCustomerDataLimit(tracker.getBytesCount()); });\n            return tracker;\n        },\n        /**\n         * Creates a tracker if it doesn't exist, and returns it.\n         */\n        getOrCreateTracker: function (type) {\n            if (!customerDataTrackers.has(type)) {\n                customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit));\n            }\n            return customerDataTrackers.get(type);\n        },\n        setCompressionStatus: function (newCompressionStatus) {\n            if (compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n                compressionStatus = newCompressionStatus;\n                checkCustomerDataLimit();\n            }\n        },\n        getCompressionStatus: function () { return compressionStatus; },\n        stop: function () {\n            customerDataTrackers.forEach(function (tracker) { return tracker.stop(); });\n            customerDataTrackers.clear();\n        },\n    };\n}\nexport function createCustomerDataTracker(checkCustomerDataLimit) {\n    var 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    var _a = throttle(function (context) {\n        bytesCountCache = computeBytesCount(jsonStringify(context));\n        checkCustomerDataLimit();\n    }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a.throttled, cancelComputeBytesCount = _a.cancel;\n    var resetBytesCount = function () {\n        cancelComputeBytesCount();\n        bytesCountCache = 0;\n    };\n    return {\n        updateCustomerData: function (context) {\n            if (isEmptyObject(context)) {\n                resetBytesCount();\n            }\n            else {\n                computeBytesCountThrottled(context);\n            }\n        },\n        resetCustomerData: resetBytesCount,\n        getBytesCount: function () { return bytesCountCache; },\n        stop: function () {\n            cancelComputeBytesCount();\n        },\n    };\n}\nfunction displayCustomerDataLimitReachedWarning(bytesCountLimit) {\n    display.warn(\"Customer data exceeds the recommended \".concat(bytesCountLimit / ONE_KIBI_BYTE, \"KiB threshold. \").concat(MORE_DETAILS, \" \").concat(DOCS_TROUBLESHOOTING, \"/#customer-data-exceeds-the-recommended-threshold-warning\"));\n}\n//# sourceMappingURL=customerDataTracker.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","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) {\n    if (circularReferenceChecker === void 0) { 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        var 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        var merged_1 = Array.isArray(destination) ? destination : [];\n        for (var i = 0; i < source.length; ++i) {\n            merged_1[i] = mergeInto(merged_1[i], source[i], circularReferenceChecker);\n        }\n        return merged_1;\n    }\n    var merged = getType(destination) === 'object' ? destination : {};\n    for (var 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() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    var destination;\n    for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {\n        var source = sources_1[_a];\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        var set_1 = new WeakSet();\n        return {\n            hasAlreadyBeenSeen: function (value) {\n                var has = set_1.has(value);\n                if (!has) {\n                    set_1.add(value);\n                }\n                return has;\n            },\n        };\n    }\n    var array = [];\n    return {\n        hasAlreadyBeenSeen: function (value) {\n            var has = array.indexOf(value) >= 0;\n            if (!has) {\n                array.push(value);\n            }\n            return has;\n        },\n    };\n}\n//# sourceMappingURL=mergeInto.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, ...\nvar SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nvar 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.\nvar KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount) {\n    if (maxCharacterCount === void 0) { maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT; }\n    // Unbind any toJSON function we may have on [] or {} prototypes\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    var containerQueue = [];\n    var visitedObjectsWithPath = new WeakMap();\n    var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n    var serializedSanitizedData = JSON.stringify(sanitizedData);\n    var 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        var containerToProcess = containerQueue.shift();\n        var 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 (var key = 0; key < containerToProcess.source.length; key++) {\n                var 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 (var key in containerToProcess.source) {\n                if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n                    var 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    var sourceToSanitize = tryToApplyToJSON(source);\n    if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n        return sanitizePrimitivesAndFunctions(sourceToSanitize);\n    }\n    var 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    var sourceAsObject = source;\n    if (visitedObjectsWithPath.has(sourceAsObject)) {\n        return \"[Reference seen at \".concat(visitedObjectsWithPath.get(sourceAsObject), \"]\");\n    }\n    // Add processed source to queue\n    var currentPath = key !== undefined ? \"\".concat(parentPath, \".\").concat(key) : parentPath;\n    var target = Array.isArray(sourceToSanitize) ? [] : {};\n    visitedObjectsWithPath.set(sourceAsObject, currentPath);\n    queue.push({ source: sourceToSanitize, target: 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] \".concat(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] \".concat(value.name || 'unknown');\n    }\n    // JSON.stringify() does not serialize symbols.\n    if (typeof value === 'symbol') {\n        return \"[Symbol] \".concat(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 * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their\n * properties enumerated if any.\n *\n */\nfunction sanitizeObjects(value) {\n    try {\n        // Handle events - Keep a simple implementation to avoid breaking changes\n        if (value instanceof Event) {\n            return {\n                isTrusted: value.isTrusted,\n            };\n        }\n        // Handle all remaining object types in a generic way\n        var result = Object.prototype.toString.call(value);\n        var match = result.match(/\\[object (.*)\\]/);\n        if (match && match[1]) {\n            return \"[\".concat(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}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n    var 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 \".concat(changeType, \" as it is over the limit of \").concat(maxCharacterCount, \" characters:\"), source);\n}\n//# sourceMappingURL=sanitize.js.map","// eslint-disable-next-line no-restricted-syntax\nvar Observable = /** @class */ (function () {\n    function Observable(onFirstSubscribe) {\n        this.onFirstSubscribe = onFirstSubscribe;\n        this.observers = [];\n    }\n    Observable.prototype.subscribe = function (f) {\n        var _this = this;\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: function () {\n                _this.observers = _this.observers.filter(function (other) { return f !== other; });\n                if (!_this.observers.length && _this.onLastUnsubscribe) {\n                    _this.onLastUnsubscribe();\n                }\n            },\n        };\n    };\n    Observable.prototype.notify = function (data) {\n        this.observers.forEach(function (observer) { return observer(data); });\n    };\n    return Observable;\n}());\nexport { Observable };\nexport function mergeObservables() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    return new Observable(function (globalObservable) {\n        var subscriptions = observables.map(function (observable) {\n            return observable.subscribe(function (data) { return globalObservable.notify(data); });\n        });\n        return function () { return subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); }); };\n    });\n}\n//# sourceMappingURL=observable.js.map","import { deepClone } from '../../tools/mergeInto';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { Observable } from '../../tools/observable';\nexport function createContextManager(customerDataTracker) {\n    var context = {};\n    var changeObservable = new Observable();\n    var contextManager = {\n        getContext: function () { return deepClone(context); },\n        setContext: function (newContext) {\n            if (getType(newContext) === 'object') {\n                context = sanitize(newContext);\n                customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\n            }\n            else {\n                contextManager.clearContext();\n            }\n            changeObservable.notify();\n        },\n        setContextProperty: function (key, property) {\n            context[key] = sanitize(property);\n            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\n            changeObservable.notify();\n        },\n        removeContextProperty: function (key) {\n            delete context[key];\n            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.updateCustomerData(context);\n            changeObservable.notify();\n        },\n        clearContext: function () {\n            context = {};\n            customerDataTracker === null || customerDataTracker === void 0 ? void 0 : customerDataTracker.resetCustomerData();\n            changeObservable.notify();\n        },\n        changeObservable: changeObservable,\n    };\n    return contextManager;\n}\n//# sourceMappingURL=contextManager.js.map","import { Observable } from '../tools/observable';\nexport var TrackingConsent = {\n    GRANTED: 'granted',\n    NOT_GRANTED: 'not-granted',\n};\nexport function createTrackingConsentState(currentConsent) {\n    var observable = new Observable();\n    return {\n        tryToInit: function (trackingConsent) {\n            if (!currentConsent) {\n                currentConsent = trackingConsent;\n            }\n        },\n        update: function (trackingConsent) {\n            currentConsent = trackingConsent;\n            observable.notify();\n        },\n        isGranted: function () {\n            return currentConsent === TrackingConsent.GRANTED;\n        },\n        observable: observable,\n    };\n}\n//# sourceMappingURL=trackingConsent.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, _a) {\n    var _b = _a === void 0 ? {} : _a, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var listenerWithMonitor = monitor(function (event) {\n        if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {\n            return;\n        }\n        if (once) {\n            stop();\n        }\n        listener(event);\n    });\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)\n    var listenerTarget = window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget;\n    var add = getZoneJsOriginalValue(listenerTarget, 'addEventListener');\n    eventNames.forEach(function (eventName) { return add.call(eventTarget, eventName, listenerWithMonitor, options); });\n    function stop() {\n        var remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener');\n        eventNames.forEach(function (eventName) { return remove.call(eventTarget, eventName, listenerWithMonitor, options); });\n    }\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","import { addEventListener } from '../../browser/addEventListener';\nimport { combine } from '../../tools/mergeInto';\nvar CONTEXT_STORE_KEY_PREFIX = '_dd_c';\nvar storageListeners = [];\nexport function storeContextManager(configuration, contextManager, productKey, customerDataType) {\n    var storageKey = buildStorageKey(productKey, customerDataType);\n    storageListeners.push(addEventListener(configuration, window, \"storage\" /* DOM_EVENT.STORAGE */, function (_a) {\n        var key = _a.key;\n        if (storageKey === key) {\n            synchronizeWithStorage();\n        }\n    }));\n    contextManager.changeObservable.subscribe(dumpToStorage);\n    contextManager.setContext(combine(getFromStorage(), contextManager.getContext()));\n    function synchronizeWithStorage() {\n        contextManager.setContext(getFromStorage());\n    }\n    function dumpToStorage() {\n        localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()));\n    }\n    function getFromStorage() {\n        var rawContext = localStorage.getItem(storageKey);\n        return rawContext !== null ? JSON.parse(rawContext) : {};\n    }\n}\nexport function buildStorageKey(productKey, customerDataType) {\n    return \"\".concat(CONTEXT_STORE_KEY_PREFIX, \"_\").concat(productKey, \"_\").concat(customerDataType);\n}\nexport function removeStorageListeners() {\n    storageListeners.map(function (listener) { return listener.stop(); });\n}\n//# sourceMappingURL=storeContextManager.js.map","import { computeBytesCount } from './utils/byteUtils';\nexport function createIdentityEncoder() {\n    var output = '';\n    var outputBytesCount = 0;\n    return {\n        isAsync: false,\n        get isEmpty() {\n            return !output;\n        },\n        write: function (data, callback) {\n            var additionalEncodedBytesCount = computeBytesCount(data);\n            outputBytesCount += additionalEncodedBytesCount;\n            output += data;\n            if (callback) {\n                callback(additionalEncodedBytesCount);\n            }\n        },\n        finish: function (callback) {\n            callback(this.finishSync());\n        },\n        finishSync: function () {\n            var result = {\n                output: output,\n                outputBytesCount: outputBytesCount,\n                rawBytesCount: outputBytesCount,\n                pendingData: '',\n            };\n            output = '';\n            outputBytesCount = 0;\n            return result;\n        },\n        estimateEncodedBytesCount: function (data) {\n            return data.length;\n        },\n    };\n}\n//# sourceMappingURL=encoder.js.map","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\nimport { startsWith } from '../utils/polyfills';\nvar UNKNOWN_FUNCTION = '?';\nexport function computeStackTrace(ex) {\n    var stack = [];\n    var stackProperty = tryToGetString(ex, 'stack');\n    var exString = String(ex);\n    if (stackProperty && startsWith(stackProperty, exString)) {\n        stackProperty = stackProperty.slice(exString.length);\n    }\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var 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: stack,\n    };\n}\nvar fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nvar filePosition = '(?::(\\\\d+))';\nvar CHROME_LINE_RE = new RegExp(\"^\\\\s*at (.*?) ?\\\\(\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"?\\\\)?\\\\s*$\"), 'i');\nvar CHROME_EVAL_RE = new RegExp(\"\\\\((\\\\S*)\".concat(filePosition).concat(filePosition, \"\\\\)\"));\nfunction parseChromeLine(line) {\n    var parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    var 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}\nvar CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\"^\\\\s*at ?\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"??\\\\s*$\"), 'i');\nfunction parseChromeAnonymousLine(line) {\n    var 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}\nvar WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    var 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}\nvar GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    var parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    var 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    var value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\nexport function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {\n    var stack = [{ url: url, column: column, line: line }];\n    var _a = tryToParseMessage(messageObj), name = _a.name, message = _a.message;\n    return {\n        name: name,\n        message: message,\n        stack: stack,\n    };\n}\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/;\nfunction tryToParseMessage(messageObj) {\n    var _a;\n    var name;\n    var message;\n    if ({}.toString.call(messageObj) === '[object String]') {\n        ;\n        _a = ERROR_TYPES_RE.exec(messageObj), name = _a[1], message = _a[2];\n    }\n    return { name: name, message: message };\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { callMonitored } from '../monitor';\nimport { noop } from '../utils/functionUtils';\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() {\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    var internalFramesToSkip = 2;\n    var error = new Error();\n    var formattedStack;\n    // IE needs to throw the error to fill in the stack trace\n    if (!error.stack) {\n        try {\n            throw error;\n        }\n        catch (_a) {\n            noop();\n        }\n    }\n    callMonitored(function () {\n        var stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\nexport function toStackTraceString(stack) {\n    var result = formatErrorMessage(stack);\n    stack.stack.forEach(function (frame) {\n        var func = frame.func === '?' ? '<anonymous>' : frame.func;\n        var args = frame.args && frame.args.length > 0 ? \"(\".concat(frame.args.join(', '), \")\") : '';\n        var line = frame.line ? \":\".concat(frame.line) : '';\n        var column = frame.line && frame.column ? \":\".concat(frame.column) : '';\n        result += \"\\n  at \".concat(func).concat(args, \" @ \").concat(frame.url).concat(line).concat(column);\n    });\n    return result;\n}\nexport function formatErrorMessage(stack) {\n    return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n//# sourceMappingURL=handlingStack.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 var NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError(_a) {\n    var stackTrace = _a.stackTrace, originalError = _a.originalError, handlingStack = _a.handlingStack, startClocks = _a.startClocks, nonErrorPrefix = _a.nonErrorPrefix, source = _a.source, handling = _a.handling;\n    var isErrorInstance = isError(originalError);\n    var message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);\n    var stack = hasUsableStack(isErrorInstance, stackTrace)\n        ? toStackTraceString(stackTrace)\n        : NO_ERROR_STACK_PRESENT_MESSAGE;\n    var causes = isErrorInstance ? flattenErrorCauses(originalError, source) : undefined;\n    var type = stackTrace ? stackTrace.name : undefined;\n    var fingerprint = tryToGetFingerprint(originalError);\n    return {\n        startClocks: startClocks,\n        source: source,\n        handling: handling,\n        handlingStack: handlingStack,\n        originalError: originalError,\n        type: type,\n        message: message,\n        stack: stack,\n        causes: causes,\n        fingerprint: fingerprint,\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            ? \"\".concat(nonErrorPrefix, \" \").concat(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 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    var currentError = error;\n    var causes = [];\n    while (isError(currentError === null || currentError === void 0 ? void 0 : currentError.cause) && causes.length < 10) {\n        var 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","/**\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[\"REMOTE_CONFIGURATION\"] = \"remote_configuration\";\n    ExperimentalFeature[\"LONG_ANIMATION_FRAME\"] = \"long_animation_frame\";\n    ExperimentalFeature[\"ANONYMOUS_USER_TRACKING\"] = \"anonymous_user_tracking\";\n    ExperimentalFeature[\"ACTION_NAME_MASKING\"] = \"action_name_masking\";\n    ExperimentalFeature[\"CONSISTENT_TRACE_SAMPLING\"] = \"consistent_trace_sampling\";\n    ExperimentalFeature[\"DELAY_VIEWPORT_COLLECTION\"] = \"delay_viewport_collection\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nvar enabledExperimentalFeatures = new Set();\nexport function initFeatureFlags(enableExperimentalFeatures) {\n    if (Array.isArray(enableExperimentalFeatures)) {\n        addExperimentalFeatures(enableExperimentalFeatures.filter(function (flag) {\n            return objectHasValue(ExperimentalFeature, flag);\n        }));\n    }\n}\nexport function addExperimentalFeatures(enabledFeatures) {\n    enabledFeatures.forEach(function (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","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_FED_STAGING = 'dd0g-gov.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';\nexport var PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com';\nexport var INTAKE_URL_PARAMETERS = ['ddsource', 'ddtags'];\n//# sourceMappingURL=intakeSites.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 var ONE_SECOND = 1000;\nexport var ONE_MINUTE = 60 * ONE_SECOND;\nexport var ONE_HOUR = 60 * ONE_MINUTE;\nexport var ONE_DAY = 24 * ONE_HOUR;\nexport var ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nexport function timeStampToClocks(timeStamp) {\n    return { relative: getRelativeTime(timeStamp), timeStamp: timeStamp };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var 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/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\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 */\nvar navigationStart;\nfunction getNavigationStart() {\n    if (navigationStart === undefined) {\n        navigationStart = performance.timing.navigationStart;\n    }\n    return navigationStart;\n}\n//# sourceMappingURL=timeUtils.js.map","export function sendToExtension(type, payload) {\n    var callback = window.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type: type, payload: payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.js.map","export function getConnectivity() {\n    var _a;\n    var 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 { arrayFrom } from './polyfills';\nexport function removeDuplicates(array) {\n    var set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    return arrayFrom(set);\n}\nexport function removeItem(array, item) {\n    var index = array.indexOf(item);\n    if (index >= 0) {\n        array.splice(index, 1);\n    }\n}\n//# sourceMappingURL=arrayUtils.js.map","import { removeItem } from './utils/arrayUtils';\nvar BUFFER_LIMIT = 500;\nexport function createBoundedBuffer() {\n    var buffer = [];\n    var add = function (callback) {\n        var length = buffer.push(callback);\n        if (length > BUFFER_LIMIT) {\n            buffer.splice(0, 1);\n        }\n    };\n    var remove = function (callback) {\n        removeItem(buffer, callback);\n    };\n    var drain = function (arg) {\n        buffer.forEach(function (callback) { return callback(arg); });\n        buffer.length = 0;\n    };\n    return {\n        add: add,\n        remove: remove,\n        drain: drain,\n    };\n}\n//# sourceMappingURL=boundedBuffer.js.map","export var 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 { startsWith, arrayFrom, includes, assign } from '../../tools/utils/polyfills';\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';\nvar 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];\nvar TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\n// eslint-disable-next-line local-rules/disallow-side-effects\nvar preStartTelemetryBuffer = createBoundedBuffer();\nvar onRawTelemetryEventCollected = function (event) {\n    preStartTelemetryBuffer.add(function () { return onRawTelemetryEventCollected(event); });\n};\nexport function startTelemetry(telemetryService, configuration) {\n    var _a;\n    var contextProvider;\n    var observable = new Observable();\n    var alreadySentEvents = new Set();\n    var telemetryEnabled = !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n    var telemetryEnabledPerType = (_a = {},\n        _a[TelemetryType.log] = telemetryEnabled,\n        _a[TelemetryType.configuration] = telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),\n        _a[TelemetryType.usage] = telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),\n        _a);\n    var runtimeEnvInfo = getRuntimeEnvInfo();\n    onRawTelemetryEventCollected = function (rawEvent) {\n        var stringifiedEvent = jsonStringify(rawEvent);\n        if (telemetryEnabledPerType[rawEvent.type] &&\n            alreadySentEvents.size < configuration.maxTelemetryEventsPerPage &&\n            !alreadySentEvents.has(stringifiedEvent)) {\n            var event_1 = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo);\n            observable.notify(event_1);\n            sendToExtension('telemetry', event_1);\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: \"5.34.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: arrayFrom(getExperimentalFeatures()),\n        }, contextProvider !== undefined ? contextProvider() : {});\n    }\n    return {\n        setContextProvider: function (provider) {\n            contextProvider = provider;\n        },\n        observable: 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    var events = [];\n    onRawTelemetryEventCollected = function (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 = function (event) {\n        preStartTelemetryBuffer.add(function () { return 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(assign({\n        type: TelemetryType.log,\n        message: message,\n        status: \"debug\" /* StatusType.debug */,\n    }, context));\n}\nexport function addTelemetryError(e, context) {\n    onRawTelemetryEventCollected(assign({\n        type: TelemetryType.log,\n        status: \"error\" /* StatusType.error */,\n    }, formatError(e), context));\n}\nexport function addTelemetryConfiguration(configuration) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.configuration,\n        configuration: configuration,\n    });\n}\nexport function addTelemetryUsage(usage) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.usage,\n        usage: usage,\n    });\n}\nexport function formatError(e) {\n    if (isError(e)) {\n        var 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: \"\".concat(\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */, \" \").concat(jsonStringify(e)),\n    };\n}\nexport function scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter(function (frame) { return !frame.url || ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) { return startsWith(frame.url, allowedFrameUrl); }); });\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { display } from '../../tools/display';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { assign } from '../../tools/utils/polyfills';\n/**\n * Clone input data and ensure known user properties (id, name, email)\n * are strings, as defined here:\n * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n */\nexport function sanitizeUser(newUser) {\n    // We shallow clone only to prevent mutation of user data.\n    var user = assign({}, newUser);\n    var keys = ['id', 'name', 'email'];\n    keys.forEach(function (key) {\n        if (key in user) {\n            user[key] = String(user[key]);\n        }\n    });\n    return user;\n}\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser) {\n    var isValid = getType(newUser) === 'object';\n    if (!isValid) {\n        display.error('Unsupported user:', newUser);\n    }\n    return isValid;\n}\nexport function generateAnonymousId() {\n    return Math.floor(Math.random() * Math.pow(2, 53)).toString(36);\n}\n//# sourceMappingURL=user.js.map","import { display } from '../tools/display';\nexport function displayAlreadyInitializedError(sdkName, initConfiguration) {\n    if (!initConfiguration.silentMultipleInit) {\n        display.error(\"\".concat(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        : \"\".concat(1e7, \"-\").concat(1e3, \"-\").concat(4e3, \"-\").concat(8e3, \"-\").concat(1e11).replace(/[018]/g, generateUUID);\n}\nvar COMMA_SEPARATED_KEY_VALUE = /([\\w-]+)\\s*=\\s*([^;]+)/g;\nexport function findCommaSeparatedValue(rawString, name) {\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        var 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    var result = new Map();\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        var 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    if (suffix === void 0) { suffix = ''; }\n    var lastChar = candidate.charCodeAt(length - 1);\n    var isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    var correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength) {\n        return candidate;\n    }\n    return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\n//# sourceMappingURL=stringUtils.js.map","import { clocksNow, combine, elapsed, generateUUID, toServerDuration } from '@datadog/browser-core';\nexport function createCustomVitalsState() {\n    var vitalsByName = new Map();\n    var vitalsByReference = new WeakMap();\n    return { vitalsByName: vitalsByName, vitalsByReference: 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(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processVital(vital, true));\n        }\n    }\n    return {\n        addDurationVital: addDurationVital,\n        startDurationVital: function (name, options) {\n            if (options === void 0) { options = {}; }\n            return startDurationVital(customVitalsState, name, options);\n        },\n        stopDurationVital: function (nameOrRef, options) {\n            if (options === void 0) { options = {}; }\n            stopDurationVital(addDurationVital, customVitalsState, nameOrRef, options);\n        },\n    };\n}\nexport function startDurationVital(_a, name, options) {\n    var vitalsByName = _a.vitalsByName, vitalsByReference = _a.vitalsByReference;\n    if (options === void 0) { options = {}; }\n    var vital = {\n        name: 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    var 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, _a, nameOrRef, options) {\n    var vitalsByName = _a.vitalsByName, vitalsByReference = _a.vitalsByReference;\n    if (options === void 0) { options = {}; }\n    var 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: 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    var 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: rawRumEvent,\n        startTime: vital.startClocks.relative,\n        customerContext: vital.context,\n        domainContext: {},\n    };\n}\n//# sourceMappingURL=vitalCollection.js.map","import { endsWith, includes } from '../tools/utils/polyfills';\nimport { getGlobalObject } from '../tools/getGlobalObject';\nexport function getEventBridge() {\n    var eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getCapabilities: function () {\n            var _a;\n            return JSON.parse(((_a = eventBridgeGlobal.getCapabilities) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal)) || '[]');\n        },\n        getPrivacyLevel: function () {\n            var _a;\n            return (_a = eventBridgeGlobal.getPrivacyLevel) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal);\n        },\n        getAllowedWebViewHosts: function () {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send: function (eventType, event, viewId) {\n            var view = viewId ? { id: viewId } : undefined;\n            eventBridgeGlobal.send(JSON.stringify({ eventType: eventType, event: event, view: view }));\n        },\n    };\n}\nexport function bridgeSupports(capability) {\n    var bridge = getEventBridge();\n    return !!bridge && includes(bridge.getCapabilities(), 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    var bridge = getEventBridge();\n    return (!!bridge &&\n        bridge\n            .getAllowedWebViewHosts()\n            .some(function (allowedHost) { return currentHost === allowedHost || endsWith(currentHost, \".\".concat(allowedHost)); }));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nimport { arrayFrom, startsWith } from './utils/polyfills';\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, _a) {\n    var _b = _a === void 0 ? {} : _a, computeHandlingStack = _b.computeHandlingStack;\n    var original = targetPrototype[method];\n    if (typeof original !== 'function') {\n        if (method in targetPrototype && startsWith(method, 'on')) {\n            original = noop;\n        }\n        else {\n            return { stop: noop };\n        }\n    }\n    var stopped = false;\n    var 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        var parameters = arrayFrom(arguments);\n        var postCallCallback;\n        callMonitored(onPreCall, null, [\n            {\n                target: this,\n                parameters: parameters,\n                onPostCall: function (callback) {\n                    postCallCallback = callback;\n                },\n                handlingStack: computeHandlingStack ? createHandlingStack() : undefined,\n            },\n        ]);\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        var 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: function () {\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    var originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    var stoppedInstrumentation = noop;\n    var instrumentation = function (target, value) {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(function () {\n            if (instrumentation !== stoppedInstrumentation) {\n                after(target, value);\n            }\n        }, 0);\n    };\n    var 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: function () {\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 { 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    var pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function buildUrl(url, base) {\n    var 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: \".concat(String(error), \" \").concat(jsonStringify({ url: url, base: base })));\n        }\n    }\n    if (base === undefined && !/:/.test(url)) {\n        throw new Error(\"Invalid URL: '\".concat(url, \"'\"));\n    }\n    var doc = document;\n    var anchorElement = doc.createElement('a');\n    if (base !== undefined) {\n        doc = document.implementation.createHTMLDocument('');\n        var 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}\nvar originalURL = URL;\nvar isURLSupported;\nfunction getSupportedUrl() {\n    if (isURLSupported === undefined) {\n        try {\n            var 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 { instrumentMethod } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { assign } from '../tools/utils/polyfills';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nvar 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(function (observable) {\n        if (!window.fetch) {\n            return;\n        }\n        var stop = instrumentMethod(window, 'fetch', function (call) { return beforeSend(call, observable); }, {\n            computeHandlingStack: true,\n        }).stop;\n        return stop;\n    });\n}\nfunction beforeSend(_a, observable) {\n    var parameters = _a.parameters, onPostCall = _a.onPostCall, handlingStack = _a.handlingStack;\n    var input = parameters[0], init = parameters[1];\n    var methodFromParams = init && init.method;\n    if (methodFromParams === undefined && input instanceof Request) {\n        methodFromParams = input.method;\n    }\n    var method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET';\n    var url = input instanceof Request ? input.url : normalizeUrl(String(input));\n    var startClocks = clocksNow();\n    var context = {\n        state: 'start',\n        init: init,\n        input: input,\n        method: method,\n        startClocks: startClocks,\n        url: url,\n        handlingStack: 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(function (responsePromise) { return afterSend(observable, responsePromise, context); });\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    var context = startContext;\n    function reportFetch(partialContext) {\n        context.state = 'resolve';\n        assign(context, partialContext);\n        observable.notify(context);\n    }\n    responsePromise.then(monitor(function (response) {\n        reportFetch({\n            response: response,\n            responseType: response.type,\n            status: response.status,\n            isAborted: false,\n        });\n    }), monitor(function (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: 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, options) {\n    if (expireDelay === void 0) { expireDelay = 0; }\n    var date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    var expires = \"expires=\".concat(date.toUTCString());\n    var sameSite = options && options.crossSite ? 'none' : 'strict';\n    var domain = options && options.domain ? \";domain=\".concat(options.domain) : '';\n    var secure = options && options.secure ? ';secure' : '';\n    var partitioned = options && options.partitioned ? ';partitioned' : '';\n    document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure).concat(partitioned);\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nvar 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        var testCookieName = \"dd_cookie_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n        var 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 */\nvar 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        var testCookieName = \"dd_site_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        var domainLevels = window.location.hostname.split('.');\n        var candidateDomain = domainLevels.pop();\n        while (domainLevels.length && !getCookie(testCookieName)) {\n            candidateDomain = \"\".concat(domainLevels.pop(), \".\").concat(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 var SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport var 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    var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    var 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 function isIE() {\n    return detectBrowserCached() === 0 /* Browser.IE */;\n}\nexport function isChromium() {\n    return detectBrowserCached() === 1 /* Browser.CHROMIUM */;\n}\nexport function isSafari() {\n    return detectBrowserCached() === 2 /* Browser.SAFARI */;\n}\nvar browserCache;\nfunction detectBrowserCached() {\n    return browserCache !== null && browserCache !== void 0 ? browserCache : (browserCache = detectBrowser());\n}\n// Exported only for tests\nexport function detectBrowser(browserWindow) {\n    var _a;\n    if (browserWindow === void 0) { browserWindow = window; }\n    var userAgent = browserWindow.navigator.userAgent;\n    if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) {\n        return 1 /* 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 2 /* Browser.SAFARI */;\n    }\n    if (browserWindow.document.documentMode) {\n        return 0 /* Browser.IE */;\n    }\n    return 3 /* Browser.OTHER */;\n}\n//# sourceMappingURL=browserDetection.js.map","export var SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\nexport var SESSION_COOKIE_EXPIRATION_DELAY = ONE_YEAR;\n//# sourceMappingURL=sessionConstants.js.map","export var SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;\nexport var 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 { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { generateAnonymousId } from '../user';\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation';\nexport var EXPIRED = '1';\nexport function getExpiredSessionState(previousSessionState) {\n    var expiredSessionState = {\n        isExpired: EXPIRED,\n    };\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.ANONYMOUS_USER_TRACKING)) {\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 = generateAnonymousId();\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(function (_a) {\n        var key = _a[0], value = _a[1];\n        return (key === 'anonymousId' ? \"aid=\".concat(value) : \"\".concat(key, \"=\").concat(value));\n    })\n        .join(SESSION_ENTRY_SEPARATOR));\n}\nexport function toSessionState(sessionString) {\n    var session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {\n            var matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                var key = matches[1], value = matches[2];\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 { isChromium } from '../../../tools/utils/browserDetection';\nimport { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../../tools/experimentalFeatures';\nimport { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n    var cookieOptions = buildCookieOptions(initConfiguration);\n    return areCookiesAuthorized(cookieOptions) ? { type: 'Cookie', cookieOptions: cookieOptions } : undefined;\n}\nexport function initCookieStrategy(cookieOptions) {\n    var 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: function (sessionState) { return expireSessionCookie(cookieOptions, sessionState); },\n    };\n    tryOldCookiesMigration(cookieStore);\n    return cookieStore;\n}\nfunction persistSessionCookie(options) {\n    return function (session) {\n        setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n    };\n}\nfunction expireSessionCookie(options, sessionState) {\n    var expiredSessionState = getExpiredSessionState(sessionState);\n    setCookie(SESSION_STORE_KEY, toSessionString(expiredSessionState), isExperimentalFeatureEnabled(ExperimentalFeature.ANONYMOUS_USER_TRACKING)\n        ? SESSION_COOKIE_EXPIRATION_DELAY\n        : SESSION_TIME_OUT_DELAY, options);\n}\nfunction retrieveSessionCookie() {\n    var sessionString = getCookie(SESSION_STORE_KEY);\n    var sessionState = toSessionState(sessionString);\n    return sessionState;\n}\nexport function buildCookieOptions(initConfiguration) {\n    var cookieOptions = {};\n    cookieOptions.secure =\n        !!initConfiguration.useSecureSessionCookie ||\n            !!initConfiguration.usePartitionedCrossSiteSessionCookie ||\n            !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.crossSite =\n        !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { getInitCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionStarted } from './sessionState';\nexport var OLD_SESSION_COOKIE_NAME = '_dd';\nexport var OLD_RUM_COOKIE_NAME = '_dd_r';\nexport var OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport var RUM_SESSION_KEY = 'rum';\nexport var 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    var sessionString = getInitCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        var oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME);\n        var oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME);\n        var oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME);\n        var session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        if (isSessionStarted(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nvar LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n    try {\n        var id = generateUUID();\n        var testKey = \"\".concat(LOCAL_STORAGE_TEST_KEY).concat(id);\n        localStorage.setItem(testKey, id);\n        var retrievedId = localStorage.getItem(testKey);\n        localStorage.removeItem(testKey);\n        return id === retrievedId ? { type: 'LocalStorage' } : undefined;\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy() {\n    return {\n        isLockEnabled: false,\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        expireSession: expireSessionFromLocalStorage,\n    };\n}\nfunction persistInLocalStorage(sessionState) {\n    localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n    var sessionString = localStorage.getItem(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction expireSessionFromLocalStorage(previousSessionState) {\n    persistInLocalStorage(getExpiredSessionState(previousSessionState));\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var LOCK_RETRY_DELAY = 10;\nexport var LOCK_MAX_TRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries) {\n    var _a;\n    if (numberOfRetries === void 0) { numberOfRetries = 0; }\n    var isLockEnabled = sessionStoreStrategy.isLockEnabled, persistSession = sessionStoreStrategy.persistSession, expireSession = sessionStoreStrategy.expireSession;\n    var persistWithLock = function (session) { return persistSession(assign({}, session, { lock: currentLock })); };\n    var retrieveStore = function () {\n        var session = sessionStoreStrategy.retrieveSession();\n        var lock = session.lock;\n        if (session.lock) {\n            delete session.lock;\n        }\n        return {\n            session: session,\n            lock: 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    var currentLock;\n    var 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    var 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(function () {\n        processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);\n    }, LOCK_RETRY_DELAY);\n}\nfunction next(sessionStore) {\n    ongoingOperations = undefined;\n    var 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 { assign } from '../../tools/utils/polyfills';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { getExpiredSessionState, isSessionInExpiredState, isSessionInNotStartedState, isSessionStarted, } from './sessionState';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\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 var STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Checks if cookies are available as the preferred storage\n * Else, checks if LocalStorage is allowed and available\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    var sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n    if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n        sessionStoreStrategyType = selectLocalStorageStrategy();\n    }\n    return sessionStoreStrategyType;\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, productKey, computeSessionState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    var sessionStateUpdateObservable = new Observable();\n    var sessionStoreStrategy = sessionStoreStrategyType.type === 'Cookie'\n        ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy();\n    var expireSession = sessionStoreStrategy.expireSession;\n    var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n    var sessionCache;\n    startSession();\n    var _a = throttle(function () {\n        processSessionStoreOperations({\n            process: function (sessionState) {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return;\n                }\n                var synchronizedSession = synchronizeSession(sessionState);\n                expandOrRenewSessionState(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (sessionState) {\n                if (isSessionStarted(sessionState) && !hasSessionInCache()) {\n                    renewSessionInCache(sessionState);\n                }\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }, STORAGE_POLL_DELAY), throttledExpandOrRenewSession = _a.throttled, cancelExpandOrRenewSession = _a.cancel;\n    function expandSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) { return (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: function (sessionState) {\n                return isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState) : undefined;\n            },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    function synchronizeSession(sessionState) {\n        if (isSessionInExpiredState(sessionState)) {\n            sessionState = getExpiredSessionState(sessionState);\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: function (sessionState) {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return getExpiredSessionState(sessionState);\n                }\n            },\n            after: function (sessionState) {\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\n    function expandOrRenewSessionState(sessionState) {\n        if (isSessionInNotStartedState(sessionState)) {\n            return false;\n        }\n        var _a = computeSessionState(sessionState[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\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);\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function updateSessionState(partialSessionState) {\n        processSessionStoreOperations({\n            process: function (sessionState) { return assign({}, sessionState, partialSessionState); },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    return {\n        expandOrRenewSession: throttledExpandOrRenewSession,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        sessionStateUpdateObservable: sessionStateUpdateObservable,\n        restartSession: startSession,\n        expire: function () {\n            cancelExpandOrRenewSession();\n            expireSession(sessionCache);\n            synchronizeSession(getExpiredSessionState(sessionCache));\n        },\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n        updateSessionState: 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    var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType);\n    return {\n        build: function (api, payload) {\n            var parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\n        trackType: 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    var path = \"/api/v2/\".concat(trackType);\n    var proxy = initConfiguration.proxy;\n    if (typeof proxy === 'string') {\n        var normalizedProxyUrl_1 = normalizeUrl(proxy);\n        return function (parameters) { return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters))); };\n    }\n    if (typeof proxy === 'function') {\n        return function (parameters) { return proxy({ path: path, parameters: parameters }); };\n    }\n    var host = buildEndpointHost(trackType, initConfiguration);\n    return function (parameters) { return \"https://\".concat(host).concat(path, \"?\").concat(parameters); };\n}\nfunction buildEndpointHost(trackType, initConfiguration) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US1 : _a, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\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 \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n    }\n    if (site === INTAKE_SITE_FED_STAGING) {\n        return \"http-intake.logs.\".concat(site);\n    }\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    return \"browser-intake-\".concat(domainParts.join('-'), \".\").concat(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(_a, trackType, configurationTags, api, _b) {\n    var clientToken = _a.clientToken, internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n    var retry = _b.retry, encoding = _b.encoding;\n    var tags = [\"sdk_version:\".concat(\"5.34.1\"), \"api:\".concat(api)].concat(configurationTags);\n    if (retry) {\n        tags.push(\"retry_count:\".concat(retry.count), \"retry_after:\".concat(retry.lastFailureStatus));\n    }\n    var parameters = [\n        'ddsource=browser',\n        \"ddtags=\".concat(encodeURIComponent(tags.join(','))),\n        \"dd-api-key=\".concat(clientToken),\n        \"dd-evp-origin-version=\".concat(encodeURIComponent(\"5.34.1\")),\n        'dd-evp-origin=browser',\n        \"dd-request-id=\".concat(generateUUID()),\n    ];\n    if (encoding) {\n        parameters.push(\"dd-evp-encoding=\".concat(encoding));\n    }\n    if (trackType === 'rum') {\n        parameters.push(\"batch_time=\".concat(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 var TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n    var env = configuration.env, service = configuration.service, version = configuration.version, datacenter = configuration.datacenter;\n    var 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    var valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;\n    if (rawValue.length > valueSizeLimit || hasForbiddenCharacters(rawValue)) {\n        display.warn(\"\".concat(key, \" value doesn't meet tag requirements and will be sanitized. \").concat(MORE_DETAILS, \" \").concat(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    var sanitizedValue = rawValue.replace(/,/g, '_');\n    return \"\".concat(key, \":\").concat(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 IE11.\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 { assign, includes } from '../../tools/utils/polyfills';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    var site = initConfiguration.site || INTAKE_SITE_US1;\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, tags);\n    return assign({\n        replica: replicaConfiguration,\n        site: site,\n    }, endpointBuilders);\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    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n    };\n    return assign({ 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(function (param) { return includes(url, 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 { assign } from '../../tools/utils/polyfills';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { TrackingConsent } from '../trackingConsent';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n};\nexport var TraceContextInjection = {\n    ALL: 'all',\n    SAMPLED: 'sampled',\n};\nfunction isString(tag, tagName) {\n    if (tag !== undefined && tag !== null && typeof tag !== 'string') {\n        display.error(\"\".concat(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. \".concat(MORE_DETAILS, \" \").concat(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(\"\".concat(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;\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 assign({\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        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}\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_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,\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        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 { ExperimentalFeature, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { getCrypto } from '../../browser/crypto';\nexport function createTraceIdentifier() {\n    return createIdentifier(64);\n}\nexport function createSpanIdentifier() {\n    return createIdentifier(63);\n}\nvar createIdentifierImplementationCache;\nfunction createIdentifier(bits) {\n    if (!createIdentifierImplementationCache) {\n        createIdentifierImplementationCache =\n            isExperimentalFeatureEnabled(ExperimentalFeature.CONSISTENT_TRACE_SAMPLING) && areBigIntIdentifiersSupported()\n                ? createIdentifierUsingBigInt\n                : createIdentifierUsingUint32Array;\n    }\n    return createIdentifierImplementationCache(bits);\n}\nexport function areBigIntIdentifiersSupported() {\n    try {\n        crypto.getRandomValues(new BigUint64Array(1));\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nfunction createIdentifierUsingBigInt(bits) {\n    var id = crypto.getRandomValues(new BigUint64Array(1))[0];\n    if (bits === 63) {\n        // eslint-disable-next-line no-bitwise\n        id >>= BigInt('1');\n    }\n    return id;\n}\n// TODO: remove this when all browser we support have BigInt support\nfunction createIdentifierUsingUint32Array(bits) {\n    var buffer = getCrypto().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    return {\n        toString: function (radix) {\n            if (radix === void 0) { radix = 10; }\n            var high = buffer[1];\n            var low = buffer[0];\n            var str = '';\n            do {\n                var 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    var traceId = id.toString(16);\n    // TODO: replace with String.prototype.padStart when we drop IE11 support\n    return Array(17 - traceId.length).join('0') + traceId;\n}\n//# sourceMappingURL=identifier.js.map","import { startsWith } from './utils/polyfills';\nimport { display } from './display';\nimport { getType } from './utils/typeUtils';\nexport function isMatchOption(item) {\n    var 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) {\n    if (useStartsWith === void 0) { useStartsWith = false; }\n    return list.some(function (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 ? startsWith(value, 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 getCrypto() {\n    // TODO: remove msCrypto when IE11 support is dropped\n    return window.crypto || window.msCrypto;\n}\n//# sourceMappingURL=crypto.js.map","import { objectEntries, shallowClone, isNumber, assign, find, getType, isMatchOption, matchList, TraceContextInjection, } from '@datadog/browser-core';\nimport { getCrypto } from '../../browser/crypto';\nimport { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier';\nimport { isTraceSampled } from './sampler';\nexport function isTracingOption(item) {\n    var 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: clearTracingIfNeeded,\n        traceFetch: function (context) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (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(function (key) {\n                        ;\n                        context.input.headers.append(key, tracingHeaders[key]);\n                    });\n                }\n                else {\n                    context.init = shallowClone(context.init);\n                    var headers_1 = [];\n                    if (context.init.headers instanceof Headers) {\n                        context.init.headers.forEach(function (value, key) {\n                            headers_1.push([key, value]);\n                        });\n                    }\n                    else if (Array.isArray(context.init.headers)) {\n                        context.init.headers.forEach(function (header) {\n                            headers_1.push(header);\n                        });\n                    }\n                    else if (context.init.headers) {\n                        Object.keys(context.init.headers).forEach(function (key) {\n                            headers_1.push([key, context.init.headers[key]]);\n                        });\n                    }\n                    context.init.headers = headers_1.concat(objectEntries(tracingHeaders));\n                }\n            });\n        },\n        traceXhr: function (context, xhr) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                Object.keys(tracingHeaders).forEach(function (name) {\n                    xhr.setRequestHeader(name, tracingHeaders[name]);\n                });\n            });\n        },\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, inject) {\n    if (!isTracingSupported() || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    var tracingOption = find(configuration.allowedTracingUrls, function (tracingOption) {\n        return matchList([tracingOption.match], context.url, true);\n    });\n    if (!tracingOption) {\n        return;\n    }\n    var traceId = createTraceIdentifier();\n    context.traceSampled =\n        !isNumber(configuration.traceSampleRate) || isTraceSampled(traceId, configuration.traceSampleRate);\n    if (!context.traceSampled && configuration.traceContextInjection !== TraceContextInjection.ALL) {\n        return;\n    }\n    context.traceId = traceId;\n    context.spanId = createSpanIdentifier();\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes));\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\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    var tracingHeaders = {};\n    propagatorTypes.forEach(function (propagatorType) {\n        switch (propagatorType) {\n            case 'datadog': {\n                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                assign(tracingHeaders, {\n                    traceparent: \"00-0000000000000000\".concat(toPaddedHexadecimalString(traceId), \"-\").concat(toPaddedHexadecimalString(spanId), \"-0\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            // https://github.com/openzipkin/b3-propagation\n            case 'b3': {\n                assign(tracingHeaders, {\n                    b3: \"\".concat(toPaddedHexadecimalString(traceId), \"-\").concat(toPaddedHexadecimalString(spanId), \"-\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            case 'b3multi': {\n                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 { performDraw } from '@datadog/browser-core';\nexport function isTraceSampled(identifier, 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    // For simplicity, we don't use consistent sampling for browser that don't support BigInt\n    // TODO: remove this when all browser we support have BigInt support\n    if (typeof identifier !== 'bigint') {\n        return performDraw(sampleRate);\n    }\n    // Offer consistent sampling for the same trace id across different environments. The rule 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    var knuthFactor = BigInt('1111111111111111111');\n    var twoPow64 = BigInt('0x10000000000000000'); // 2n ** 64n\n    var hash = (identifier * knuthFactor) % twoPow64;\n    return Number(hash) <= (sampleRate / 100) * Number(twoPow64);\n}\n//# sourceMappingURL=sampler.js.map","import { getType, arrayFrom, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, TraceContextInjection, display, objectHasValue, validateAndBuildConfiguration, isSampleRate, } from '@datadog/browser-core';\nimport { isTracingOption } from '../tracing/tracer';\nexport var DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'datadog'];\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b;\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    var allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);\n    if (!allowedTracingUrls) {\n        return;\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    var sessionReplaySampleRate = (_a = initConfiguration.sessionReplaySampleRate) !== null && _a !== void 0 ? _a : 0;\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version || undefined,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: sessionReplaySampleRate,\n        startSessionReplayRecordingManually: initConfiguration.startSessionReplayRecordingManually !== undefined\n            ? !!initConfiguration.startSessionReplayRecordingManually\n            : sessionReplaySampleRate === 0,\n        traceSampleRate: initConfiguration.traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_b = initConfiguration.excludedActivityUrls) !== null && _b !== void 0 ? _b : [],\n        workerUrl: initConfiguration.workerUrl,\n        compressIntakeRequests: !!initConfiguration.compressIntakeRequests,\n        trackUserInteractions: !!initConfiguration.trackUserInteractions,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: !!initConfiguration.trackResources,\n        trackLongTasks: !!initConfiguration.trackLongTasks,\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.ALL,\n        plugins: initConfiguration.plugins || [],\n    }, baseConfiguration);\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    var tracingOptions = [];\n    initConfiguration.allowedTracingUrls.forEach(function (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    var usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                DEFAULT_PROPAGATOR_TYPES.forEach(function (propagatorType) { return 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(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n        });\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\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(function (plugin) { var _a; return assign({ name: plugin.name }, (_a = plugin.getConfigurationTelemetry) === null || _a === void 0 ? void 0 : _a.call(plugin)); }),\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","import { display, addEventListener, assign } from '@datadog/browser-core';\nexport var REMOTE_CONFIGURATION_URL = 'https://d3uc069fcn7uxw.cloudfront.net/configuration';\nexport function fetchAndApplyRemoteConfiguration(initConfiguration, callback) {\n    fetchRemoteConfiguration(initConfiguration, function (remoteInitConfiguration) {\n        callback(applyRemoteConfiguration(initConfiguration, remoteInitConfiguration));\n    });\n}\nexport function applyRemoteConfiguration(initConfiguration, remoteInitConfiguration) {\n    return assign({}, initConfiguration, remoteInitConfiguration);\n}\nexport function fetchRemoteConfiguration(configuration, callback) {\n    var xhr = new XMLHttpRequest();\n    addEventListener(configuration, xhr, 'load', function () {\n        if (xhr.status === 200) {\n            callback(JSON.parse(xhr.responseText));\n        }\n        else {\n            displayRemoteConfigurationFetchingError();\n        }\n    });\n    addEventListener(configuration, xhr, 'error', function () {\n        displayRemoteConfigurationFetchingError();\n    });\n    xhr.open('GET', \"\".concat(REMOTE_CONFIGURATION_URL, \"/\").concat(encodeURIComponent(configuration.remoteConfigurationId), \".json\"));\n    xhr.send();\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, assign, getEventBridge, ExperimentalFeature, isExperimentalFeatureEnabled, 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(_a, getCommonContext, trackingConsentState, customVitalsState, doStartRum) {\n    var ignoreInitIfSyntheticsWillInjectRum = _a.ignoreInitIfSyntheticsWillInjectRum, startDeflateWorker = _a.startDeflateWorker;\n    var bufferApiCalls = createBoundedBuffer();\n    var firstStartViewCall;\n    var deflateWorker;\n    var cachedInitConfiguration;\n    var cachedConfiguration;\n    var trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);\n    function tryStartRum() {\n        if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        trackingConsentStateSubscription.unsubscribe();\n        var 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        var startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions);\n        bufferApiCalls.drain(startRumResult);\n    }\n    function doInit(initConfiguration) {\n        var 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        var 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    var addDurationVital = function (vital) {\n        bufferApiCalls.add(function (startRumResult) { return startRumResult.addDurationVital(vital); });\n    };\n    return {\n        init: function (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: initConfiguration, publicApi: publicApi });\n            if (initConfiguration.remoteConfigurationId &&\n                isExperimentalFeatureEnabled(ExperimentalFeature.REMOTE_CONFIGURATION)) {\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: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addTiming(name, time); });\n        },\n        startView: function (options, startClocks) {\n            if (startClocks === void 0) { startClocks = clocksNow(); }\n            var callback = function (startRumResult) {\n                startRumResult.startView(options, startClocks);\n            };\n            bufferApiCalls.add(callback);\n            if (!firstStartViewCall) {\n                firstStartViewCall = { options: options, callback: callback };\n                tryStartRum();\n            }\n        },\n        setViewName: function (name) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.setViewName(name); });\n        },\n        setViewContext: function (context) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.setViewContext(context); });\n        },\n        setViewContextProperty: function (key, value) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.setViewContextProperty(key, value); });\n        },\n        addAction: function (action, commonContext) {\n            if (commonContext === void 0) { commonContext = getCommonContext(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addAction(action, commonContext); });\n        },\n        addError: function (providedError, commonContext) {\n            if (commonContext === void 0) { commonContext = getCommonContext(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addError(providedError, commonContext); });\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addFeatureFlagEvaluation(key, value); });\n        },\n        startDurationVital: function (name, options) {\n            return startDurationVital(customVitalsState, name, options);\n        },\n        stopDurationVital: function (name, options) {\n            stopDurationVital(addDurationVital, customVitalsState, name, options);\n        },\n        addDurationVital: addDurationVital,\n    };\n}\nfunction overrideInitConfigurationForBridge(initConfiguration) {\n    var _a, _b;\n    return assign({}, 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","export function callPluginsMethod(plugins, methodName, parameter) {\n    if (!plugins) {\n        return;\n    }\n    for (var _i = 0, plugins_1 = plugins; _i < plugins_1.length; _i++) {\n        var plugin = plugins_1[_i];\n        var method = plugin[methodName];\n        if (method) {\n            method(parameter);\n        }\n    }\n}\n//# sourceMappingURL=plugins.js.map","import { Observable } from '../tools/observable';\nimport { objectValues, includes } from '../tools/utils/polyfills';\nimport { addEventListeners, addEventListener } from './addEventListener';\nexport var 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(function (observable) {\n        var stopListeners = addEventListeners(configuration, window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */], function (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 }).stop;\n        var stopBeforeUnloadListener = addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, function () {\n            observable.notify({ reason: PageExitReason.UNLOADING });\n        }).stop;\n        return function () {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n}\nexport function isPageExitReason(reason) {\n    return includes(objectValues(PageExitReason), reason);\n}\n//# sourceMappingURL=pageExitObservable.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    var MutationObserver = getMutationObserverConstructor();\n    return new Observable(function (observable) {\n        if (!MutationObserver) {\n            return;\n        }\n        var observer = new MutationObserver(monitor(function () { return observable.notify(); }));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return function () { return observer.disconnect(); };\n    });\n}\nexport function getMutationObserverConstructor() {\n    var constructor;\n    var 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            var patchedInstance = new browserWindow.MutationObserver(noop);\n            var 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","export var 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","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    var eventCount = 0;\n    var allowNextEvent = false;\n    return {\n        isLimitReached: function () {\n            if (eventCount === 0) {\n                setTimeout(function () {\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 \".concat(eventType, \"s by minute: \").concat(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 { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from '@datadog/browser-core';\nexport function getSyntheticsContext() {\n    var testId = getSyntheticsTestId();\n    var resultId = getSyntheticsResultId();\n    if (testId && resultId) {\n        return {\n            test_id: testId,\n            result_id: resultId,\n            injected: willSyntheticsInjectRum(),\n        };\n    }\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core';\n/**\n * Current limitation:\n * - field path do not support array, 'a.b.c' only\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    var clone = deepClone(object);\n    var result = modifier(clone);\n    objectEntries(modifiableFieldPaths).forEach(function (_a) {\n        var fieldPath = _a[0], fieldType = _a[1];\n        var newValue = get(clone, fieldPath);\n        var newType = getType(newValue);\n        if (newType === fieldType) {\n            set(object, fieldPath, sanitize(newValue));\n        }\n        else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n            set(object, fieldPath, {});\n        }\n    });\n    return result;\n}\nfunction get(object, path) {\n    var current = object;\n    for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {\n        var field = _a[_i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        current = current[field];\n    }\n    return current;\n}\nfunction set(object, path, value) {\n    var current = object;\n    var fields = path.split('.');\n    for (var i = 0; i < fields.length; i += 1) {\n        var field = fields[i];\n        if (!isValidObject(current)) {\n            return;\n        }\n        if (i !== fields.length - 1) {\n            current = current[field];\n        }\n        else {\n            current[field] = value;\n        }\n    }\n}\nfunction isValidObject(object) {\n    return getType(object) === 'object';\n}\nfunction isValidObjectContaining(object, field) {\n    return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field);\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, assign, round, isExperimentalFeatureEnabled, ExperimentalFeature, getConnectivity, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { limitModification } from './limitModification';\nvar VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.name': 'string',\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nvar USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nvar ROOT_MODIFIABLE_FIELD_PATHS = {\n    service: 'string',\n    version: 'string',\n};\nvar modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewHistory, urlContexts, actionContexts, displayContext, ciVisibilityContext, getCommonContext, reportError) {\n    var _a, _b;\n    modifiableFieldPathsByEvent = (_a = {},\n        _a[\"view\" /* RumEventType.VIEW */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"error\" /* RumEventType.ERROR */] = assign({\n            'error.message': 'string',\n            'error.stack': 'string',\n            'error.resource.url': 'string',\n            'error.fingerprint': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"resource\" /* RumEventType.RESOURCE */] = assign({\n            'resource.url': 'string',\n        }, isExperimentalFeatureEnabled(ExperimentalFeature.WRITABLE_RESOURCE_GRAPHQL)\n            ? {\n                'resource.graphql': 'object',\n            }\n            : {}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"action\" /* RumEventType.ACTION */] = assign({\n            'action.target.name': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"long_task\" /* RumEventType.LONG_TASK */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"vital\" /* RumEventType.VITAL */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a);\n    var eventRateLimiters = (_b = {},\n        _b[\"error\" /* RumEventType.ERROR */] = createEventRateLimiter(\"error\" /* RumEventType.ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"action\" /* RumEventType.ACTION */] = createEventRateLimiter(\"action\" /* RumEventType.ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"vital\" /* RumEventType.VITAL */] = createEventRateLimiter(\"vital\" /* RumEventType.VITAL */, configuration.eventRateLimiterThreshold, reportError),\n        _b);\n    var syntheticsContext = getSyntheticsContext();\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (_a) {\n        var startTime = _a.startTime, rawRumEvent = _a.rawRumEvent, domainContext = _a.domainContext, savedCommonContext = _a.savedCommonContext, customerContext = _a.customerContext;\n        var viewHistoryEntry = viewHistory.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (session && viewHistoryEntry && urlContext) {\n            var commonContext = savedCommonContext || getCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var 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() ? \"5.34.1\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: viewHistoryEntry.service || configuration.service,\n                version: viewHistoryEntry.version || configuration.version,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext\n                        ? \"synthetics\" /* SessionType.SYNTHETICS */\n                        : ciVisibilityContext.get()\n                            ? \"ci_test\" /* SessionType.CI_TEST */\n                            : \"user\" /* SessionType.USER */,\n                },\n                view: {\n                    id: viewHistoryEntry.id,\n                    name: viewHistoryEntry.name,\n                    url: urlContext.url,\n                    referrer: urlContext.referrer,\n                },\n                action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n                synthetics: syntheticsContext,\n                ci_test: ciVisibilityContext.get(),\n                display: displayContext.get(),\n                connectivity: getConnectivity(),\n            };\n            var serverRumEvent = combine(rumContext, rawRumEvent);\n            serverRumEvent.context = combine(commonContext.context, viewHistoryEntry.context, customerContext);\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 (\n            // TODO: remove ff and should always add anonymous user id\n            isExperimentalFeatureEnabled(ExperimentalFeature.ANONYMOUS_USER_TRACKING) &&\n                !commonContext.user.anonymous_id) {\n                commonContext.user.anonymous_id = session.anonymousId;\n            }\n            if (!isEmptyObject(commonContext.user)) {\n                ;\n                serverRumEvent.usr = commonContext.user;\n            }\n            if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n                if (isEmptyObject(serverRumEvent.context)) {\n                    delete serverRumEvent.context;\n                }\n                lifeCycle.notify(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, serverRumEvent);\n            }\n        }\n    });\n}\nfunction shouldSend(event, beforeSend, domainContext, eventRateLimiters) {\n    var _a;\n    if (beforeSend) {\n        var result = limitModification(event, modifiableFieldPathsByEvent[event.type], function (event) {\n            return beforeSend(event, domainContext);\n        });\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    var rateLimitReached = (_a = eventRateLimiters[event.type]) === null || _a === void 0 ? void 0 : _a.isLimitReached();\n    return !rateLimitReached;\n}\nfunction needToAssembleWithAction(event) {\n    return [\"error\" /* RumEventType.ERROR */, \"resource\" /* RumEventType.RESOURCE */, \"long_task\" /* RumEventType.LONG_TASK */].indexOf(event.type) !== -1;\n}\n//# sourceMappingURL=assembly.js.map","// eslint-disable-next-line no-restricted-syntax\nvar AbstractLifeCycle = /** @class */ (function () {\n    function AbstractLifeCycle() {\n        this.callbacks = {};\n    }\n    AbstractLifeCycle.prototype.notify = function (eventType, data) {\n        var eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach(function (callback) { return callback(data); });\n        }\n    };\n    AbstractLifeCycle.prototype.subscribe = function (eventType, callback) {\n        var _this = this;\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: function () {\n                _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) { return callback !== other; });\n            },\n        };\n    };\n    return AbstractLifeCycle;\n}());\nexport { AbstractLifeCycle };\n//# sourceMappingURL=abstractLifeCycle.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","import { setInterval, clearInterval } from './timer';\nimport { removeItem } from './utils/arrayUtils';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\nexport function createValueHistory(_a) {\n    var expireDelay = _a.expireDelay, maxEntries = _a.maxEntries;\n    var entries = [];\n    var clearOldValuesInterval = setInterval(function () { return clearOldValues(); }, CLEAR_OLD_VALUES_INTERVAL);\n    function clearOldValues() {\n        var oldTimeThreshold = relativeNow() - expireDelay;\n        while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {\n            entries.pop();\n        }\n    }\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        var entry = {\n            value: value,\n            startTime: startTime,\n            endTime: END_OF_TIMES,\n            remove: function () {\n                removeItem(entries, entry);\n            },\n            close: function (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, options) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        if (options === void 0) { options = { returnInactive: false }; }\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\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        var 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, duration) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        if (duration === void 0) { duration = 0; }\n        var endTime = addDuration(startTime, duration);\n        return entries\n            .filter(function (entry) { return entry.startTime <= endTime && startTime <= entry.endTime; })\n            .map(function (entry) { return entry.value; });\n    }\n    /**\n     * Remove all entries from this collection.\n     */\n    function reset() {\n        entries = [];\n    }\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    function stop() {\n        clearInterval(clearOldValuesInterval);\n    }\n    return { add: add, find: find, closeActive: closeActive, findAll: findAll, reset: reset, stop: stop };\n}\n//# sourceMappingURL=valueHistory.js.map","import { SESSION_TIME_OUT_DELAY, createValueHistory } from '@datadog/browser-core';\nexport var VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewHistory(lifeCycle) {\n    var viewValueHistory = createValueHistory({ expireDelay: VIEW_CONTEXT_TIME_OUT_DELAY });\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, function (view) {\n        viewValueHistory.add(buildViewHistoryEntry(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(5 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewValueHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_UPDATED */, function (viewUpdate) {\n        var 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(9 /* LifeCycleEventType.SESSION_RENEWED */, function () {\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: function (startTime) { return viewValueHistory.find(startTime); },\n        stop: function () {\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';\nvar xhrObservable;\nvar 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(function (observable) {\n        var stopInstrumentingStart = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr).stop;\n        var stopInstrumentingSend = instrumentMethod(XMLHttpRequest.prototype, 'send', function (call) {\n            sendXhr(call, configuration, observable);\n        }, { computeHandlingStack: true }).stop;\n        var stopInstrumentingAbort = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr).stop;\n        return function () {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n}\nfunction openXhr(_a) {\n    var xhr = _a.target, _b = _a.parameters, method = _b[0], url = _b[1];\n    xhrContexts.set(xhr, {\n        state: 'open',\n        method: String(method).toUpperCase(),\n        url: normalizeUrl(String(url)),\n    });\n}\nfunction sendXhr(_a, configuration, observable) {\n    var xhr = _a.target, handlingStack = _a.handlingStack;\n    var context = xhrContexts.get(xhr);\n    if (!context) {\n        return;\n    }\n    var startContext = context;\n    startContext.state = 'start';\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = xhr;\n    startContext.handlingStack = handlingStack;\n    var hasBeenReported = false;\n    var stopInstrumentingOnReadyStateChange = instrumentMethod(xhr, 'onreadystatechange', function () {\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    }).stop;\n    var onEnd = function () {\n        unsubscribeLoadEndListener();\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        var 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    var unsubscribeLoadEndListener = addEventListener(configuration, xhr, 'loadend', onEnd).stop;\n    observable.notify(startContext);\n}\nfunction abortXhr(_a) {\n    var xhr = _a.target;\n    var context = xhrContexts.get(xhr);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { addTelemetryDebug, elapsed, getPathName, includes, isValidUrl, toServerDuration, isIntakeUrl, } from '@datadog/browser-core';\nexport var FAKE_INITIAL_DOCUMENT = 'initial_document';\nvar RESOURCE_TYPES = [\n    [\"document\" /* ResourceType.DOCUMENT */, function (initiatorType) { return FAKE_INITIAL_DOCUMENT === initiatorType; }],\n    [\"xhr\" /* ResourceType.XHR */, function (initiatorType) { return 'xmlhttprequest' === initiatorType; }],\n    [\"fetch\" /* ResourceType.FETCH */, function (initiatorType) { return 'fetch' === initiatorType; }],\n    [\"beacon\" /* ResourceType.BEACON */, function (initiatorType) { return 'beacon' === initiatorType; }],\n    [\"css\" /* ResourceType.CSS */, function (_, path) { return /\\.css$/i.test(path); }],\n    [\"js\" /* ResourceType.JS */, function (_, path) { return /\\.js$/i.test(path); }],\n    [\n        \"image\" /* ResourceType.IMAGE */,\n        function (initiatorType, path) {\n            return includes(['image', 'img', 'icon'], initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null;\n        },\n    ],\n    [\"font\" /* ResourceType.FONT */, function (_, path) { return /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null; }],\n    [\n        \"media\" /* ResourceType.MEDIA */,\n        function (initiatorType, path) {\n            return includes(['audio', 'video'], initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null;\n        },\n    ],\n];\nexport function computeResourceEntryType(entry) {\n    var url = entry.name;\n    if (!isValidUrl(url)) {\n        addTelemetryDebug(\"Failed to construct URL for \\\"\".concat(entry.name, \"\\\"\"));\n        return \"other\" /* ResourceType.OTHER */;\n    }\n    var path = getPathName(url);\n    for (var _i = 0, RESOURCE_TYPES_1 = RESOURCE_TYPES; _i < RESOURCE_TYPES_1.length; _i++) {\n        var _a = RESOURCE_TYPES_1[_i], type = _a[0], isType = _a[1];\n        if (isType(entry.initiatorType, path)) {\n            return type;\n        }\n    }\n    return \"other\" /* ResourceType.OTHER */;\n}\nfunction areInOrder() {\n    var numbers = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        numbers[_i] = arguments[_i];\n    }\n    for (var 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    var duration = entry.duration, startTime = entry.startTime, responseEnd = entry.responseEnd;\n    // Safari duration is always 0 on timings blocked by cross origin policies.\n    if (duration === 0 && startTime < responseEnd) {\n        return toServerDuration(elapsed(startTime, responseEnd));\n    }\n    return toServerDuration(duration);\n}\nexport function computeResourceEntryDetails(entry) {\n    if (!hasValidResourceEntryTimings(entry)) {\n        return undefined;\n    }\n    var startTime = entry.startTime, fetchStart = entry.fetchStart, workerStart = entry.workerStart, redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd, domainLookupStart = entry.domainLookupStart, domainLookupEnd = entry.domainLookupEnd, connectStart = entry.connectStart, secureConnectionStart = entry.secureConnectionStart, connectEnd = entry.connectEnd, requestStart = entry.requestStart, responseStart = entry.responseStart, responseEnd = entry.responseEnd;\n    var 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    var areCommonTimingsInOrder = areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd);\n    var 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        var encodedBodySize = entry.encodedBodySize, decodedBodySize = entry.decodedBodySize, transferSize = entry.transferSize;\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}\nvar DATA_URL_REGEX = /data:(.+)?(;base64)?,/g;\nexport var 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 \"\".concat(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';\nvar nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    var tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable(configuration).subscribe(function (rawContext) {\n        var 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(6 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(7 /* 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: function () { return subscription.unsubscribe(); } };\n}\nexport function trackFetch(lifeCycle, tracer) {\n    var subscription = initFetchObservable().subscribe(function (rawContext) {\n        var 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(6 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, function (duration) {\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(7 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration: 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: function () { return subscription.unsubscribe(); } };\n}\nfunction getNextRequestIndex() {\n    var result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\nfunction waitForResponseToComplete(context, callback) {\n    var 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, function () {\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 { addEventListener, Observable, setTimeout, clearTimeout, monitor, includes } 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(function (observable) {\n        if (!window.PerformanceObserver) {\n            return;\n        }\n        var handlePerformanceEntries = function (entries) {\n            var rumPerformanceEntries = filterRumPerformanceEntries(entries);\n            if (rumPerformanceEntries.length > 0) {\n                observable.notify(rumPerformanceEntries);\n            }\n        };\n        var timeoutId;\n        var isObserverInitializing = true;\n        var observer = new PerformanceObserver(monitor(function (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(function () { return 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            var fallbackSupportedEntryTypes = [\n                RumPerformanceEntryType.RESOURCE,\n                RumPerformanceEntryType.NAVIGATION,\n                RumPerformanceEntryType.LONG_TASK,\n                RumPerformanceEntryType.PAINT,\n            ];\n            if (includes(fallbackSupportedEntryTypes, options.type)) {\n                if (options.buffered) {\n                    timeoutId = setTimeout(function () { return 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        var stopFirstInputTiming;\n        if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT) &&\n            options.type === RumPerformanceEntryType.FIRST_INPUT) {\n            ;\n            (stopFirstInputTiming = retrieveFirstInputTiming(configuration, function (timing) {\n                handlePerformanceEntries([timing]);\n            }).stop);\n        }\n        return function () {\n            observer.disconnect();\n            if (stopFirstInputTiming) {\n                stopFirstInputTiming();\n            }\n            clearTimeout(timeoutId);\n        };\n    });\n}\nvar 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', function () {\n            performance.clearResourceTimings();\n        });\n    }\n    return function () {\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(function (entry) { return !isForbiddenResource(entry); });\n}\nfunction isForbiddenResource(entry) {\n    return (entry.entryType === RumPerformanceEntryType.RESOURCE &&\n        (!isAllowedRequestUrl(entry.name) || !hasValidResourceEntryDuration(entry)));\n}\n//# sourceMappingURL=performanceObservable.js.map","export function 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 { 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    var reader = stream.getReader();\n    var chunks = [];\n    var readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor(function (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(function (error) { return 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        var bytes;\n        var limitExceeded;\n        if (options.collectStreamBody) {\n            var completeBuffer_1;\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_1 = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer_1 = new Uint8Array(readBytesCount);\n                var offset_1 = 0;\n                chunks.forEach(function (chunk) {\n                    completeBuffer_1.set(chunk, offset_1);\n                    offset_1 += chunk.length;\n                });\n            }\n            bytes = completeBuffer_1.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer_1.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(_a) {\n    var lifeCycle = _a.lifeCycle, isChildEvent = _a.isChildEvent, _b = _a.onChange, callback = _b === void 0 ? noop : _b;\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (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: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: 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    var startTimeStamp = dateNow();\n    var timingSent = false;\n    var 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 */], function (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        var 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: function () { return ({}); },\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 }).stop;\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 */], function (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            var 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 { 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 var PAGE_ACTIVITY_VALIDATION_DELAY = 100;\n// Delay to wait after a page activity to end the tracking process\nexport var 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    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    var pageActivityEndTimeoutId;\n    var hasCompleted = false;\n    var validationTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: false }); }), PAGE_ACTIVITY_VALIDATION_DELAY);\n    var maxDurationTimeoutId = maxDuration !== undefined\n        ? setTimeout(monitor(function () { return complete({ hadActivity: true, end: timeStampNow() }); }), maxDuration)\n        : undefined;\n    var pageActivitySubscription = pageActivityObservable.subscribe(function (_a) {\n        var isBusy = _a.isBusy;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: true, end: lastChangeTime }); }), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    var stop = function () {\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: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    return new Observable(function (observable) {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), windowOpenObservable.subscribe(notifyPageActivity), createPerformanceObservable(configuration, { type: RumPerformanceEntryType.RESOURCE }).subscribe(function (entries) {\n            if (entries.some(function (entry) { return !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_STARTED */, function (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(7 /* LifeCycleEventType.REQUEST_COMPLETED */, function (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 function () {\n            subscriptions.forEach(function (s) { return 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","// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str) {\n    if (window.CSS && window.CSS.escape) {\n        return window.CSS.escape(str);\n    }\n    // eslint-disable-next-line no-control-regex\n    return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n        if (asCodePoint) {\n            // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n            if (ch === '\\0') {\n                return '\\uFFFD';\n            }\n            // Control characters and (dependent upon position) numbers get escaped as code points\n            return \"\".concat(ch.slice(0, -1), \"\\\\\").concat(ch.charCodeAt(ch.length - 1).toString(16), \" \");\n        }\n        // Other potentially-special ASCII characters get backslash-escaped\n        return \"\\\\\".concat(ch);\n    });\n}\nexport function elementMatches(element, selector) {\n    if (element.matches) {\n        return element.matches(selector);\n    }\n    // IE11 support\n    if (element.msMatchesSelector) {\n        return element.msMatchesSelector(selector);\n    }\n    return false;\n}\n/**\n * Return the parentElement of an node\n *\n * In cases where parentElement is not supported, such as in IE11 for SVG nodes, we fallback to parentNode\n */\nexport function getParentElement(node) {\n    if (node.parentElement) {\n        return node.parentElement;\n    }\n    while (node.parentNode) {\n        if (node.parentNode.nodeType === Node.ELEMENT_NODE) {\n            return node.parentNode;\n        }\n        node = node.parentNode;\n    }\n    return null;\n}\n/**\n * Return the classList of an element or an array of classes if classList is not supported\n *\n * In cases where classList is not supported, such as in IE11 for SVG and MathML elements,\n * we fallback to using element.getAttribute('class').\n * We opt for element.getAttribute('class') over element.className because className returns an SVGAnimatedString for SVG elements.\n */\nexport function getClassList(element) {\n    if (element.classList) {\n        return element.classList;\n    }\n    var classes = (element.getAttribute('class') || '').trim();\n    return classes ? classes.split(/\\s+/) : [];\n}\n// ie11 supports WeakMap but not WeakSet\nvar PLACEHOLDER = 1;\n// eslint-disable-next-line no-restricted-syntax\nvar WeakSet = /** @class */ (function () {\n    function WeakSet(initialValues) {\n        var _this = this;\n        this.map = new WeakMap();\n        if (initialValues) {\n            initialValues.forEach(function (value) { return _this.map.set(value, PLACEHOLDER); });\n        }\n    }\n    WeakSet.prototype.add = function (value) {\n        this.map.set(value, PLACEHOLDER);\n        return this;\n    };\n    WeakSet.prototype.delete = function (value) {\n        return this.map.delete(value);\n    };\n    WeakSet.prototype.has = function (value) {\n        return this.map.has(value);\n    };\n    return WeakSet;\n}());\nexport { WeakSet };\n//# sourceMappingURL=polyfills.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    var 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    var 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';\nimport { elementMatches } from '../browser/polyfills';\nexport var 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 var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_PREFIX = 'dd-privacy-';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var 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};\nvar 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    var parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode\n        ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel, cache)\n        : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    var 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        var 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        var 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 (elementMatches(node, getPrivacySelector(NodePrivacyLevel.HIDDEN))) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.MASK))) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.MASK_USER_INPUT))) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (elementMatches(node, 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    var 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 var censorText = function (text) { return 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    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var 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        var 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        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var 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 \"[\".concat(PRIVACY_ATTR_NAME, \"=\\\"\").concat(privacyLevel, \"\\\"], .\").concat(PRIVACY_CLASS_PREFIX).concat(privacyLevel);\n}\n//# sourceMappingURL=privacy.js.map","import { safeTruncate, isIE, find } from '@datadog/browser-core';\nimport { getParentElement } from '../../browser/polyfills';\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 var DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name';\nexport var ACTION_NAME_PLACEHOLDER = 'Masked Element';\nexport function getActionNameFromElement(element, _a, nodePrivacyLevel) {\n    var enablePrivacyForActionName = _a.enablePrivacyForActionName, userProgrammaticAttribute = _a.actionNameAttribute;\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    var 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    var elementWithAttribute;\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    // If available, use element.closest() to match get the attribute from the element or any of its\n    // parent.  Else fallback to a more traditional implementation.\n    if (supportsElementClosest()) {\n        elementWithAttribute = targetElement.closest(\"[\".concat(programmaticAttribute, \"]\"));\n    }\n    else {\n        var element = targetElement;\n        while (element) {\n            if (element.hasAttribute(programmaticAttribute)) {\n                elementWithAttribute = element;\n                break;\n            }\n            element = getParentElement(element);\n        }\n    }\n    if (!elementWithAttribute) {\n        return;\n    }\n    var name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nvar priorityStrategies = [\n    // associated LABEL text\n    function (element, userProgrammaticAttribute, privacy) {\n        // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n        // instead\n        if (supportsLabelProperty()) {\n            if ('labels' in element && element.labels && element.labels.length > 0) {\n                return getActionNameFromTextualContent(element.labels[0], userProgrammaticAttribute);\n            }\n        }\n        else if (element.id) {\n            var label = element.ownerDocument &&\n                find(element.ownerDocument.querySelectorAll('label'), function (label) { return label.htmlFor === element.id; });\n            return label && getActionNameFromTextualContent(label, userProgrammaticAttribute, privacy);\n        }\n    },\n    // INPUT button (and associated) value\n    function (element) {\n        if (element.nodeName === 'INPUT') {\n            var input = element;\n            var 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    function (element, userProgrammaticAttribute, privacyEnabledActionName) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName);\n        }\n    },\n    function (element) { return getActionNameFromStandardAttribute(element, 'aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute, privacyEnabledActionName) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return {\n                name: labelledByAttribute\n                    .split(/\\s+/)\n                    .map(function (id) { return getElementById(element, id); })\n                    .filter(function (label) { return Boolean(label); })\n                    .map(function (element) { return getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName); })\n                    .join(' '),\n                nameSource: \"text_content\" /* ActionNameSource.TEXT_CONTENT */,\n            };\n        }\n    },\n    function (element) { return getActionNameFromStandardAttribute(element, 'alt'); },\n    function (element) { return getActionNameFromStandardAttribute(element, 'name'); },\n    function (element) { return getActionNameFromStandardAttribute(element, 'title'); },\n    function (element) { return getActionNameFromStandardAttribute(element, 'placeholder'); },\n    // SELECT first OPTION text\n    function (element, userProgrammaticAttribute) {\n        if ('options' in element && element.options.length > 0) {\n            return getActionNameFromTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nvar fallbackStrategies = [\n    function (element, userProgrammaticAttribute, privacyEnabledActionName) {\n        return getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName);\n    },\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 */\nvar MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, userProgrammaticAttribute, strategies, privacyEnabledActionName) {\n    var element = targetElement;\n    var 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 (var _i = 0, strategies_1 = strategies; _i < strategies_1.length; _i++) {\n            var strategy = strategies_1[_i];\n            var actionName = strategy(element, userProgrammaticAttribute, privacyEnabledActionName);\n            if (actionName) {\n                var name_1 = actionName.name, nameSource = actionName.nameSource;\n                var trimmedName = name_1 && name_1.trim();\n                if (trimmedName) {\n                    return { name: truncate(normalizeWhitespace(trimmedName)), nameSource: nameSource };\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = getParentElement(element);\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".concat(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        var text_1 = element.innerText;\n        var removeTextFromElements = function (query) {\n            var list = element.querySelectorAll(query);\n            for (var index = 0; index < list.length; index += 1) {\n                var element_1 = list[index];\n                if ('innerText' in element_1) {\n                    var textToReplace = element_1.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text_1 = text_1.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        if (!supportsInnerTextScriptAndStyleRemoval()) {\n            // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n            // be relatively fast and work in most cases.\n            removeTextFromElements('script, style');\n        }\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(\"[\".concat(DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, \"]\"));\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(\"[\".concat(userProgrammaticAttribute, \"]\"));\n        }\n        if (privacyEnabledActionName) {\n            // remove the text of elements with privacy override\n            removeTextFromElements(\"\".concat(getPrivacySelector(NodePrivacyLevel.HIDDEN), \", \").concat(getPrivacySelector(NodePrivacyLevel.MASK)));\n        }\n        return text_1;\n    }\n    return element.textContent;\n}\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n    return !isIE();\n}\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsLabelPropertyResult;\nfunction supportsLabelProperty() {\n    if (supportsLabelPropertyResult === undefined) {\n        supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype;\n    }\n    return supportsLabelPropertyResult;\n}\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsElementClosestResult;\nfunction supportsElementClosest() {\n    if (supportsElementClosestResult === undefined) {\n        supportsElementClosestResult = 'closest' in HTMLElement.prototype;\n    }\n    return supportsElementClosestResult;\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { cssEscape, elementMatches, getClassList, getParentElement } from '../browser/polyfills';\nimport { 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 var 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.\nvar 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.\nvar UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    if (!isConnected(targetElement)) {\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    var targetElementSelector;\n    var currentElement = targetElement;\n    while (currentElement && currentElement.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(currentElement, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(currentElement, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector);\n        currentElement = getParentElement(currentElement);\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 \"#\".concat(cssEscape(element.id));\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    var classList = getClassList(element);\n    for (var i = 0; i < classList.length; i += 1) {\n        var className = classList[i];\n        if (isGeneratedValue(className)) {\n            continue;\n        }\n        return \"\".concat(cssEscape(element.tagName), \".\").concat(cssEscape(className));\n    }\n}\nfunction getTagNameSelector(element) {\n    return cssEscape(element.tagName);\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        var selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (var _i = 0, STABLE_ATTRIBUTES_1 = STABLE_ATTRIBUTES; _i < STABLE_ATTRIBUTES_1.length; _i++) {\n        var attributeName = STABLE_ATTRIBUTES_1[_i];\n        var selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return \"\".concat(cssEscape(element.tagName), \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = getParentElement(element).firstElementChild;\n    var elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return \"\".concat(cssEscape(element.tagName), \":nth-of-type(\").concat(elementIndex, \")\");\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (var _i = 0, selectorGetters_1 = selectorGetters; _i < selectorGetters_1.length; _i++) {\n        var selectorGetter = selectorGetters_1[_i];\n        var 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 * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT CHILD_SELECTOR\" returns a single element), regardless of whether the selector is\n * a direct descendant of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\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    var 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 = function (sibling) { return elementMatches(sibling, currentElementSelector); };\n    }\n    else {\n        var scopedSelector_1 = supportScopeSelector()\n            ? combineSelector(\"\".concat(currentElementSelector, \":scope\"), childSelector)\n            : combineSelector(currentElementSelector, childSelector);\n        isSiblingMatching = function (sibling) { return sibling.querySelector(scopedSelector_1) !== null; };\n    }\n    var parent = getParentElement(currentElement);\n    var 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 ? \"\".concat(parent, \">\").concat(child) : parent;\n}\nvar supportScopeSelectorCache;\nexport function supportScopeSelector() {\n    if (supportScopeSelectorCache === undefined) {\n        try {\n            document.querySelector(':scope');\n            supportScopeSelectorCache = true;\n        }\n        catch (_a) {\n            supportScopeSelectorCache = false;\n        }\n    }\n    return supportScopeSelectorCache;\n}\n/**\n * Polyfill-utility for the `isConnected` property not supported in IE11\n */\nfunction isConnected(element) {\n    if ('isConnected' in\n        // cast is to make sure `element` is not inferred as `never` after the check\n        element) {\n        return element.isConnected;\n    }\n    return element.ownerDocument.documentElement.contains(element);\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nexport var MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport var MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    var bufferedClicks = [];\n    var status = 0 /* ClickChainStatus.WaitingForMoreClicks */;\n    var 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(function (click) { return 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: function (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: function () {\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, _a) {\n    var onPointerDown = _a.onPointerDown, onPointerUp = _a.onPointerUp;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n        scroll: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(configuration, window, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, function (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 */, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, function () {\n            userActivity.scroll = true;\n        }, { capture: true, passive: true }),\n        addEventListener(configuration, window, \"pointerup\" /* DOM_EVENT.POINTER_UP */, function (event) {\n            if (isValidPointerEvent(event) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                var localUserActivity_1 = userActivity;\n                onPointerUp(clickContext, event, function () { return localUserActivity_1; });\n                clickContext = undefined;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"input\" /* DOM_EVENT.INPUT */, function () {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: function () {\n            listeners.forEach(function (listener) { return listener.stop(); });\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    var selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidPointerEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        event.isPrimary !== false);\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { ONE_SECOND } from '@datadog/browser-core';\nimport { elementMatches } from '../../browser/polyfills';\nvar 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    var hasSelectionChanged = clicks.some(function (click) { return click.getUserActivity().selection; });\n    clicks.forEach(function (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(function (click) { return click.getUserActivity().selection || click.getUserActivity().scroll; })) {\n        return false;\n    }\n    for (var 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}\nvar 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 !elementMatches(click.event.target, 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 var CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var interactionSelectorCache = new Map();\nexport function getInteractionSelector(relativeTimestamp) {\n    var 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(function (_, relativeTimestamp) {\n        if (elapsed(relativeTimestamp, relativeNow()) > CLICK_ACTION_MAX_DURATION) {\n            interactionSelectorCache.delete(relativeTimestamp);\n        }\n    });\n}\n//# sourceMappingURL=interactionSelectorCache.js.map","import { includes, timeStampNow, Observable, assign, 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 var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {\n    var history = createValueHistory({ expireDelay: ACTION_CONTEXT_TIME_OUT_DELAY });\n    var stopObservable = new Observable();\n    var currentClickChain;\n    lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents(configuration, {\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable);\n        },\n        onPointerUp: function (_a, startEvent, getUserActivity) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) { return history.findAll(startTime); },\n    };\n    return {\n        stop: function () {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts: actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            var rageClick_1 = click.clone();\n            currentClickChain = createClickChain(click, function (clicks) {\n                finalizeClicks(clicks, rageClick_1);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable) {\n    var nodePrivacyLevel = configuration.enablePrivacyForActionName\n        ? getNodePrivacyLevel(pointerDownEvent.target, configuration.defaultPrivacyLevel)\n        : NodePrivacyLevel.ALLOW;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return undefined;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, nodePrivacyLevel, configuration);\n    var hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, function (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: clickActionBase, hadActivityOnPointerDown: function () { return hadActivityOnPointerDown; } };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, windowOpenObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var _a;\n    var click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    appendClickToClickChain(click);\n    var 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    var stopWaitPageActivityEnd = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, function (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).stop;\n    var viewEndedSubscription = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        click.stop(endClocks.timeStamp);\n    });\n    var stopSubscription = stopObservable.subscribe(function () {\n        click.stop();\n    });\n    click.stopObservable.subscribe(function () {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, nodePrivacyLevel, configuration) {\n    var rect = event.target.getBoundingClientRect();\n    var selector = getSelectorFromElement(event.target, configuration.actionNameAttribute);\n    if (selector) {\n        updateInteractionSelector(event.timeStamp, selector);\n    }\n    var 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: 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    var id = generateUUID();\n    var startClocks = clocksNow();\n    var historyEntry = history.add(id, startClocks.relative);\n    var eventCountsSubscription = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) {\n            return event.action !== undefined &&\n                (Array.isArray(event.action.id) ? includes(event.action.id, id) : event.action.id === id);\n        },\n    });\n    var status = 0 /* ClickStatus.ONGOING */;\n    var activityEndTime;\n    var frustrationTypes = [];\n    var 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: stop,\n        stopObservable: stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity: getUserActivity,\n        addFrustration: function (frustrationType) {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks: startClocks,\n        isStopped: function () { return status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */; },\n        clone: function () { return newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent); },\n        validate: function (domEvents) {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            var _a = eventCountsSubscription.eventCounts, resourceCount = _a.resourceCount, errorCount = _a.errorCount, longTaskCount = _a.longTaskCount;\n            var clickAction = assign({\n                type: \"click\" /* ActionType.CLICK */,\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks: startClocks,\n                id: id,\n                frustrationTypes: frustrationTypes,\n                counts: {\n                    resourceCount: resourceCount,\n                    errorCount: errorCount,\n                    longTaskCount: longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n            }, clickActionBase);\n            lifeCycle.notify(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n        discard: function () {\n            stop();\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    var isRage = computeFrustration(clicks, rageClick).isRage;\n    if (isRage) {\n        clicks.forEach(function (click) { return click.discard(); });\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map(function (click) { return click.event; }));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach(function (click) { return click.validate(); });\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, assign, combine, toServerDuration, generateUUID, ExperimentalFeature, isExperimentalFeatureEnabled, } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, windowOpenObservable, configuration, pageStateHistory) {\n    lifeCycle.subscribe(0 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action, pageStateHistory));\n    });\n    var actionContexts = { findActionId: noop };\n    if (configuration.trackUserInteractions) {\n        actionContexts = trackClickActions(lifeCycle, domMutationObservable, windowOpenObservable, configuration).actionContexts;\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, pageStateHistory)));\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction processAction(action, pageStateHistory) {\n    var 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: isExperimentalFeatureEnabled(ExperimentalFeature.ACTION_NAME_MASKING)\n                        ? action.nameSource\n                        : undefined,\n                },\n            },\n        }\n        : undefined;\n    var customerContext = !isAutoAction(action) ? action.context : undefined;\n    var actionEvent = combine({\n        action: {\n            id: generateUUID(),\n            target: {\n                name: action.name,\n            },\n            type: action.type,\n        },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* RumEventType.ACTION */,\n        view: { in_foreground: pageStateHistory.wasInPageStateAt(\"active\" /* PageState.ACTIVE */, action.startClocks.relative) },\n    }, autoActionProperties);\n    var domainContext = isAutoAction(action) ? { events: action.events } : {};\n    if (!isAutoAction(action) && action.handlingStack) {\n        domainContext.handlingStack = action.handlingStack;\n    }\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: 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    var handleRuntimeError = function (stackTrace, originalError) {\n        var rawError = computeRawError({\n            stackTrace: stackTrace,\n            originalError: 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    var stopInstrumentingOnError = instrumentOnError(handleRuntimeError).stop;\n    var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(handleRuntimeError).stop;\n    return {\n        stop: function () {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        },\n    };\n}\nexport function instrumentOnError(callback) {\n    return instrumentMethod(window, 'onerror', function (_a) {\n        var _b = _a.parameters, messageObj = _b[0], url = _b[1], line = _b[2], column = _b[3], errorObj = _b[4];\n        var 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', function (_a) {\n        var e = _a.parameters[0];\n        var reason = e.reason || 'Empty reason';\n        var stack = computeStackTrace(reason);\n        callback(stack, reason);\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { flattenErrorCauses, isError, tryToGetFingerprint } 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 { find } from '../../tools/utils/polyfills';\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';\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    var consoleObservables = apis.map(function (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.apply(void 0, consoleObservables);\n}\nexport function resetConsoleObservable() {\n    consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n    return new Observable(function (observable) {\n        var originalConsoleApi = globalConsole[api];\n        globalConsole[api] = function () {\n            var params = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                params[_i] = arguments[_i];\n            }\n            originalConsoleApi.apply(console, params);\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                observable.notify(buildConsoleLog(params, api, handlingStack));\n            });\n        };\n        return function () {\n            globalConsole[api] = originalConsoleApi;\n        };\n    });\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    var message = params.map(function (param) { return formatConsoleParameters(param); }).join(' ');\n    var error;\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, 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: message,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            handlingStack: handlingStack,\n        };\n    }\n    return {\n        api: api,\n        message: message,\n        error: error,\n        handlingStack: 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 { assign, includes } from '../../tools/utils/polyfills';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nimport { ErrorSource } from '../error/error.types';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nexport var RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(configuration, apis) {\n    var observables = [];\n    if (includes(apis, RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable(configuration));\n    }\n    var reportTypes = apis.filter(function (api) { return api !== RawReportType.cspViolation; });\n    if (reportTypes.length) {\n        observables.push(createReportObservable(reportTypes));\n    }\n    return mergeObservables.apply(void 0, observables);\n}\nfunction createReportObservable(reportTypes) {\n    return new Observable(function (observable) {\n        if (!window.ReportingObserver) {\n            return;\n        }\n        var handleReports = monitor(function (reports, _) {\n            return reports.forEach(function (report) { return observable.notify(buildRawReportErrorFromReport(report)); });\n        });\n        var observer = new window.ReportingObserver(handleReports, {\n            types: reportTypes,\n            buffered: true,\n        });\n        observer.observe();\n        return function () {\n            observer.disconnect();\n        };\n    });\n}\nfunction createCspViolationReportObservable(configuration) {\n    return new Observable(function (observable) {\n        var stop = addEventListener(configuration, document, \"securitypolicyviolation\" /* DOM_EVENT.SECURITY_POLICY_VIOLATION */, function (event) {\n            observable.notify(buildRawReportErrorFromCspViolation(event));\n        }).stop;\n        return stop;\n    });\n}\nfunction buildRawReportErrorFromReport(report) {\n    var type = report.type, body = report.body;\n    return buildRawReportError({\n        type: body.id,\n        message: \"\".concat(type, \": \").concat(body.message),\n        originalError: report,\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    });\n}\nfunction buildRawReportErrorFromCspViolation(event) {\n    var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n    return buildRawReportError({\n        type: event.effectiveDirective,\n        message: \"\".concat(RawReportType.cspViolation, \": \").concat(message),\n        originalError: event,\n        csp: {\n            disposition: event.disposition,\n        },\n        stack: buildStack(event.effectiveDirective, event.originalPolicy\n            ? \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\")\n            : 'no policy', event.sourceFile, event.lineNumber, event.columnNumber),\n    });\n}\nfunction buildRawReportError(partial) {\n    return assign({\n        startClocks: clocksNow(),\n        source: ErrorSource.REPORT,\n        handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n    }, partial);\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n    return sourceFile\n        ? toStackTraceString({\n            name: name,\n            message: 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 { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, isError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(configuration, errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(13 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts) {\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n            customerContext: customerContext,\n            savedCommonContext: savedCommonContext,\n        }, processError(error, pageStateHistory, featureFlagContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var stackTrace = isError(error) ? computeStackTrace(error) : undefined;\n            var rawError = computeRawError({\n                stackTrace: stackTrace,\n                originalError: error,\n                handlingStack: handlingStack,\n                startClocks: startClocks,\n                nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n                source: ErrorSource.CUSTOM,\n                handling: \"handled\" /* ErrorHandling.HANDLED */,\n            });\n            lifeCycle.notify(13 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction processError(error, pageStateHistory, featureFlagContexts) {\n    var 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            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        view: { in_foreground: pageStateHistory.wasInPageStateAt(\"active\" /* PageState.ACTIVE */, error.startClocks.relative) },\n    };\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\n    }\n    var domainContext = {\n        error: error.originalError,\n        handlingStack: error.handlingStack,\n    };\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: domainContext,\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { initConsoleObservable, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    var subscription = initConsoleObservable([ConsoleApiName.error]).subscribe(function (consoleLog) {\n        return errorObservable.notify(consoleLog.error);\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(configuration, errorObservable) {\n    var subscription = initReportObservable(configuration, [\n        RawReportType.cspViolation,\n        RawReportType.intervention,\n    ]).subscribe(function (rawError) { return errorObservable.notify(rawError); });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.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        var id_1 = window.requestIdleCallback(monitor(callback), opts);\n        return function () { return window.cancelIdleCallback(id_1); };\n    }\n    return requestIdleCallbackShim(callback);\n}\nexport var 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    var start = dateNow();\n    var timeoutId = setTimeout(function () {\n        callback({\n            didTimeout: false,\n            timeRemaining: function () { return Math.max(0, MAX_TASK_TIME - (dateNow() - start)); },\n        });\n    }, 0);\n    return function () { return clearTimeout(timeoutId); };\n}\n//# sourceMappingURL=requestIdleCallback.js.map","import { addDuration } from '@datadog/browser-core';\nimport { WeakSet } from '../../browser/polyfills';\nimport { hasValidResourceEntryDuration, hasValidResourceEntryTimings } from './resourceUtils';\nvar 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    var sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    var candidates = sameNameEntries\n        .filter(function (entry) { return !alreadyMatchedEntries.has(entry); })\n        .filter(function (entry) { return hasValidResourceEntryDuration(entry) && hasValidResourceEntryTimings(entry); })\n        .filter(function (entry) {\n        return isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration }));\n    });\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    var errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestResourceEntry.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    var eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n    return addEventListener(configuration, window, eventName, callback, { once: true });\n}\n//# sourceMappingURL=runOnReadyState.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\nexport var INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    var 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    var traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    var traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    var 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    var traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId: traceId,\n        traceTime: 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 (var i = 0; i < document.childNodes.length; i += 1) {\n        var 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 (var i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            var node = document.body.childNodes[i];\n            var 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        var match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { assign, getRelativeTime, isNumber } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent, } from './performanceObservable';\nexport function getNavigationEntry() {\n    if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n        var navigationEntry = performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION)[0];\n        if (navigationEntry) {\n            return navigationEntry;\n        }\n    }\n    var timings = computeTimingsFromDeprecatedPerformanceTiming();\n    var entry = assign({\n        entryType: RumPerformanceEntryType.NAVIGATION,\n        initiatorType: 'navigation',\n        name: window.location.href,\n        startTime: 0,\n        duration: timings.responseEnd,\n        decodedBodySize: 0,\n        encodedBodySize: 0,\n        transferSize: 0,\n        workerStart: 0,\n        toJSON: function () { return assign({}, entry, { toJSON: undefined }); },\n    }, timings);\n    return entry;\n}\nexport function computeTimingsFromDeprecatedPerformanceTiming() {\n    var result = {};\n    var timing = performance.timing;\n    for (var key in timing) {\n        if (isNumber(timing[key])) {\n            var numberKey = key;\n            var timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=performanceUtils.js.map","import { assign, runOnReadyState } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceObservable';\nimport { getDocumentTraceId } from '../tracing/getDocumentTraceId';\nimport { getNavigationEntry } from '../../browser/performanceUtils';\nimport { FAKE_INITIAL_DOCUMENT } from './resourceUtils';\nexport function retrieveInitialDocumentResourceTiming(configuration, callback) {\n    runOnReadyState(configuration, 'interactive', function () {\n        var entry = assign(getNavigationEntry().toJSON(), {\n            entryType: RumPerformanceEntryType.RESOURCE,\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n            toJSON: function () { return assign({}, entry, { toJSON: undefined }); },\n        });\n        callback(entry);\n    });\n}\n//# sourceMappingURL=retrieveInitialDocumentResourceTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, 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, retrieveInitialDocumentResourceTimingImpl) {\n    if (taskQueue === void 0) { taskQueue = createTaskQueue(); }\n    if (retrieveInitialDocumentResourceTimingImpl === void 0) { retrieveInitialDocumentResourceTimingImpl = retrieveInitialDocumentResourceTiming; }\n    lifeCycle.subscribe(7 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n        handleResource(function () { return processRequest(request, configuration, pageStateHistory); });\n    });\n    var performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.RESOURCE,\n        buffered: true,\n    }).subscribe(function (entries) {\n        var _loop_1 = function (entry) {\n            if (!isResourceEntryRequestType(entry)) {\n                handleResource(function () { return processResourceEntry(entry, configuration); });\n            }\n        };\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            _loop_1(entry);\n        }\n    });\n    retrieveInitialDocumentResourceTimingImpl(configuration, function (timing) {\n        handleResource(function () { return processResourceEntry(timing, configuration); });\n    });\n    function handleResource(computeRawEvent) {\n        taskQueue.push(function () {\n            var rawEvent = computeRawEvent();\n            if (rawEvent) {\n                lifeCycle.notify(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, rawEvent);\n            }\n        });\n    }\n    return {\n        stop: function () {\n            performanceResourceSubscription.unsubscribe();\n        },\n    };\n}\nfunction processRequest(request, configuration, pageStateHistory) {\n    var matchingTiming = matchRequestResourceEntry(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var tracingInfo = computeRequestTracingInfo(request, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    var type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.FETCH */;\n    var correspondingTimingOverrides = matchingTiming ? computeResourceEntryMetrics(matchingTiming) : undefined;\n    var duration = computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: 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        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    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeResourceEntryTracingInfo(entry, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    var type = computeResourceEntryType(entry);\n    var entryMetrics = computeResourceEntryMetrics(entry);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\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        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: entry,\n        },\n    };\n}\nfunction computeResourceEntryMetrics(entry) {\n    var renderBlockingStatus = entry.renderBlockingStatus;\n    return {\n        resource: assign({\n            duration: computeResourceEntryDuration(entry),\n            render_blocking_status: renderBlockingStatus,\n        }, computeResourceEntrySize(entry), computeResourceEntryDetails(entry)),\n    };\n}\nfunction computeRequestTracingInfo(request, configuration) {\n    var 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: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeResourceEntryTracingInfo(entry, configuration) {\n    var 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: getRulePsr(configuration),\n        },\n    };\n}\n/**\n * @returns number between 0 and 1 which represents trace sample rate\n */\nfunction getRulePsr(configuration) {\n    return isNumber(configuration.traceSampleRate) ? configuration.traceSampleRate / 100 : undefined;\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, startClocks.relative, duration)\n        ? toServerDuration(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_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 */\nvar 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 var MAX_EXECUTION_TIME_ON_TIMEOUT = 30;\nexport function createTaskQueue() {\n    var pendingTasks = [];\n    function run(deadline) {\n        var executionTimeRemaining;\n        if (deadline.didTimeout) {\n            var start_1 = performance.now();\n            executionTimeRemaining = function () { return MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start_1); };\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: function (task) {\n            if (pendingTasks.push(task) === 1) {\n                scheduleNextRun();\n            }\n        },\n    };\n}\n//# sourceMappingURL=taskQueue.js.map","import { setTimeout, relativeNow, runOnReadyState, clearTimeout } from '@datadog/browser-core';\nimport { getNavigationEntry } from '../../../browser/performanceUtils';\nexport function trackNavigationTimings(configuration, callback, getNavigationEntryImpl) {\n    if (getNavigationEntryImpl === void 0) { getNavigationEntryImpl = getNavigationEntry; }\n    return waitAfterLoadEvent(configuration, function () {\n        var 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    var timeoutId;\n    var stopOnReadyState = runOnReadyState(configuration, 'complete', function () {\n        // Invoke the callback a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        timeoutId = setTimeout(function () { return callback(); });\n    }).stop;\n    return {\n        stop: function () {\n            stopOnReadyState();\n            clearTimeout(timeoutId);\n        },\n    };\n}\n//# sourceMappingURL=trackNavigationTimings.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function trackFirstHidden(configuration, eventTarget) {\n    if (eventTarget === void 0) { eventTarget = window; }\n    var timeStamp;\n    var stopListeners;\n    if (document.visibilityState === 'hidden') {\n        timeStamp = 0;\n    }\n    else {\n        timeStamp = Infinity;\n        (stopListeners = addEventListeners(configuration, eventTarget, [\"pagehide\" /* DOM_EVENT.PAGE_HIDE */, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */], function (event) {\n            if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ || document.visibilityState === 'hidden') {\n                timeStamp = event.timeStamp;\n                stopListeners();\n            }\n        }, { capture: true }).stop);\n    }\n    return {\n        get timeStamp() {\n            return timeStamp;\n        },\n        stop: function () {\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    var initialViewMetrics = {};\n    var stopNavigationTracking = trackNavigationTimings(configuration, function (navigationTimings) {\n        setLoadEvent(navigationTimings.loadEvent);\n        initialViewMetrics.navigationTimings = navigationTimings;\n        scheduleViewUpdate();\n    }).stop;\n    var firstHidden = trackFirstHidden(configuration);\n    var stopFCPTracking = trackFirstContentfulPaint(configuration, firstHidden, function (firstContentfulPaint) {\n        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaint(configuration, firstHidden, window, function (largestContentfulPaint) {\n        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopFIDTracking = trackFirstInput(configuration, firstHidden, function (firstInput) {\n        initialViewMetrics.firstInput = firstInput;\n        scheduleViewUpdate();\n    }).stop;\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n        firstHidden.stop();\n    }\n    return {\n        stop: stop,\n        initialViewMetrics: initialViewMetrics,\n    };\n}\n//# sourceMappingURL=trackInitialViewMetrics.js.map","import { ONE_MINUTE, find } 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 var FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackFirstContentfulPaint(configuration, firstHidden, callback) {\n    var performanceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.PAINT,\n        buffered: true,\n    }).subscribe(function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < FCP_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    });\n    return {\n        stop: performanceSubscription.unsubscribe,\n    };\n}\n//# sourceMappingURL=trackFirstContentfulPaint.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 var 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    var firstInteractionTimestamp = Infinity;\n    var stopEventListener = addEventListeners(configuration, eventTarget, [\"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var biggestLcpSize = 0;\n    var performanceLcpSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n        buffered: true,\n    }).subscribe(function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return 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        });\n        if (lcpEntry) {\n            var lcpTargetSelector = void 0;\n            if (lcpEntry.element) {\n                lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);\n            }\n            callback({\n                value: lcpEntry.startTime,\n                targetSelector: lcpTargetSelector,\n            });\n            biggestLcpSize = lcpEntry.size;\n        }\n    });\n    return {\n        stop: function () {\n            stopEventListener();\n            performanceLcpSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackLargestContentfulPaint.js.map","import { elapsed, find } 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    var performanceFirstInputSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.FIRST_INPUT,\n        buffered: true,\n    }).subscribe(function (entries) {\n        var firstInputEntry = find(entries, function (entry) { return entry.startTime < firstHidden.timeStamp; });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            var firstInputTargetSelector = void 0;\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: function () {\n            performanceFirstInputSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFirstInput.js.map","import { round, find, 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    var maxClsValue = 0;\n    var maxClsTarget;\n    var maxClsStartTime;\n    // if no layout shift happen the value should be reported as 0\n    callback({\n        value: 0,\n    });\n    var window = slidingSessionWindow();\n    var performanceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LAYOUT_SHIFT,\n        buffered: true,\n    }).subscribe(function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.hadRecentInput || entry.startTime < viewStart) {\n                continue;\n            }\n            var _a = window.update(entry), cumulatedValue = _a.cumulatedValue, isMaxValue = _a.isMaxValue;\n            if (isMaxValue) {\n                var target = getTargetFromSource(entry.sources);\n                maxClsTarget = target ? new WeakRef(target) : undefined;\n                maxClsStartTime = elapsed(viewStart, entry.startTime);\n            }\n            if (cumulatedValue > maxClsValue) {\n                maxClsValue = cumulatedValue;\n                var target = maxClsTarget === null || maxClsTarget === void 0 ? void 0 : maxClsTarget.deref();\n                callback({\n                    value: round(maxClsValue, 4),\n                    targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),\n                    time: maxClsStartTime,\n                });\n            }\n        }\n    });\n    return {\n        stop: function () {\n            performanceSubscription.unsubscribe();\n        },\n    };\n}\nfunction getTargetFromSource(sources) {\n    var _a;\n    if (!sources) {\n        return;\n    }\n    return (_a = find(sources, function (source) { return !!source.node && isElementNode(source.node); })) === null || _a === void 0 ? void 0 : _a.node;\n}\nexport var MAX_WINDOW_DURATION = 5 * ONE_SECOND;\nvar MAX_UPDATE_GAP = ONE_SECOND;\nfunction slidingSessionWindow() {\n    var cumulatedValue = 0;\n    var startTime;\n    var endTime;\n    var maxValue = 0;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= MAX_UPDATE_GAP ||\n                entry.startTime - startTime >= MAX_WINDOW_DURATION;\n            var 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: cumulatedValue,\n                isMaxValue: 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';\nvar observer;\nvar interactionCountEstimate = 0;\nvar minKnownInteractionId = Infinity;\nvar maxKnownInteractionId = 0;\nexport function initInteractionCountPolyfill() {\n    if ('interactionCount' in performance || observer) {\n        return;\n    }\n    observer = new window.PerformanceObserver(monitor(function (entries) {\n        entries.getEntries().forEach(function (e) {\n            var 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 var getInteractionCount = function () {\n    return observer ? interactionCountEstimate : window.performance.interactionCount || 0;\n};\n//# sourceMappingURL=interactionCountPolyfill.js.map","import { Observable, throttle, addEventListener } from '@datadog/browser-core';\nvar 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(function (observable) {\n        var updateDimension = throttle(function () {\n            observable.notify(getViewportDimension());\n        }, 200).throttled;\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    var 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 { 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.\nvar MAX_INTERACTION_ENTRIES = 10;\n// Arbitrary value to cap INP outliers\nexport var 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: function () { return undefined; },\n            setViewEnd: noop,\n            stop: noop,\n        };\n    }\n    var _a = trackViewInteractionCount(viewLoadingType), getViewInteractionCount = _a.getViewInteractionCount, stopViewInteractionCount = _a.stopViewInteractionCount;\n    var viewEnd = Infinity;\n    var longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    var interactionToNextPaint = -1;\n    var interactionToNextPaintTargetSelector;\n    var interactionToNextPaintStartTime;\n    function handleEntries(entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\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        var 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    var firstInputSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.FIRST_INPUT,\n        buffered: true,\n    }).subscribe(handleEntries);\n    var 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: function () {\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: function (viewEndTime) {\n            viewEnd = viewEndTime;\n            stopViewInteractionCount();\n        },\n        stop: function () {\n            eventSubscription.unsubscribe();\n            firstInputSubscription.unsubscribe();\n        },\n    };\n}\nfunction trackLongestInteractions(getViewInteractionCount) {\n    var longestInteractions = [];\n    function sortAndTrimLongestInteractions() {\n        longestInteractions.sort(function (a, b) { return 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: function (entry) {\n            var interactionIndex = longestInteractions.findIndex(function (interaction) { return entry.interactionId === interaction.interactionId; });\n            var 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: function () {\n            var interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));\n            return longestInteractions[interactionIndex];\n        },\n    };\n}\nexport function trackViewInteractionCount(viewLoadingType) {\n    initInteractionCountPolyfill();\n    var previousInteractionCount = viewLoadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */ ? 0 : getInteractionCount();\n    var state = { stopped: false };\n    function computeViewInteractionCount() {\n        return getInteractionCount() - previousInteractionCount;\n    }\n    return {\n        getViewInteractionCount: function () {\n            if (state.stopped) {\n                return state.interactionCount;\n            }\n            return computeViewInteractionCount();\n        },\n        stopViewInteractionCount: function () {\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    var scrollX;\n    var 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    var scrollY;\n    var 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, 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 var THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackScrollMetrics(configuration, viewStart, callback, scrollValues) {\n    if (scrollValues === void 0) { scrollValues = createScrollValuesObservable(configuration); }\n    var maxScrollDepth = 0;\n    var maxScrollHeight = 0;\n    var maxScrollHeightTime = 0;\n    var subscription = scrollValues.subscribe(function (_a) {\n        var scrollDepth = _a.scrollDepth, scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight;\n        var shouldUpdate = false;\n        if (scrollDepth > maxScrollDepth) {\n            maxScrollDepth = scrollDepth;\n            shouldUpdate = true;\n        }\n        if (scrollHeight > maxScrollHeight) {\n            maxScrollHeight = scrollHeight;\n            var 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: maxScrollHeight,\n                maxScrollHeightTime: maxScrollHeightTime,\n            });\n        }\n    });\n    return {\n        stop: function () { return subscription.unsubscribe(); },\n    };\n}\nexport function computeScrollValues() {\n    var scrollTop = getScrollY();\n    var height = getViewportDimension().height;\n    var scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);\n    var scrollDepth = Math.round(height + scrollTop);\n    return {\n        scrollHeight: scrollHeight,\n        scrollDepth: scrollDepth,\n        scrollTop: scrollTop,\n    };\n}\nexport function createScrollValuesObservable(configuration, throttleDuration) {\n    if (throttleDuration === void 0) { throttleDuration = THROTTLE_SCROLL_DURATION; }\n    return new Observable(function (observable) {\n        function notify() {\n            observable.notify(computeScrollValues());\n        }\n        if (window.ResizeObserver) {\n            var throttledNotify_1 = throttle(notify, throttleDuration, {\n                leading: false,\n                trailing: true,\n            });\n            var observerTarget = document.scrollingElement || document.documentElement;\n            var resizeObserver_1 = new ResizeObserver(monitor(throttledNotify_1.throttled));\n            if (observerTarget) {\n                resizeObserver_1.observe(observerTarget);\n            }\n            var eventListener_1 = addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, throttledNotify_1.throttled, {\n                passive: true,\n            });\n            return function () {\n                throttledNotify_1.cancel();\n                resizeObserver_1.disconnect();\n                eventListener_1.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    var commonViewMetrics = {};\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, function (newLoadingTime) {\n        commonViewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopScrollMetricsTracking = trackScrollMetrics(configuration, viewStart, function (newScrollMetrics) {\n        commonViewMetrics.scroll = newScrollMetrics;\n    }).stop;\n    var stopCLSTracking = trackCumulativeLayoutShift(configuration, viewStart.relative, function (cumulativeLayoutShift) {\n        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n        scheduleViewUpdate();\n    }).stop;\n    var _b = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType), stopINPTracking = _b.stop, getInteractionToNextPaint = _b.getInteractionToNextPaint, setViewEnd = _b.setViewEnd;\n    return {\n        stop: function () {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        stopINPTracking: stopINPTracking,\n        setLoadEvent: setLoadEvent,\n        setViewEnd: setViewEnd,\n        getCommonViewMetrics: function () {\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    var isWaitingForLoadEvent = loadType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */;\n    var isWaitingForActivityLoadingTime = true;\n    var loadingTimeCandidates = [];\n    var firstHidden = trackFirstHidden(configuration);\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            var loadingTime = Math.max.apply(Math, loadingTimeCandidates);\n            if (loadingTime < firstHidden.timeStamp) {\n                callback(loadingTime);\n            }\n        }\n    }\n    var stop = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, function (event) {\n        if (isWaitingForActivityLoadingTime) {\n            isWaitingForActivityLoadingTime = false;\n            if (event.hadActivity) {\n                loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));\n            }\n            invokeCallbackIfAllCandidatesAreReceived();\n        }\n    }).stop;\n    return {\n        stop: function () {\n            stop();\n            firstHidden.stop();\n        },\n        setLoadEvent: function (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 var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var 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 var KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, windowOpenObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    var activeViews = new Set();\n    var currentView = startNewView(\"initial_load\" /* ViewLoadingType.INITIAL_LOAD */, clocksOrigin(), initialViewOptions);\n    startViewLifeCycle();\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        var newlyCreatedView = newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, location, loadingType, startClocks, viewOptions);\n        activeViews.add(newlyCreatedView);\n        newlyCreatedView.stopObservable.subscribe(function () {\n            activeViews.delete(newlyCreatedView);\n        });\n        return newlyCreatedView;\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_RENEWED */, function () {\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(8 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n            currentView.end({ sessionIsActive: false });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(10 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n                currentView.end();\n            }\n        });\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(function (_a) {\n            var oldLocation = _a.oldLocation, newLocation = _a.newLocation;\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */);\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n        },\n        startView: function (options, startClocks) {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, startClocks, options);\n        },\n        setViewContext: function (context) {\n            currentView.contextManager.setContext(context);\n        },\n        setViewContextProperty: function (key, value) {\n            currentView.contextManager.setContextProperty(key, value);\n        },\n        setViewName: function (name) {\n            currentView.setViewName(name);\n        },\n        stop: function () {\n            if (locationChangeSubscription) {\n                locationChangeSubscription.unsubscribe();\n            }\n            currentView.end();\n            activeViews.forEach(function (view) { return view.stop(); });\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, windowOpenObservable, configuration, initialLocation, loadingType, startClocks, viewOptions) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var stopObservable = new Observable();\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    var contextManager = createContextManager();\n    var sessionIsActive = true;\n    var name;\n    var service;\n    var version;\n    var context;\n    if (viewOptions) {\n        name = viewOptions.name;\n        service = viewOptions.service || undefined;\n        version = viewOptions.version || undefined;\n        if (viewOptions.context) {\n            context = viewOptions.context;\n            // use ContextManager to update the context so we always sanitize it\n            contextManager.setContext(context);\n        }\n    }\n    var viewCreatedEvent = {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n        context: 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    var _a = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, setViewEnd = _b.setViewEnd, stopCommonViewMetricsTracking = _b.stop, stopINPTracking = _b.stopINPTracking, getCommonViewMetrics = _b.getCommonViewMetrics;\n    var _c = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewMetrics(configuration, setLoadEvent, scheduleViewUpdate)\n        : { stop: noop, initialViewMetrics: {} }, stopInitialViewMetricsTracking = _c.stop, initialViewMetrics = _c.initialViewMetrics;\n    var _d = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), stopEventCountsTracking = _d.stop, eventCounts = _d.eventCounts;\n    // Session keep alive\n    var keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    // Initial view update\n    triggerViewUpdate();\n    contextManager.changeObservable.subscribe(triggerViewUpdate);\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(3 /* LifeCycleEventType.VIEW_UPDATED */, {\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            service: service,\n            version: version,\n            context: contextManager.getContext(),\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            commonViewMetrics: getCommonViewMetrics(),\n            initialViewMetrics: initialViewMetrics,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive: sessionIsActive,\n            eventCounts: eventCounts,\n        });\n    }\n    return {\n        get name() {\n            return name;\n        },\n        service: service,\n        version: version,\n        contextManager: contextManager,\n        stopObservable: stopObservable,\n        end: function (options) {\n            var _this = this;\n            var _a, _b;\n            if (options === void 0) { options = {}; }\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(4 /* LifeCycleEventType.VIEW_ENDED */, { endClocks: endClocks });\n            lifeCycle.notify(5 /* LifeCycleEventType.AFTER_VIEW_ENDED */, { endClocks: endClocks });\n            clearInterval(keepAliveIntervalId);\n            setViewEnd(endClocks.relative);\n            stopCommonViewMetricsTracking();\n            triggerViewUpdate();\n            setTimeout(function () {\n                _this.stop();\n            }, KEEP_TRACKING_AFTER_VIEW_DELAY);\n        },\n        stop: function () {\n            stopInitialViewMetricsTracking();\n            stopEventCountsTracking();\n            stopINPTracking();\n            stopObservable.notify();\n        },\n        addTiming: function (name, time) {\n            if (endClocks) {\n                return;\n            }\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\n        },\n        setViewName: function (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    var sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(\"Invalid timing name: \".concat(name, \", sanitized to: \").concat(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    var 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    var 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    var _a = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) { return event.view.id === viewId; },\n        onChange: onChange,\n    }), stop = _a.stop, eventCounts = _a.eventCounts;\n    return {\n        stop: stop,\n        eventCounts: 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, configuration, location, domMutationObservable, pageOpenObserable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, pageOpenObserable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\n    var pageStates = pageStateHistory.findAll(view.startClocks.relative, view.duration);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            page_states: pageStates,\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: (_a = view.commonViewMetrics.cumulativeLayoutShift) === null || _a === void 0 ? void 0 : _a.value,\n            cumulative_layout_shift_time: toServerDuration((_b = view.commonViewMetrics.cumulativeLayoutShift) === null || _b === void 0 ? void 0 : _b.time),\n            cumulative_layout_shift_target_selector: (_c = view.commonViewMetrics.cumulativeLayoutShift) === null || _c === void 0 ? void 0 : _c.targetSelector,\n            first_byte: toServerDuration((_d = view.initialViewMetrics.navigationTimings) === null || _d === void 0 ? void 0 : _d.firstByte),\n            dom_complete: toServerDuration((_e = view.initialViewMetrics.navigationTimings) === null || _e === void 0 ? void 0 : _e.domComplete),\n            dom_content_loaded: toServerDuration((_f = view.initialViewMetrics.navigationTimings) === null || _f === void 0 ? void 0 : _f.domContentLoaded),\n            dom_interactive: toServerDuration((_g = view.initialViewMetrics.navigationTimings) === null || _g === void 0 ? void 0 : _g.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),\n            first_input_delay: toServerDuration((_h = view.initialViewMetrics.firstInput) === null || _h === void 0 ? void 0 : _h.delay),\n            first_input_time: toServerDuration((_j = view.initialViewMetrics.firstInput) === null || _j === void 0 ? void 0 : _j.time),\n            first_input_target_selector: (_k = view.initialViewMetrics.firstInput) === null || _k === void 0 ? void 0 : _k.targetSelector,\n            interaction_to_next_paint: toServerDuration((_l = view.commonViewMetrics.interactionToNextPaint) === null || _l === void 0 ? void 0 : _l.value),\n            interaction_to_next_paint_time: toServerDuration((_m = view.commonViewMetrics.interactionToNextPaint) === null || _m === void 0 ? void 0 : _m.time),\n            interaction_to_next_paint_target_selector: (_o = view.commonViewMetrics.interactionToNextPaint) === null || _o === void 0 ? void 0 : _o.targetSelector,\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration((_p = view.initialViewMetrics.largestContentfulPaint) === null || _p === void 0 ? void 0 : _p.value),\n            largest_contentful_paint_target_selector: (_q = view.initialViewMetrics.largestContentfulPaint) === null || _q === void 0 ? void 0 : _q.targetSelector,\n            load_event: toServerDuration((_r = view.initialViewMetrics.navigationTimings) === null || _r === void 0 ? void 0 : _r.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.commonViewMetrics.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n        },\n        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\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        domainContext: {\n            location: view.location,\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 var VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeSessionState, trackingConsentState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    // TODO - Improve configuration type and remove assertion\n    var sessionStore = startSessionStore(configuration.sessionStoreStrategyType, productKey, computeSessionState);\n    stopCallbacks.push(function () { return sessionStore.stop(); });\n    var sessionContextHistory = createValueHistory({\n        expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,\n    });\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n        renewObservable.notify();\n    });\n    sessionStore.expireObservable.subscribe(function () {\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(function () {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n        else {\n            sessionStore.expire();\n        }\n    });\n    trackActivity(configuration, function () {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n    });\n    trackVisibility(configuration, function () { return sessionStore.expandSession(); });\n    trackResume(configuration, function () { return 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: function (startTime, options) { return sessionContextHistory.find(startTime, options); },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,\n        expire: sessionStore.expire,\n        updateSessionState: sessionStore.updateSessionState,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(configuration, expandOrRenewSession) {\n    var 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 }).stop;\n    stopCallbacks.push(stop);\n}\nfunction trackVisibility(configuration, expandSession) {\n    var expandSessionWhenVisible = function () {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    };\n    var stop = addEventListener(configuration, document, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, expandSessionWhenVisible).stop;\n    stopCallbacks.push(stop);\n    var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n    stopCallbacks.push(function () {\n        clearInterval(visibilityCheckInterval);\n    });\n}\nfunction trackResume(configuration, cb) {\n    var stop = addEventListener(configuration, window, \"resume\" /* DOM_EVENT.RESUME */, cb, { capture: true }).stop;\n    stopCallbacks.push(stop);\n}\n//# sourceMappingURL=sessionManager.js.map","import { Observable, bridgeSupports, noop, performDraw, startSessionManager, } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle, trackingConsentState) {\n    var sessionManager = startSessionManager(configuration, RUM_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); }, trackingConsentState);\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(8 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(9 /* LifeCycleEventType.SESSION_RENEWED */);\n    });\n    sessionManager.sessionStateUpdateObservable.subscribe(function (_a) {\n        var previousState = _a.previousState, newState = _a.newState;\n        if (!previousState.forcedReplay && newState.forcedReplay) {\n            var sessionEntity = sessionManager.findSession();\n            if (sessionEntity) {\n                sessionEntity.isReplayForced = true;\n            }\n        }\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var 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: function () { return sessionManager.updateSessionState({ forcedReplay: '1' }); },\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    var 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: function () { return session; },\n        expire: noop,\n        expireObservable: new Observable(),\n        setForcedReplay: noop,\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var 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: 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(_a) {\n    var encoder = _a.encoder, request = _a.request, flushController = _a.flushController, messageBytesLimit = _a.messageBytesLimit;\n    var upsertBuffer = {};\n    var flushSubscription = flushController.flushObservable.subscribe(function (event) { return 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\".concat(serializedMessage), function (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        var removedMessage = upsertBuffer[key];\n        delete upsertBuffer[key];\n        var messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage);\n        flushController.notifyAfterRemoveMessage(messageBytesCount);\n    }\n    function addOrUpdate(message, key) {\n        var serializedMessage = jsonStringify(message);\n        var estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage);\n        if (estimatedMessageBytesCount >= messageBytesLimit) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(messageBytesLimit, \"KB. \").concat(MORE_DETAILS, \" \").concat(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        var upsertMessages = objectValues(upsertBuffer).join('\\n');\n        upsertBuffer = {};\n        var isPageExit = isPageExitReason(event.reason);\n        var 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            var 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            var 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\".concat(upsertMessages));\n            }\n            encoder.finish(function (encoderResult) {\n                send(formatPayloadFromEncoder(encoderResult));\n            });\n        }\n    }\n    return {\n        flushController: flushController,\n        add: addOrUpdate,\n        upsert: addOrUpdate,\n        stop: flushSubscription.unsubscribe,\n    };\n}\nfunction formatPayloadFromEncoder(encoderResult) {\n    var 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: data,\n        bytesCount: encoderResult.outputBytesCount,\n        encoding: encoderResult.encoding,\n    };\n}\n//# sourceMappingURL=batch.js.map","import { setTimeout } from '../tools/timer';\nimport { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { isServerError } from '../tools/utils/responseUtils';\nimport { ErrorSource } from '../domain/error/error.types';\nexport var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport var MAX_ONGOING_REQUESTS = 32;\nexport var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;\nexport var MAX_BACKOFF_TIME = ONE_MINUTE;\nexport var 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: function () { return retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, trackType, reportError); },\n            onFailure: function () {\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(function () {\n        var payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, {\n            onSuccess: function () {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, trackType, reportError);\n            },\n            onFailure: function () {\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, _a) {\n    var onSuccess = _a.onSuccess, onFailure = _a.onFailure;\n    state.bandwidthMonitor.add(payload);\n    sendStrategy(payload, function (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 \".concat(trackType, \" events size queued for upload: \").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, \"MiB\"),\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n        });\n        state.queueFullReported = true;\n    }\n    var 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    var queue = [];\n    return {\n        bytesCount: 0,\n        enqueue: function (payload) {\n            if (this.isFull()) {\n                return;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\n        },\n        first: function () {\n            return queue[0];\n        },\n        dequeue: function () {\n            var payload = queue.shift();\n            if (payload) {\n                this.bytesCount -= payload.bytesCount;\n            }\n            return payload;\n        },\n        size: function () {\n            return queue.length;\n        },\n        isFull: function () {\n            return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n        },\n    };\n}\nfunction newBandwidthMonitor() {\n    return {\n        ongoingRequestCount: 0,\n        ongoingByteCount: 0,\n        canHandle: function (payload) {\n            return (this.ongoingRequestCount === 0 ||\n                (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n                    this.ongoingRequestCount < MAX_ONGOING_REQUESTS));\n        },\n        add: function (payload) {\n            this.ongoingRequestCount += 1;\n            this.ongoingByteCount += payload.bytesCount;\n        },\n        remove: function (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    var retryState = newRetryState();\n    var sendStrategyForRetry = function (payload, onResponse) {\n        return fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse);\n    };\n    return {\n        send: function (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: function (payload) {\n            sendBeaconStrategy(endpointBuilder, bytesLimit, payload);\n        },\n    };\n}\nfunction sendBeaconStrategy(endpointBuilder, bytesLimit, payload) {\n    var canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            var beaconUrl = endpointBuilder.build('beacon', payload);\n            var isQueued = navigator.sendBeacon(beaconUrl, payload.data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    var xhrUrl = endpointBuilder.build('xhr', payload);\n    sendXHR(xhrUrl, payload.data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse) {\n    var canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        var fetchUrl = endpointBuilder.build('fetch', payload);\n        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(monitor(function (response) { return onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type }); }), monitor(function () {\n            var xhrUrl = endpointBuilder.build('xhr', payload);\n            // failed to queue the request\n            sendXHR(xhrUrl, payload.data, onResponse);\n        }));\n    }\n    else {\n        var 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    var 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', function () {\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","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(_a) {\n    var messagesLimit = _a.messagesLimit, bytesLimit = _a.bytesLimit, durationLimit = _a.durationLimit, pageExitObservable = _a.pageExitObservable, sessionExpireObservable = _a.sessionExpireObservable;\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) { return flush(event.reason); });\n    var sessionExpireSubscription = sessionExpireObservable.subscribe(function () { return flush('session_expire'); });\n    var flushObservable = new Observable(function () { return function () {\n        pageExitSubscription.unsubscribe();\n        sessionExpireSubscription.unsubscribe();\n    }; });\n    var currentBytesCount = 0;\n    var currentMessagesCount = 0;\n    function flush(flushReason) {\n        if (currentMessagesCount === 0) {\n            return;\n        }\n        var messagesCount = currentMessagesCount;\n        var bytesCount = currentBytesCount;\n        currentMessagesCount = 0;\n        currentBytesCount = 0;\n        cancelDurationLimitTimeout();\n        flushObservable.notify({\n            reason: flushReason,\n            messagesCount: messagesCount,\n            bytesCount: bytesCount,\n        });\n    }\n    var durationLimitTimeoutId;\n    function scheduleDurationLimitTimeout() {\n        if (durationLimitTimeoutId === undefined) {\n            durationLimitTimeoutId = setTimeout(function () {\n                flush('duration_limit');\n            }, durationLimit);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable: 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: function (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: function (messageBytesCountDiff) {\n            if (messageBytesCountDiff === void 0) { 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: function (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    var replica = configuration.replica;\n    var batch = startBatchWithReplica(configuration, {\n        endpoint: configuration.rumEndpointBuilder,\n        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),\n    }, replica && {\n        endpoint: replica.rumEndpointBuilder,\n        transformMessage: function (message) { return combine(message, { application: { id: replica.applicationId } }); },\n        encoder: createEncoder(3 /* DeflateEncoderStreamId.RUM_REPLICA */),\n    }, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (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(function (event) { return 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) {\n    if (batchFactoryImp === void 0) { batchFactoryImp = createBatch; }\n    var primaryBatch = createBatchFromConfig(configuration, primary);\n    var replicaBatch = replica && createBatchFromConfig(configuration, replica);\n    function createBatchFromConfig(configuration, _a) {\n        var endpoint = _a.endpoint, encoder = _a.encoder;\n        return batchFactoryImp({\n            encoder: 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: pageExitObservable,\n                sessionExpireObservable: sessionExpireObservable,\n            }),\n            messageBytesLimit: configuration.messageBytesLimit,\n        });\n    }\n    return {\n        flushObservable: primaryBatch.flushController.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message);\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key);\n            }\n        },\n        stop: function () {\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 var URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, locationChangeObservable, location) {\n    var urlContextHistory = createValueHistory({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY });\n    var previousViewUrl;\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var 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(5 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    var locationChangeSubscription = locationChangeObservable.subscribe(function (_a) {\n        var newLocation = _a.newLocation;\n        var current = urlContextHistory.find();\n        if (current) {\n            var 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(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            url: url,\n            referrer: referrer,\n        };\n    }\n    return {\n        findUrl: function (startTime) { return urlContextHistory.find(startTime); },\n        stop: function () {\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    var currentLocation = shallowClone(location);\n    return new Observable(function (observable) {\n        var stopHistoryTracking = trackHistory(configuration, onLocationChange).stop;\n        var stopHashTracking = trackHash(configuration, onLocationChange).stop;\n        function onLocationChange() {\n            if (currentLocation.href === location.href) {\n                return;\n            }\n            var newLocation = shallowClone(location);\n            observable.notify({\n                newLocation: newLocation,\n                oldLocation: currentLocation,\n            });\n            currentLocation = newLocation;\n        }\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n}\nfunction trackHistory(configuration, onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethod(getHistoryInstrumentationTarget('pushState'), 'pushState', function (_a) {\n        var onPostCall = _a.onPostCall;\n        onPostCall(onHistoryChange);\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethod(getHistoryInstrumentationTarget('replaceState'), 'replaceState', function (_a) {\n        var onPostCall = _a.onPostCall;\n        onPostCall(onHistoryChange);\n    }).stop;\n    var removeListener = addEventListener(configuration, window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\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 } from '@datadog/browser-core';\nexport var FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport var 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, customerDataTracker) {\n    var featureFlagContexts = createValueHistory({\n        expireDelay: FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY,\n    });\n    lifeCycle.subscribe(1 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        customerDataTracker.resetCustomerData();\n    });\n    lifeCycle.subscribe(5 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n                customerDataTracker.updateCustomerData(currentContext);\n            }\n        },\n        stop: function () { return customerDataTracker.stop(); },\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { includes, performDraw, ONE_SECOND, addTelemetryDebug, setInterval, } from '@datadog/browser-core';\nexport var MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nvar currentPeriodMeasures;\nvar currentBatchMeasures;\nvar batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batchFlushObservable) {\n    var 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(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (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, includes([\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */], event.type)\n            ? customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */).getBytesCount()\n            : 0);\n    });\n    batchFlushObservable.subscribe(function (_a) {\n        var bytesCount = _a.bytesCount, messagesCount = _a.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 var MAX_PAGE_STATE_ENTRIES = 4000;\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport var MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500;\nexport var PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startPageStateHistory(configuration, maxPageStateEntriesSelectable) {\n    if (maxPageStateEntriesSelectable === void 0) { maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE; }\n    var pageStateEntryHistory = createValueHistory({\n        expireDelay: PAGE_STATE_CONTEXT_TIME_OUT_DELAY,\n        maxEntries: MAX_PAGE_STATE_ENTRIES,\n    });\n    var currentPageState;\n    addPageState(getPageState(), relativeNow());\n    var 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    ], function (event) {\n        addPageState(computePageState(event), event.timeStamp);\n    }, { capture: true }).stop;\n    function addPageState(nextPageState, startTime) {\n        if (startTime === void 0) { startTime = relativeNow(); }\n        if (nextPageState === currentPageState) {\n            return;\n        }\n        currentPageState = nextPageState;\n        pageStateEntryHistory.closeActive(startTime);\n        pageStateEntryHistory.add({ state: currentPageState, startTime: startTime }, startTime);\n    }\n    var pageStateHistory = {\n        findAll: function (eventStartTime, duration) {\n            var pageStateEntries = pageStateEntryHistory.findAll(eventStartTime, duration);\n            if (pageStateEntries.length === 0) {\n                return;\n            }\n            var pageStateServerEntries = [];\n            // limit the number of entries to return\n            var limit = Math.max(0, pageStateEntries.length - maxPageStateEntriesSelectable);\n            // loop page state entries backward to return the selected ones in desc order\n            for (var index = pageStateEntries.length - 1; index >= limit; index--) {\n                var pageState = pageStateEntries[index];\n                // compute the start time relative to the event start time (ex: to be relative to the view start time)\n                var relativeStartTime = elapsed(eventStartTime, pageState.startTime);\n                pageStateServerEntries.push({\n                    state: pageState.state,\n                    start: toServerDuration(relativeStartTime),\n                });\n            }\n            return pageStateServerEntries;\n        },\n        wasInPageStateAt: function (state, startTime) {\n            return pageStateHistory.wasInPageStateDuringPeriod(state, startTime, 0);\n        },\n        wasInPageStateDuringPeriod: function (state, startTime, duration) {\n            return pageStateEntryHistory.findAll(startTime, duration).some(function (pageState) { return pageState.state === state; });\n        },\n        addPageState: addPageState,\n        stop: function () {\n            stopEventListeners();\n            pageStateEntryHistory.stop();\n        },\n    };\n    return pageStateHistory;\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, find, } from '@datadog/browser-core';\nexport function createCookieObservable(configuration, cookieName) {\n    var detectCookieChangeStrategy = window.cookieStore\n        ? listenToCookieStoreChange(configuration)\n        : watchCookieFallback;\n    return new Observable(function (observable) {\n        return detectCookieChangeStrategy(cookieName, function (event) { return observable.notify(event); });\n    });\n}\nfunction listenToCookieStoreChange(configuration) {\n    return function (cookieName, callback) {\n        var listener = addEventListener(configuration, window.cookieStore, \"change\" /* DOM_EVENT.CHANGE */, function (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            var changeEvent = find(event.changed, function (event) { return event.name === cookieName; }) ||\n                find(event.deleted, function (event) { return event.name === cookieName; });\n            if (changeEvent) {\n                callback(changeEvent.value);\n            }\n        });\n        return listener.stop;\n    };\n}\nexport var WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND;\nfunction watchCookieFallback(cookieName, callback) {\n    var previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n    var watchCookieIntervalId = setInterval(function () {\n        var cookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n        if (cookieValue !== previousCookieValue) {\n            callback(cookieValue);\n        }\n    }, WATCH_COOKIE_INTERVAL_DELAY);\n    return function () {\n        clearInterval(watchCookieIntervalId);\n    };\n}\n//# sourceMappingURL=cookieObservable.js.map","import { getInitCookie } from '@datadog/browser-core';\nimport { createCookieObservable } from '../../browser/cookieObservable';\nexport var CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id';\nexport function startCiVisibilityContext(configuration, cookieObservable) {\n    var _a;\n    if (cookieObservable === void 0) { cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME); }\n    var testExecutionId = getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || ((_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId'));\n    var cookieObservableSubscription = cookieObservable.subscribe(function (value) {\n        testExecutionId = value;\n    });\n    return {\n        get: function () {\n            if (typeof testExecutionId === 'string') {\n                return {\n                    test_execution_id: testExecutionId,\n                };\n            }\n        },\n        stop: function () { return cookieObservableSubscription.unsubscribe(); },\n    };\n}\n//# sourceMappingURL=ciVisibilityContext.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, _a) {\n    var session = _a.session, viewContext = _a.viewContext, errorType = _a.errorType;\n    var sessionId = session ? session.id : 'no-session-id';\n    var parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(\"error-type=\".concat(errorType));\n    }\n    if (viewContext) {\n        parameters.push(\"seed=\".concat(viewContext.id));\n        parameters.push(\"from=\".concat(viewContext.startClocks.timeStamp));\n    }\n    var origin = getDatadogSiteUrl(configuration);\n    var path = \"/rum/replay/sessions/\".concat(sessionId);\n    return \"\".concat(origin).concat(path, \"?\").concat(parameters.join('&'));\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    var site = rumConfiguration.site;\n    var subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return \"https://\".concat(subdomain ? \"\".concat(subdomain, \".\") : '').concat(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","export var MAX_STATS_HISTORY = 10;\nvar 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    var 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    if (statsPerView.keys) {\n        var toDelete = statsPerView.keys().next().value;\n        if (toDelete) {\n            statsPerView.delete(toDelete);\n        }\n    }\n    else {\n        // IE11 doesn't support map.keys\n        var isFirst_1 = true;\n        statsPerView.forEach(function (_value, key) {\n            if (isFirst_1) {\n                statsPerView.delete(key);\n                isFirst_1 = false;\n            }\n        });\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';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var 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    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var 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 var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(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}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    var 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='\".concat(width, \"' height='\").concat(height, \"' style='background-color:silver'%3E%3C/svg%3E\");\n}\n//# sourceMappingURL=serializationUtils.js.map","export var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport var NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport var 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 var 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 var 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(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: 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 { startsWith } from '@datadog/browser-core';\nimport { 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    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var 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            var image = element;\n            if (image.naturalWidth > 0) {\n                return censoredImageForSize(image.naturalWidth, image.naturalHeight);\n            }\n            var _a = element.getBoundingClientRect(), width = _a.width, height = _a.height;\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 && startsWith(attributeName, '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    var _a;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var 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        var 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        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        var 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    var 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        var 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    var scrollTop;\n    var scrollLeft;\n    var 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: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\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    var 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    var 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        var 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 { assign } from '@datadog/browser-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    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nvar _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    forEachChildNodes(node, function (childNode) {\n        var 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    var 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: 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    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var 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    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: NodeType.Element,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    var 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        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: 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    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: 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: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: 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\nvar 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 var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visualViewport = window.visualViewport;\n    var 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 var getVisualViewport = function (visualViewport) { return ({\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 { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\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';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function trackMove(configuration, moveCb) {\n    var _a = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var 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    }), updatePosition = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(configuration, document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\nexport function tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\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: x, y: y };\n}\n//# sourceMappingURL=trackMove.js.map","var _a;\nimport { assign, 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';\nvar eventTypeToMouseInteraction = (_a = {},\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    _a[\"pointerup\" /* DOM_EVENT.POINTER_UP */] = MouseInteractionType.MouseUp,\n    _a[\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */] = MouseInteractionType.MouseDown,\n    _a[\"click\" /* DOM_EVENT.CLICK */] = MouseInteractionType.Click,\n    _a[\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */] = MouseInteractionType.ContextMenu,\n    _a[\"dblclick\" /* DOM_EVENT.DBL_CLICK */] = MouseInteractionType.DblClick,\n    _a[\"focus\" /* DOM_EVENT.FOCUS */] = MouseInteractionType.Focus,\n    _a[\"blur\" /* DOM_EVENT.BLUR */] = MouseInteractionType.Blur,\n    _a[\"touchstart\" /* DOM_EVENT.TOUCH_START */] = MouseInteractionType.TouchStart,\n    _a[\"touchend\" /* DOM_EVENT.TOUCH_END */] = MouseInteractionType.TouchEnd,\n    _a);\nexport function trackMouseInteraction(configuration, mouseInteractionCb, recordIds) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: recordIds.getIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\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';\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nexport function trackScroll(configuration, scrollCb, elementsScrollPositions, target) {\n    if (target === void 0) { target = document; }\n    var _a = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var 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: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD), updatePosition = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListener(configuration, target, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\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';\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function trackViewportResize(configuration, viewportResizeCb) {\n    var viewportResizeSubscription = initViewportObservable(configuration).subscribe(function (data) {\n        viewportResizeCb(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: function () {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function trackVisualViewportResize(configuration, visualViewportResizeCb) {\n    var visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    var _a = throttle(function () {\n        visualViewportResizeCb({\n            data: getVisualViewport(visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp: timeStampNow(),\n        });\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(configuration, visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\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 */], function (event) {\n        var 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    var instrumentationStoppers = [\n        instrumentMethod(CSSStyleSheet.prototype, 'insertRule', function (_a) {\n            var styleSheet = _a.target, _b = _a.parameters, rule = _b[0], index = _b[1];\n            checkStyleSheetAndCallback(styleSheet, function (id) {\n                return styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                    id: id,\n                    adds: [{ rule: rule, index: index }],\n                }));\n            });\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', function (_a) {\n            var styleSheet = _a.target, index = _a.parameters[0];\n            checkStyleSheetAndCallback(styleSheet, function (id) {\n                return styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                    id: id,\n                    removes: [{ index: index }],\n                }));\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', function (_a) {\n            var styleSheet = _a.target, _b = _a.parameters, rule = _b[0], index = _b[1];\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, function (id) {\n                var path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index || 0);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id: id,\n                        adds: [{ rule: rule, index: path }],\n                    }));\n                }\n            });\n        }), instrumentMethod(cls.prototype, 'deleteRule', function (_a) {\n            var styleSheet = _a.target, index = _a.parameters[0];\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, function (id) {\n                var path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id: id,\n                        removes: [{ index: path }],\n                    }));\n                }\n            });\n        }));\n    }\n    return {\n        stop: function () {\n            instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        },\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var 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 */], function () {\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    var frustrationSubscription = lifeCycle.subscribe(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (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(function (e) { return recordIds.getIdForEvent(e); }),\n                },\n            });\n        }\n    });\n    return {\n        stop: function () {\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    var viewEndSubscription = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function () {\n        viewEndCb({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    });\n    return {\n        stop: function () {\n            viewEndSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackViewEnd.js.map","import { instrumentSetter, assign, addEventListeners, forEach, noop } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel, shouldMaskNode, cssEscape } 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) {\n    if (target === void 0) { target = document; }\n    var defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    var lastInputStateMap = new WeakMap();\n    var isShadowRoot = target !== document;\n    var 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 */], function (event) {\n        var 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    }).stop;\n    var stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        var instrumentationStoppers_1 = [\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 = function () {\n            instrumentationStoppers_1.forEach(function (stopper) { return stopper.stop(); });\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return {\n        stop: function () {\n            stopPropertySetterInstrumentation();\n            stopEventListeners();\n        },\n    };\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var 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        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(cssEscape(name), \"\\\"]\")), function (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        var 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, assign({\n                id: getSerializedNodeId(target),\n            }, inputState)));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.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    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController);\n    });\n    var 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: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController) {\n    var nodePrivacyLevelCache = new Map();\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (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    var filteredMutations = mutations.filter(function (mutation) {\n        return mutation.target.isConnected &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !==\n                NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController, nodePrivacyLevelCache), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), configuration, nodePrivacyLevelCache);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration, nodePrivacyLevelCache);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback(assembleIncrementalSnapshot(IncrementalSource.Mutation, { adds: adds, removes: removes, texts: texts, attributes: 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    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\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    var 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    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var 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    var removedNodeMutations = [];\n    removedNodes.forEach(function (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: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var 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    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (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 (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var 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    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var 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    var emittedMutations = new Map();\n    for (var _i = 0, filteredMutations_2 = filteredMutations; _i < filteredMutations_2.length; _i++) {\n        var mutation = filteredMutations_2[_i];\n        var uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        var privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var 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        var 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(function (a, b) {\n        var 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, function (childNode) { return traverseRemovedShadowDom(childNode, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=trackMutation.js.map","import { noop, throttle, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar 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 var MUTATION_PROCESS_MIN_DELAY = 16;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    var _a = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n        leading: false,\n    }), throttledFlush = _a.throttled, cancelThrottle = _a.cancel;\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.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    var emit = options.emit, configuration = options.configuration, lifeCycle = options.lifeCycle;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var emitAndComputeStats = function (record) {\n        emit(record);\n        sendToExtension('record', { record: record });\n        var view = options.viewHistory.findView();\n        replayStats.addRecord(view.id);\n    };\n    var elementsScrollPositions = createElementsScrollPositions();\n    var shadowRootsController = initShadowRootsController(configuration, emitAndComputeStats, elementsScrollPositions);\n    var stopFullSnapshots = startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, function (records) { return records.forEach(function (record) { return emitAndComputeStats(record); }); }).stop;\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    var recordIds = initRecordIds();\n    var mutationTracker = trackMutation(emitAndComputeStats, configuration, shadowRootsController, document);\n    var 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, function (viewEndRecord) {\n            flushMutations();\n            emitAndComputeStats(viewEndRecord);\n        }),\n    ];\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            trackers.forEach(function (tracker) { return tracker.stop(); });\n            stopFullSnapshots();\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (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: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport var initShadowRootsController = function (configuration, callback, elementsScrollPositions) {\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            var 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            var 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            var scrollTracker = trackScroll(configuration, callback, elementsScrollPositions, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: function () { return mutationTracker.flush(); },\n                stop: function () {\n                    mutationTracker.stop();\n                    inputTracker.stop();\n                    scrollTracker.stop();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var 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: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.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    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        var records = [\n            {\n                data: {\n                    height: height,\n                    href: window.location.href,\n                    width: width,\n                },\n                type: RecordType.Meta,\n                timestamp: timestamp,\n            },\n            {\n                data: {\n                    has_focus: document.hasFocus(),\n                },\n                type: RecordType.Focus,\n                timestamp: 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: timestamp,\n            },\n        ];\n        if (window.visualViewport) {\n            records.push({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n        return records;\n    };\n    fullSnapshotCallback(takeFullSnapshot());\n    var unsubscribe = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        flushMutations();\n        fullSnapshotCallback(takeFullSnapshot(view.startClocks.timeStamp, {\n            shadowRootsController: shadowRootsController,\n            status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n        }));\n    }).unsubscribe;\n    return {\n        stop: unsubscribe,\n    };\n}\n//# sourceMappingURL=startFullSnapshots.js.map","export function initRecordIds() {\n    var recordIds = new WeakMap();\n    var nextId = 1;\n    return {\n        getIdForEvent: function (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 { assign } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nexport function createSegment(_a) {\n    var context = _a.context, creationReason = _a.creationReason, encoder = _a.encoder;\n    var encodedBytesCount = 0;\n    var viewId = context.view.id;\n    var metadata = assign({\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    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        var prefix = encoder.isEmpty ? '{\"records\":[' : ',';\n        encoder.write(prefix + JSON.stringify(record), function (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(\"],\".concat(JSON.stringify(metadata).slice(1), \"\\n\"));\n        encoder.finish(function (encoderResult) {\n            replayStats.addWroteData(metadata.view.id, encoderResult.rawBytesCount);\n            callback(metadata, encoderResult);\n        });\n    }\n    return { addRecord: addRecord, flush: 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 var 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 var 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, function () { return computeSegmentContext(configuration.applicationId, sessionManager, viewHistory); }, httpRequest, encoder);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, encoder) {\n    var state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribePageExited = lifeCycle.subscribe(10 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n        flushSegment(pageExitEvent.reason);\n    }).unsubscribe;\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush(function (metadata, encoderResult) {\n                var 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: function (record) {\n            if (state.status === 2 /* SegmentCollectionStatus.Stopped */) {\n                return;\n            }\n            if (state.status === 0 /* SegmentCollectionStatus.WaitingForInitialRecord */) {\n                var context = getSegmentContext();\n                if (!context) {\n                    return;\n                }\n                state = {\n                    status: 1 /* SegmentCollectionStatus.SegmentPending */,\n                    segment: createSegment({ encoder: encoder, context: context, creationReason: state.nextSegmentCreationReason }),\n                    expirationTimeoutId: setTimeout(function () {\n                        flushSegment('segment_duration_limit');\n                    }, SEGMENT_DURATION_LIMIT),\n                };\n            }\n            state.segment.addRecord(record, function (encodedBytesCount) {\n                if (encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        stop: function () {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewHistory) {\n    var session = sessionManager.findTrackedSession();\n    var 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) {\n    if (newSegmentBytesLimit === void 0) { newSegmentBytesLimit = 60000; }\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { assign } from '@datadog/browser-core';\nexport function buildReplayPayload(data, metadata, rawSegmentBytesCount) {\n    var formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), \"\".concat(metadata.session.id, \"-\").concat(metadata.start));\n    var metadataAndSegmentSizes = assign({\n        raw_segment_size: rawSegmentBytesCount,\n        compressed_segment_size: data.byteLength,\n    }, metadata);\n    var 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 { addEventListener, addTelemetryDebug, assign, concatBuffers } from '@datadog/browser-core';\nexport function createDeflateEncoder(configuration, worker, streamId) {\n    var rawBytesCount = 0;\n    var compressedData = [];\n    var compressedDataTrailer;\n    var nextWriteActionId = 0;\n    var pendingWriteActions = [];\n    var removeMessageListener = addEventListener(configuration, worker, 'message', function (_a) {\n        var workerResponse = _a.data;\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        var 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    }).stop;\n    function consumeResult() {\n        var output = compressedData.length === 0 ? new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer));\n        var result = {\n            rawBytesCount: rawBytesCount,\n            output: 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: streamId,\n            });\n            nextWriteActionId = 0;\n        }\n    }\n    return {\n        isAsync: true,\n        get isEmpty() {\n            return nextWriteActionId === 0;\n        },\n        write: function (data, callback) {\n            worker.postMessage({\n                action: 'write',\n                id: nextWriteActionId,\n                data: data,\n                streamId: streamId,\n            });\n            pendingWriteActions.push({\n                id: nextWriteActionId,\n                writeCallback: callback,\n                data: data,\n            });\n            nextWriteActionId += 1;\n        },\n        finish: function (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(function (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 = function () { return callback(consumeResult()); };\n            }\n        },\n        finishSync: function () {\n            sendResetIfNeeded();\n            var pendingData = pendingWriteActions\n                .map(function (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 assign(consumeResult(), {\n                pendingData: pendingData,\n            });\n        },\n        estimateEncodedBytesCount: function (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: function () {\n            removeMessageListener();\n        },\n    };\n}\n//# sourceMappingURL=deflateEncoder.js.map","import { addTelemetryError, display, includes, addEventListener, setTimeout, ONE_SECOND, DOCS_ORIGIN, } from '@datadog/browser-core';\nexport var INITIALIZATION_TIME_OUT_DELAY = 30 * ONE_SECOND;\nfunction createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"!function(){\\\"use strict\\\";function t(t){for(var e=t.reduce((function(t,e){return t+e.length}),0),a=new Uint8Array(e),n=0,r=0,i=t;r<i.length;r++){var s=i[r];a.set(s,n),n+=s.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){var 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){void 0===e&&(e=self);try{var a=new Map;e.addEventListener(\\\"message\\\",(function(n){try{var r=function(e,a){switch(a.action){case\\\"init\\\":return{type:\\\"initialized\\\",version:\\\"5.34.1\\\"};case\\\"write\\\":var n=e.get(a.streamId);n||(n=new re,e.set(a.streamId,n));var r=n.chunks.length,i=function(t){if(\\\"function\\\"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);var e,a,n,r,i,s=t.length,h=0;for(r=0;r<s;r++)55296==(64512&(a=t.charCodeAt(r)))&&r+1<s&&56320==(64512&(n=t.charCodeAt(r+1)))&&(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++)55296==(64512&(a=t.charCodeAt(r)))&&r+1<s&&56320==(64512&(n=t.charCodeAt(r+1)))&&(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}\nvar state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(configuration, source, onInitializationFailure, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { 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) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker = createDeflateWorkerImpl(configuration);\n        var removeErrorListener_1 = addEventListener(configuration, worker, 'error', function (error) {\n            onError(configuration, source, error);\n        }).stop;\n        var removeMessageListener_1 = addEventListener(configuration, worker, 'message', function (_a) {\n            var data = _a.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        }).stop;\n        worker.postMessage({ action: 'init' });\n        setTimeout(function () { return onTimeout(source); }, INITIALIZATION_TIME_OUT_DELAY);\n        var stop_1 = function () {\n            removeErrorListener_1();\n            removeMessageListener_1();\n        };\n        state = { status: 1 /* DeflateWorkerStatus.Loading */, worker: worker, stop: stop_1, 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(\"\".concat(source, \" failed to start: a timeout occurred while initializing the Worker\"));\n        state.initializationFailureCallbacks.forEach(function (callback) { return 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: version };\n    }\n}\nfunction onError(configuration, source, error, streamId) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */ || state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        display.error(\"\".concat(source, \" failed to start: an error occurred while creating the Worker:\"), error);\n        if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n            var baseMessage = void 0;\n            if (configuration.workerUrl) {\n                baseMessage = \"Please make sure the Worker URL \".concat(configuration.workerUrl, \" is correct and CSP is correctly configured.\");\n            }\n            else {\n                baseMessage = 'Please make sure CSP is correctly configured.';\n            }\n            display.error(\"\".concat(baseMessage, \" See documentation at \").concat(DOCS_ORIGIN, \"/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay\"));\n        }\n        else {\n            addTelemetryError(error);\n        }\n        if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n            state.initializationFailureCallbacks.forEach(function (callback) { return 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}\nfunction isMessageCspRelated(message) {\n    return (includes(message, '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        includes(message, \"requires 'TrustedScriptURL'\"));\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    var session = sessionManager.findTrackedSession();\n    var errorType = getErrorType(session, isRecordingStarted);\n    var viewContext = viewHistory.findView();\n    return getSessionReplayUrl(configuration, {\n        viewContext: viewContext,\n        errorType: errorType,\n        session: 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 { PageExitReason, runOnReadyState } from '@datadog/browser-core';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nexport function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, startRecordingImpl, getOrCreateDeflateEncoder) {\n    var status = 0 /* RecorderStatus.Stopped */;\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\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(10 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n        if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n            stop();\n        }\n    });\n    lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        if (status === 1 /* RecorderStatus.IntentToStart */) {\n            start();\n        }\n    });\n    function start(options) {\n        var 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        runOnReadyState(configuration, 'interactive', function () {\n            if (status !== 2 /* RecorderStatus.Starting */) {\n                return;\n            }\n            var deflateEncoder = getOrCreateDeflateEncoder();\n            if (!deflateEncoder) {\n                status = 0 /* RecorderStatus.Stopped */;\n                return;\n            }\n            ;\n            (stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewHistory, deflateEncoder).stop);\n            status = 3 /* RecorderStatus.Started */;\n        });\n        if (shouldForceReplay(session, options)) {\n            sessionManager.setForcedReplay();\n        }\n    }\n    function stop() {\n        if (status !== 0 /* RecorderStatus.Stopped */ && status === 3 /* RecorderStatus.Started */) {\n            stopRecording === null || stopRecording === void 0 ? void 0 : stopRecording();\n        }\n        status = 0 /* RecorderStatus.Stopped */;\n    }\n    var stopRecording;\n    return {\n        start: start,\n        stop: stop,\n        getSessionReplayLink: function () {\n            return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== 0 /* RecorderStatus.Stopped */);\n        },\n        isRecording: function () { return 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","// 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 { startRecording } from '../boot/startRecording';\nimport { makeRecorderApi } from '../boot/recorderApi';\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi, { startDeflateWorker: startDeflateWorker, createDeflateEncoder: createDeflateEncoder });\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils/polyfills';\nimport { display } from '../tools/display';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"5.34.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: function (callback) {\n            callback();\n        },\n    }, stub);\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: function () {\n            return setDebugMode;\n        },\n        enumerable: false,\n    });\n    return publicApi;\n}\nexport function defineGlobal(global, name, api) {\n    var 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(function (fn) { return catchUserErrors(fn, 'onReady callback threw an error:')(); });\n    }\n}\n//# sourceMappingURL=init.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(startRecordingImpl, createDeflateWorkerImpl) {\n    if ((canUseEventBridge() && !bridgeSupports(\"records\" /* BridgeCapability.RECORDS */)) || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n            getSessionReplayLink: function () { return undefined; },\n        };\n    }\n    // eslint-disable-next-line prefer-const\n    var _a = createPreStartStrategy(), strategy = _a.strategy, shouldStartImmediately = _a.shouldStartImmediately;\n    return {\n        start: function (options) { return strategy.start(options); },\n        stop: function () { return strategy.stop(); },\n        getSessionReplayLink: function () { return strategy.getSessionReplayLink(); },\n        onRumStart: onRumStart,\n        isRecording: function () {\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            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ && strategy.isRecording();\n        },\n        getReplayStats: function (viewId) {\n            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ ? getReplayStatsImpl(viewId) : undefined;\n        },\n    };\n    function onRumStart(lifeCycle, configuration, sessionManager, viewHistory, worker) {\n        var cachedDeflateEncoder;\n        function getOrCreateDeflateEncoder() {\n            if (!cachedDeflateEncoder) {\n                worker !== null && worker !== void 0 ? worker : (worker = startDeflateWorker(configuration, 'Datadog Session Replay', function () {\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, startRecordingImpl, 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    var status = 0 /* PreStartRecorderStatus.None */;\n    return {\n        strategy: {\n            start: function () {\n                status = 1 /* PreStartRecorderStatus.HadManualStart */;\n            },\n            stop: function () {\n                status = 2 /* PreStartRecorderStatus.HadManualStop */;\n            },\n            isRecording: function () { return false; },\n            getSessionReplayLink: noop,\n        },\n        shouldStartImmediately: function (configuration) {\n            return (status === 1 /* PreStartRecorderStatus.HadManualStart */ ||\n                (status === 0 /* PreStartRecorderStatus.None */ && !configuration.startSessionReplayRecordingManually));\n        },\n    };\n}\n//# sourceMappingURL=preStartStrategy.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    var cleanupTasks = [];\n    var reportError = function (error) {\n        lifeCycle.notify(13 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var addRecord;\n    if (!canUseEventBridge()) {\n        var 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).addRecord);\n    }\n    var stopRecording = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n        viewHistory: viewHistory,\n    }).stop;\n    cleanupTasks.push(stopRecording);\n    return {\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRecordBridge(viewHistory) {\n    var bridge = getEventBridge();\n    return {\n        addRecord: function (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            var view = viewHistory.findView();\n            bridge.send('record', record, view.id);\n        },\n    };\n}\n//# sourceMappingURL=startRecordBridge.js.map","import { addTelemetryUsage, assign, createContextManager, deepClone, makePublicApi, monitor, clocksNow, callMonitored, createHandlingStack, checkUser, sanitizeUser, sanitize, createIdentityEncoder, createCustomerDataTrackerManager, storeContextManager, displayAlreadyInitializedError, createTrackingConsentState, timeStampToClocks, } from '@datadog/browser-core';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nimport { createCustomVitalsState } from '../domain/vital/vitalCollection';\nimport { createPreStartStrategy } from './preStartRum';\nvar RUM_STORAGE_KEY = 'rum';\nexport function makeRumPublicApi(startRumImpl, recorderApi, options) {\n    if (options === void 0) { options = {}; }\n    var customerDataTrackerManager = createCustomerDataTrackerManager(0 /* CustomerDataCompressionStatus.Unknown */);\n    var globalContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */));\n    var userContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */));\n    var trackingConsentState = createTrackingConsentState();\n    var customVitalsState = createCustomVitalsState();\n    function getCommonContext() {\n        return buildCommonContext(globalContextManager, userContextManager, recorderApi);\n    }\n    var strategy = createPreStartStrategy(options, getCommonContext, trackingConsentState, customVitalsState, function (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        }\n        customerDataTrackerManager.setCompressionStatus(deflateWorker ? 1 /* CustomerDataCompressionStatus.Enabled */ : 2 /* CustomerDataCompressionStatus.Disabled */);\n        var startRumResult = startRumImpl(configuration, recorderApi, customerDataTrackerManager, getCommonContext, initialViewOptions, deflateWorker && options.createDeflateEncoder\n            ? function (streamId) { return 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        return startRumResult;\n    });\n    var startView = monitor(function (options) {\n        var 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    var rumPublicApi = makePublicApi({\n        init: monitor(function (initConfiguration) {\n            strategy.init(initConfiguration, rumPublicApi);\n        }),\n        setTrackingConsent: monitor(function (trackingConsent) {\n            trackingConsentState.update(trackingConsent);\n            addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent });\n        }),\n        setViewName: monitor(function (name) {\n            strategy.setViewName(name);\n        }),\n        setViewContext: monitor(function (context) {\n            strategy.setViewContext(context);\n        }),\n        setViewContextProperty: monitor(function (key, value) {\n            strategy.setViewContextProperty(key, value);\n        }),\n        setGlobalContext: monitor(function (context) {\n            globalContextManager.setContext(context);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        getGlobalContext: monitor(function () { return globalContextManager.getContext(); }),\n        setGlobalContextProperty: monitor(function (key, value) {\n            globalContextManager.setContextProperty(key, value);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        removeGlobalContextProperty: monitor(function (key) { return globalContextManager.removeContextProperty(key); }),\n        clearGlobalContext: monitor(function () { return globalContextManager.clearContext(); }),\n        getInternalContext: monitor(function (startTime) { return strategy.getInternalContext(startTime); }),\n        getInitConfiguration: monitor(function () { return deepClone(strategy.initConfiguration); }),\n        addAction: function (name, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                strategy.addAction({\n                    name: sanitize(name),\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                    type: \"custom\" /* ActionType.CUSTOM */,\n                    handlingStack: handlingStack,\n                });\n                addTelemetryUsage({ feature: 'add-action' });\n            });\n        },\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                strategy.addError({\n                    error: error, // Do not sanitize error here, it is needed unserialized by computeRawError()\n                    handlingStack: handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n                addTelemetryUsage({ feature: 'add-error' });\n            });\n        },\n        addTiming: monitor(function (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(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        getUser: monitor(function () { return userContextManager.getContext(); }),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        removeUserProperty: monitor(function (key) { return userContextManager.removeContextProperty(key); }),\n        clearUser: monitor(function () { return userContextManager.clearContext(); }),\n        startView: startView,\n        stopSession: monitor(function () {\n            strategy.stopSession();\n            addTelemetryUsage({ feature: 'stop-session' });\n        }),\n        addFeatureFlagEvaluation: monitor(function (key, value) {\n            strategy.addFeatureFlagEvaluation(sanitize(key), sanitize(value));\n            addTelemetryUsage({ feature: 'add-feature-flag-evaluation' });\n        }),\n        getSessionReplayLink: monitor(function () { return recorderApi.getSessionReplayLink(); }),\n        startSessionReplayRecording: monitor(function (options) {\n            recorderApi.start(options);\n            addTelemetryUsage({ feature: 'start-session-replay-recording', force: options && options.force });\n        }),\n        stopSessionReplayRecording: monitor(function () { return recorderApi.stop(); }),\n        addDurationVital: monitor(function (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(function (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(function (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 assign({\n        init: function (initConfiguration) {\n            displayAlreadyInitializedError('DD_RUM', initConfiguration);\n        },\n        initConfiguration: preStartStrategy.initConfiguration,\n    }, startRumResult);\n}\n//# sourceMappingURL=rumPublicApi.js.map","export function buildCommonContext(globalContextManager, userContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.js.map","import { sendToExtension, createPageExitObservable, startTelemetry, canUseEventBridge, getEventBridge, addTelemetryDebug, drainPreStartTelemetry, isExperimentalFeatureEnabled, ExperimentalFeature, } 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 { startLongTaskCollection } from '../domain/longTask/longTaskCollection';\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';\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 cleanupTasks = [];\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) { return sendToExtension('rum', event); });\n    var telemetry = startRumTelemetry(configuration);\n    telemetry.setContextProvider(function () {\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    var reportError = function (error) {\n        lifeCycle.notify(13 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle, customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */));\n    var pageExitObservable = createPageExitObservable(configuration);\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) {\n        lifeCycle.notify(10 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    cleanupTasks.push(function () { return pageExitSubscription.unsubscribe(); });\n    var session = !canUseEventBridge()\n        ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n        : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        var batch_1 = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable, createEncoder);\n        cleanupTasks.push(function () { return batch_1.stop(); });\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batch_1.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(configuration, location);\n    var pageStateHistory = startPageStateHistory(configuration);\n    var _a = createWindowOpenObservable(), windowOpenObservable = _a.observable, stopWindowOpen = _a.stop;\n    cleanupTasks.push(stopWindowOpen);\n    var _b = startRumEventCollection(lifeCycle, configuration, location, session, pageStateHistory, locationChangeObservable, domMutationObservable, windowOpenObservable, getCommonContext, reportError), viewHistory = _b.viewHistory, urlContexts = _b.urlContexts, actionContexts = _b.actionContexts, addAction = _b.addAction, stopRumEventCollection = _b.stop;\n    cleanupTasks.push(stopRumEventCollection);\n    drainPreStartTelemetry();\n    var _c = startViewCollection(lifeCycle, configuration, location, domMutationObservable, windowOpenObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions), addTiming = _c.addTiming, startView = _c.startView, setViewName = _c.setViewName, setViewContext = _c.setViewContext, setViewContextProperty = _c.setViewContextProperty, stopViewCollection = _c.stop;\n    cleanupTasks.push(stopViewCollection);\n    var stopResourceCollection = startResourceCollection(lifeCycle, configuration, pageStateHistory).stop;\n    cleanupTasks.push(stopResourceCollection);\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.LONG_ANIMATION_FRAME)) {\n        if (configuration.trackLongTasks) {\n            var stopLongAnimationFrameCollection = startLongAnimationFrameCollection(lifeCycle, configuration).stop;\n            cleanupTasks.push(stopLongAnimationFrameCollection);\n        }\n    }\n    else {\n        startLongTaskCollection(lifeCycle, configuration);\n    }\n    var addError = startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    var vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState);\n    var internalContext = startInternalContext(configuration.applicationId, session, viewHistory, actionContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView: startView,\n        setViewContext: setViewContext,\n        setViewContextProperty: setViewContextProperty,\n        setViewName: setViewName,\n        lifeCycle: lifeCycle,\n        viewHistory: viewHistory,\n        session: session,\n        stopSession: function () { return session.expire(); },\n        getInternalContext: internalContext.get,\n        startDurationVital: vitalCollection.startDurationVital,\n        stopDurationVital: vitalCollection.stopDurationVital,\n        addDurationVital: vitalCollection.addDurationVital,\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\nfunction startRumTelemetry(configuration) {\n    var telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, pageStateHistory, locationChangeObservable, domMutationObservable, windowOpenObservable, getCommonContext, reportError) {\n    var viewHistory = startViewHistory(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var _a = startActionCollection(lifeCycle, domMutationObservable, windowOpenObservable, configuration, pageStateHistory), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    var displayContext = startDisplayContext(configuration);\n    var ciVisibilityContext = startCiVisibilityContext(configuration);\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewHistory, urlContexts, actionContexts, displayContext, ciVisibilityContext, getCommonContext, reportError);\n    return {\n        viewHistory: viewHistory,\n        pageStateHistory: pageStateHistory,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            ciVisibilityContext.stop();\n            displayContext.stop();\n            urlContexts.stop();\n            viewHistory.stop();\n            pageStateHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { instrumentMethod, Observable } from '@datadog/browser-core';\nexport function createWindowOpenObservable() {\n    var observable = new Observable();\n    var stop = instrumentMethod(window, 'open', function () { return observable.notify(); }).stop;\n    return { observable: observable, stop: stop };\n}\n//# sourceMappingURL=windowOpenObservable.js.map","import { ExperimentalFeature, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nexport function startDisplayContext(configuration) {\n    var viewport;\n    var animationFrameId;\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.DELAY_VIEWPORT_COLLECTION)) {\n        // Use requestAnimationFrame to delay the calculation of viewport dimensions until after SDK initialization, preventing long tasks.\n        animationFrameId = requestAnimationFrame(function () {\n            viewport = getViewportDimension();\n        });\n    }\n    else {\n        viewport = getViewportDimension();\n    }\n    var unsubscribeViewport = initViewportObservable(configuration).subscribe(function (viewportDimension) {\n        viewport = viewportDimension;\n    }).unsubscribe;\n    return {\n        get: function () { return (viewport ? { viewport: viewport } : undefined); },\n        stop: function () {\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    var performanceResourceSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_ANIMATION_FRAME,\n        buffered: true,\n    }).subscribe(function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            var startClocks = relativeToClocks(entry.startTime);\n            var 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(function (script) { return ({\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(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return {\n        stop: function () { return performanceResourceSubscription.unsubscribe(); },\n    };\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    var performanceLongTaskSubscription = createPerformanceObservable(configuration, {\n        type: RumPerformanceEntryType.LONG_TASK,\n        buffered: true,\n    }).subscribe(function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType !== RumPerformanceEntryType.LONG_TASK) {\n                break;\n            }\n            if (!configuration.trackLongTasks) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var 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(11 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry },\n            });\n        }\n    });\n    return {\n        stop: function () {\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: function (startTime) {\n            var viewContext = viewHistory.findView(startTime);\n            var urlContext = urlContexts.findUrl(startTime);\n            var session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                var 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 { 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":["ConsoleApiName","log","debug","info","warn","error","globalConsole","console","originalConsoleMethods","Object","keys","forEach","name","PREFIX","display","bind","DOCS_ORIGIN","DOCS_TROUBLESHOOTING","concat","MORE_DETAILS","catchUserErrors","fn","errorMsg","args","_i","arguments","length","apply","err","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","i","l","Array","prototype","slice","call","debugMode","setDebugMode","newDebugMode","monitor","callMonitored","this","context","e","displayIfDebugEnabled","includes","candidate","search","indexOf","arrayLike","array","Set","item","push","find","predicate","objectValues","object","map","key","objectEntries","startsWith","target","toAssign","source","hasOwnProperty","getGlobalObject","globalThis","defineProperty","get","configurable","globalObject","_dd_temp_","self","window","ONE_KIBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","test","undefined","TextEncoder","encode","Blob","size","getZoneJsOriginalValue","original","browserWindow","Zone","__symbol__","callback","delay","timeoutId","throttle","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","cancel","noop","jsonStringify","value","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","_a","objectToJson","toJSON","shallowClone","objectHasValue","some","isEmptyObject","createCustomerDataTrackerManager","compressionStatus","customerDataTrackers","Map","alreadyWarned","checkCustomerDataLimit","initialBytesCount","bytesCountLimit","bytesCount","tracker","getBytesCount","displayCustomerDataLimitReachedWarning","createDetachedTracker","createCustomerDataTracker","getOrCreateTracker","type","has","set","setCompressionStatus","newCompressionStatus","getCompressionStatus","stop","clear","bytesCountCache","computeBytesCountThrottled","cancelComputeBytesCount","resetBytesCount","updateCustomerData","resetCustomerData","getType","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","add","createCircularReferenceChecker","Date","getTime","RegExp","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","sources_1","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","serializedSanitizedData","accumulatedCharacterCount","containerToProcess","shift","separatorLength","targetData","path","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","toString","description","sanitizePrimitivesAndFunctions","sanitizedSource","Event","isTrusted","match","sanitizeObjects","sourceAsObject","currentPath","changeType","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","filter","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","createContextManager","customerDataTracker","changeObservable","contextManager","getContext","setContext","newContext","clearContext","setContextProperty","property","removeContextProperty","TrackingConsent","GRANTED","NOT_GRANTED","addEventListener","configuration","eventTarget","eventName","listener","addEventListeners","eventNames","_b","once","capture","passive","listenerWithMonitor","event","__ddIsTrusted","allowUntrustedEvents","listenerTarget","EventTarget","remove","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","productKey","customerDataType","storageKey","buildStorageKey","getFromStorage","rawContext","localStorage","getItem","parse","setItem","createIdentityEncoder","output","outputBytesCount","isAsync","isEmpty","write","additionalEncodedBytesCount","finish","finishSync","result","rawBytesCount","pendingData","estimateEncodedBytesCount","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","exString","String","split","line","stackFrame","parts","CHROME_LINE_RE","exec","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","url","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","message","fileUrl","filePosition","computeStackTraceFromOnErrorMessage","messageObj","ERROR_TYPES_RE","tryToParseMessage","createHandlingStack","formattedStack","Error","stackTrace","toStackTraceString","formatErrorMessage","frame","ExperimentalFeature","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","originalError","handlingStack","startClocks","nonErrorPrefix","handling","isErrorInstance","isError","computeMessage","hasUsableStack","causes","flattenErrorCauses","fingerprint","tryToGetFingerprint","dd_fingerprint","parentSource","currentError","cause","enabledExperimentalFeatures","initFeatureFlags","enableExperimentalFeatures","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","PCI_INTAKE_HOST_US1","INTAKE_URL_PARAMETERS","performDraw","threshold","Math","random","round","num","decimals","toFixed","isNumber","navigationStart","ONE_SECOND","ONE_MINUTE","ONE_YEAR","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","addDuration","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","a","b","getRelativeTime","timestamp","timing","sendToExtension","payload","__ddBrowserSdkExtensionCallback","getConnectivity","navigator","status","onLine","interfaces","connection","effective_type","effectiveType","removeItem","index","splice","buffer","drain","arg","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","preStartTelemetryBuffer","onRawTelemetryEventCollected","startTelemetry","telemetryService","contextProvider","alreadySentEvents","telemetryEnabled","site","telemetrySampleRate","telemetryEnabledPerType","telemetryConfigurationSampleRate","telemetryUsageSampleRate","runtimeEnvInfo","is_local_file","location","protocol","is_worker","rawEvent","stringifiedEvent","maxTelemetryEventsPerPage","event_1","date","service","version","_dd","format_version","telemetry","runtime_env","connectivity","sdk_setup","experimental_features","toTelemetryEvent","addTelemetryError","setContextProvider","provider","enabled","addTelemetryDebug","kind","scrubCustomerFrames","formatError","addTelemetryUsage","usage","allowedFrameUrl","sanitizeUser","newUser","user","displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","generateUUID","placeholder","parseInt","replace","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","startVitalCollection","lifeCycle","pageStateHistory","customVitalsState","addDurationVital","vital","wasInPageStateDuringPeriod","isValid","valueComputedBySdk","rawRumEvent","id","computed_value","startTime","customerContext","domainContext","processVital","startDurationVital","stopDurationVital","nameOrRef","vitalsByName","vitalsByReference","reference","__dd_vital_reference","stopCallback","vitalStart","stopOptions","stopClocks","buildDurationVital","delete","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","getPrivacyLevel","getAllowedWebViewHosts","send","eventType","viewId","view","bridgeSupports","capability","bridge","canUseEventBridge","currentHost","hostname","allowedHost","instrumentMethod","targetPrototype","method","onPreCall","computeHandlingStack","stopped","instrumentation","postCallCallback","onPostCall","instrumentSetter","after","originalDescriptor","getOwnPropertyDescriptor","stoppedInstrumentation","instrumentationWrapper","normalizeUrl","buildUrl","href","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","document","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","fetchObservable","initCookieParsed","getCurrentSiteCache","URL","initFetchObservable","fetch","input","init","methodFromParams","Request","toUpperCase","state","responsePromise","startContext","reportFetch","partialContext","then","response","responseType","isAborted","signal","aborted","DOMException","code","ABORT_ERR","afterSend","beforeSend","setCookie","expireDelay","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","partitioned","cookie","getCookie","getInitCookie","findCommaSeparatedValues","deleteCookie","browserCache","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","detectBrowserCached","userAgent","chrome","vendor","documentMode","detectBrowser","SESSION_STORE_KEY","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_COOKIE_EXPIRATION_DELAY","SESSION_ENTRY_REGEXP","getExpiredSessionState","previousSessionState","expiredSessionState","isExpired","ANONYMOUS_USER_TRACKING","anonymousId","floor","pow","isSessionInNotStartedState","session","isSessionStarted","isSessionInExpiredState","sessionState","created","Number","expire","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","entry","matches","selectCookieStrategy","cookieOptions","useSecureSessionCookie","usePartitionedCrossSiteSessionCookie","useCrossSiteSessionCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","pop","getCurrentSite","buildCookieOptions","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","isLockEnabled","persistSession","retrieveSession","retrieveSessionCookie","expireSession","expireSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","persistInLocalStorage","retrieveSessionFromLocalStorage","expireSessionFromLocalStorage","ongoingOperations","bufferedOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","persistWithLock","lock","currentLock","retrieveStore","next","currentStore","retryLater","processedSession","process","sessionStore","currentNumberOfRetries","nextOperations","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionStoreStrategyType","allowFallbackToLocalStorage","testKey","retrievedId","selectLocalStorageStrategy","startSessionStore","computeSessionState","sessionCache","renewObservable","expireObservable","sessionStateUpdateObservable","watchSessionTimeoutId","synchronizeSession","startSession","synchronizedSession","trackingType","isTracked","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","throttledExpandOrRenewSession","cancelExpandOrRenewSession","isSessionInCacheOutdated","previousState","newState","expandOrRenewSession","expandSession","getSession","restartSession","updateSessionState","partialSessionState","createEndpointBuilder","trackType","configurationTags","buildUrlWithParameters","proxy","normalizedProxyUrl_1","encodeURIComponent","host","internalAnalyticsSubdomain","usePciIntake","domainParts","extension","buildEndpointHost","createEndpointUrlWithParametersBuilder","build","api","clientToken","retry","encoding","tags","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","buildTag","rawValue","valueSizeLimit","supportUnicodePropertyEscapes","hasForbiddenCharacters","sanitizedValue","computeTransportConfiguration","env","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","createIdentifierImplementationCache","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","TraceContextInjection","ALL","SAMPLED","isString","tag","tagName","isSampleRate","sampleRate","validateAndBuildConfiguration","_c","_d","_e","sessionSampleRate","trackingConsent","storeContextsAcrossPages","batchBytesLimit","eventRateLimiterThreshold","flushTimeout","batchMessagesLimit","messageBytesLimit","isMatchOption","itemType","matchList","list","useStartsWith","getCrypto","crypto","msCrypto","createSpanIdentifier","createIdentifier","bits","CONSISTENT_TRACE_SAMPLING","getRandomValues","BigUint64Array","areBigIntIdentifiersSupported","createIdentifierUsingBigInt","createIdentifierUsingUint32Array","BigInt","Uint32Array","radix","high","low","str","mod","toPaddedHexadecimalString","traceId","clearTracingIfNeeded","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","findTrackedSession","tracingOption","allowedTracingUrls","traceSampleRate","identifier","knuthFactor","twoPow64","isTraceSampled","traceContextInjection","propagatorTypes","tracingHeaders","propagatorType","traceparent","b3","makeTracingHeaders","DEFAULT_PROPAGATOR_TYPES","validateAndBuildRumConfiguration","sessionReplaySampleRate","excludedActivityUrls","tracingOptions","option","expectedItem","validateAndBuildTracingOptions","baseConfiguration","actionNameAttribute","startSessionReplayRecordingManually","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackLongTasks","subdomain","defaultPrivacyLevel","enablePrivacyForActionName","customerDataTelemetrySampleRate","plugins","getSelectedTracingPropagators","usedTracingPropagators","REMOTE_CONFIGURATION_URL","fetchAndApplyRemoteConfiguration","xhr","XMLHttpRequest","responseText","displayRemoteConfigurationFetchingError","open","remoteConfigurationId","fetchRemoteConfiguration","remoteInitConfiguration","applyRemoteConfiguration","createPreStartStrategy","getCommonContext","trackingConsentState","doStartRum","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","ignoreInitIfSyntheticsWillInjectRum","startDeflateWorker","bufferApiCalls","trackingConsentStateSubscription","tryStartRum","isGranted","initialViewOptions","startRumResult","doInit","eventBridgeAvailable","overrideInitConfigurationForBridge","addTelemetryConfiguration","baseSerializedConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","telemetry_usage_sample_rate","use_before_send","use_cross_site_session_cookie","use_partitioned_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","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","plugin","getConfigurationTelemetry","serializeRumConfiguration","tryToInit","publicApi","methodName","parameter","plugins_1","callPluginsMethod","REMOTE_CONFIGURATION","getInternalContext","stopSession","addTiming","time","startView","setViewName","setViewContext","setViewContextProperty","addAction","action","commonContext","addError","providedError","addFeatureFlagEvaluation","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","isPageExitReason","reason","getMutationObserverConstructor","constructor","MutationObserver","originalInstance","ErrorSource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","getSyntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","limitModification","modifiableFieldPaths","modifier","clone","fieldPath","fieldType","newValue","current","field","isValidObjectContaining","newType","fields","isValidObject","modifiableFieldPathsByEvent","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","ROOT_MODIFIABLE_FIELD_PATHS","startRumAssembly","viewHistory","urlContexts","actionContexts","displayContext","ciVisibilityContext","reportError","WRITABLE_RESOURCE_GRAPHQL","eventRateLimiters","syntheticsContext","savedCommonContext","viewHistoryEntry","findView","urlContext","findUrl","actionId","findActionId","serverRumEvent","drift","browser_sdk_version","application","referrer","synthetics","ci_test","has_replay","hasReplay","sampled_for_replay","sessionReplay","anonymous_id","usr","rateLimitReached","shouldSend","LifeCycle","AbstractLifeCycle","callbacks","eventCallbacks","END_OF_TIMES","Infinity","createValueHistory","maxEntries","entries","clearOldValuesInterval","oldTimeThreshold","endTime","clearOldValues","close","unshift","returnInactive","entries_1","closeActive","latestEntry","findAll","reset","xhrObservable","VIEW_CONTEXT_TIME_OUT_DELAY","xhrContexts","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","hasBeenReported","stopInstrumentingOnReadyStateChange","readyState","DONE","onEnd","unsubscribeLoadEndListener","completeContext","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","computeResourceEntryType","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","areInOrder","numbers","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","encoded_body_size","decoded_body_size","transfer_size","transferSize","isAllowedRequestUrl","every","param","isIntakeUrl","DATA_URL_REGEX","isLongDataUrl","substring","sanitizeDataUrl","RumPerformanceEntryType","resourceTimingBufferFullListener","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","tryToClone","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer_1","Uint8Array","offset_1","chunk","bytesLimit","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","discardNegativeDuration","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","retrieveFirstInputTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","entryType","processingStart","processingEnd","sendTiming","sendTimingIfPointerIsNotCancelled","createPerformanceObservable","PerformanceObserver","stopFirstInputTiming","handlePerformanceEntries","rumPerformanceEntries","RESOURCE","isForbiddenResource","filterRumPerformanceEntries","isObserverInitializing","getEntries","observe","NAVIGATION","LONG_TASK","PAINT","buffered","getEntriesByType","entryTypes","clearResourceTimings","manageResourceTimingBufferFull","supportPerformanceTimingEvent","FIRST_INPUT","disconnect","supportedEntryTypes","PAGE_ACTIVITY_VALIDATION_DELAY","waitPageActivityEnd","domMutationObservable","windowOpenObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","cssEscape","CSS","escape","ch","asCodePoint","elementMatches","element","selector","msMatchesSelector","getParentElement","node","parentElement","parentNode","nodeType","Node","ELEMENT_NODE","initialValues","isTextNode","TEXT_NODE","isElementNode","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","forEachChildNodes","child","firstChild","nextSibling","getParentNode","NodePrivacyLevel","IGNORE","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","cache","parentNodePrivacyLevel","nodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","inputElement","autocomplete","getAttribute","endsWith","getPrivacySelector","nodeName","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","hasAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","getTextContent","textNode","ignoreWhiteSpace","parentTagName","textContent","trim","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","truncate","normalizeWhitespace","supportsLabelPropertyResult","priorityStrategies","userProgrammaticAttribute","privacy","HTMLInputElement","supportsLabelProperty","labels","getActionNameFromTextualContent","label","ownerDocument","querySelectorAll","htmlFor","nameSource","privacyEnabledActionName","getActionNameFromStandardAttribute","labelledByAttribute","refElement","getElementById","getTextualContent","fallbackStrategies","MAX_PARENTS_TO_CONSIDER","getActionNameFromElementForStrategies","strategies","recursionCounter","strategies_1","actionName","strategy","name_1","trimmedName","attribute","isContentEditable","text_1","innerText","removeTextFromElements","query","element_1","textToReplace","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","classes","getClassList","className","getSelectorFromElement","isConnected","documentElement","contains","targetElementSelector","currentElement","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","childSelector","selectorGetters_1","elementSelector","selectorGetter","currentElementSelector","isSiblingMatching","scopedSelector_1","querySelector","supportScopeSelector","parent","MAX_DURATION_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeoutId","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","isStopped","tryAppend","first","second","sqrt","clientX","clientY","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","computeFrustration","clicks","rageClick","getUserActivity","scroll","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","CLICK_ACTION_MAX_DURATION","interactionSelectorCache","updateInteractionSelector","relativeTimestamp","trackClickActions","currentClickChain","history","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onPointerUp","userActivity","listeners","localUserActivity_1","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","defaultActionName","getActionNameFromElement","width","height","position","x","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","viewEndedSubscription","endClocks","stopSubscription","startClickAction","rageClick_1","validate","finalizeClicks","activityEndTime","historyEntry","eventCountsSubscription","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","events","processAction","autoActionProperties","isAutoAction","loading_time","long_task","resource","name_source","ACTION_NAME_MASKING","actionEvent","in_foreground","wasInPageStateAt","trackRuntimeError","errorObservable","handleRuntimeError","rawError","stopInstrumentingOnError","errorObj","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","RawReportType","initReportObservable","blockedURI","effectiveDirective","buildRawReportError","csp","disposition","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportErrorFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportErrorFromReport","types","createReportObservable","partial","startErrorCollection","featureFlagContexts","consoleLog","trackConsoleError","trackReportError","handling_stack","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","processError","doStartErrorCollection","requestIdleCallback","opts","cancelIdleCallback","id_1","didTimeout","timeRemaining","max","MAX_TASK_TIME","requestIdleCallbackShim","alreadyMatchedEntries","matchRequestResourceEntry","sameNameEntries","getEntriesByName","candidates","errorMargin","runOnReadyState","expectedReadyState","getDocumentTraceId","traceIdMeta","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","getNavigationEntry","navigationEntry","timings","numberKey","timingElement","computeTimingsFromDeprecatedPerformanceTiming","retrieveInitialDocumentResourceTiming","startResourceCollection","taskQueue","retrieveInitialDocumentResourceTimingImpl","pendingTasks","run","deadline","executionTimeRemaining","start_1","scheduleNextRun","timeout","task","createTaskQueue","handleResource","matchingTiming","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","correspondingTimingOverrides","computeResourceEntryMetrics","computeRequestDuration","resourceEvent","status_code","delivery_type","performanceEntry","requestInput","requestInit","processRequest","performanceResourceSubscription","_loop_1","isResourceEntryRequestType","processResourceEntry","computeRawEvent","computeResourceEntryTracingInfo","statusCode","entryMetrics","responseStatus","renderBlockingStatus","render_blocking_status","trackNavigationTimings","getNavigationEntryImpl","stopOnReadyState","waitAfterLoadEvent","loadEventEnd","isIncompleteNavigation","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","processNavigationEntry","trackFirstHidden","stopListeners","visibilityState","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","navigationTimings","firstHidden","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","biggestLcpSize","performanceLcpSubscription","LARGEST_CONTENTFUL_PAINT","lcpEntry","findLast","lcpTargetSelector","targetSelector","trackLargestContentfulPaint","largestContentfulPaint","stopFIDTracking","performanceFirstInputSubscription","firstInputEntry","firstInputDelay","firstInputTargetSelector","trackFirstInput","firstInput","trackCumulativeLayoutShift","viewStart","isLayoutShiftSupported","maxClsTarget","maxClsStartTime","maxClsValue","cumulatedValue","maxValue","update","isMaxValue","MAX_UPDATE_GAP","MAX_WINDOW_DURATION","slidingSessionWindow","performanceSubscription","LAYOUT_SHIFT","hadRecentInput","getTargetFromSource","WeakRef","deref","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","viewportObservable","getInteractionCount","interactionCount","trackInteractionToNextPaint","viewLoadingType","EVENT","PerformanceEventTiming","getInteractionToNextPaint","setViewEnd","interactionToNextPaintTargetSelector","interactionToNextPaintStartTime","interactionId","min","durationThreshold","previousInteractionCount","computeViewInteractionCount","getViewInteractionCount","stopViewInteractionCount","trackViewInteractionCount","viewEnd","longestInteractions","sortAndTrimLongestInteractions","sort","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaint","handleEntries","newInteraction","firstInputSubscription","eventSubscription","viewEndTime","getScrollX","scrollX","visual","visualViewport","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","initViewportObservable","updateDimension","getViewportDimension","createViewportObservable","scale","innerWidth","innerHeight","THROTTLE_SCROLL_DURATION","trackScrollMetrics","scrollValues","throttleDuration","scrollTop","scrollHeight","scrollDepth","scrollingElement","ResizeObserver","throttledNotify_1","observerTarget","resizeObserver_1","eventListener_1","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","maxDepth","maxDepthScrollTop","trackCommonViewMetrics","loadingType","commonViewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","loadingTime","trackLoadingTime","newLoadingTime","stopLoadingTimeTracking","stopScrollMetricsTracking","newScrollMetrics","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","getCommonViewMetrics","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","locationChangeSubscription","activeViews","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","customTimings","documentVersion","sessionIsActive","viewCreatedEvent","triggerViewUpdate","cancelScheduleViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","trackViewEventCounts","stopEventCountsTracking","keepAliveIntervalId","currentEnd","isActive","looksLikeRelativeTime","sanitized","sanitizeTiming","updatedName","newView","pageExitEvent","currentLocation","otherLocation","hash","correspondingId","oldLocation","newLocation","getPathFromHash","renewViewOnLocationChange","startViewCollection","pageOpenObserable","recorderApi","_f","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","replayStats","getReplayStats","pageStates","viewEvent","document_version","replay_stats","page_states","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","time_spent","max_depth","max_depth_scroll_top","max_scroll_height","max_scroll_height_time","replay_level","custom_timings","newObject","mapValues","processViewUpdate","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","encoder","flushController","upsertBuffer","flushSubscription","flushObservable","upsertMessages","isPageExit","sendOnExit","encoderResult","formatPayloadFromEncoder","pendingMessages","flush","addOrUpdate","serializedMessage","estimatedMessageBytesCount","hasMessageFor","removedMessage","messageBytesCount","notifyAfterRemoveMessage","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","upsert","MAX_QUEUE_BYTES_COUNT","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","createFlushController","durationLimitTimeoutId","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","pageExitSubscription","sessionExpireSubscription","currentBytesCount","currentMessagesCount","flushReason","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","startRumBatch","telemetryEventObservable","createEncoder","batch","primary","batchFactoryImp","primaryBatch","createBatchFromConfig","replicaBatch","endpoint","replicated","transformMessage","startBatchWithReplica","isTelemetryReplicationAllowed","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","getHistoryInstrumentationTarget","stopInstrumentingReplaceState","removeListener","trackHistory","onLocationChange","stopHashTracking","onHashChange","trackHash","History","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","startPageStateHistory","maxPageStateEntriesSelectable","currentPageState","pageStateEntryHistory","addPageState","getPageState","stopEventListeners","persisted","computePageState","nextPageState","eventStartTime","pageStateEntries","pageStateServerEntries","pageState","relativeStartTime","hasFocus","createCookieObservable","cookieName","detectCookieChangeStrategy","changeEvent","changed","deleted","listenToCookieStoreChange","watchCookieFallback","WATCH_COOKIE_INTERVAL_DELAY","previousCookieValue","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","getSessionReplayUrl","viewContext","errorType","sessionId","rumConfiguration","getSiteDefaultSubdomain","statsPerView","getSegmentsCount","getOrCreateReplayStats","segments_count","records_count","segments_total_raw_size","toDelete","isFirst_1","_value","deleteOldestStats","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","quote","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","censoredImageForSize","RecordType","NodeType","IncrementalSource","MouseInteractionType","MediaInteractionType","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","cssRule","disabled","media","serializeAttribute","attributeValue","image","naturalWidth","naturalHeight","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","rule","isCSSStyleRule","selectorText","isCSSImportRule","styleSheet","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","isSVG","el","SVGElement","attributes","rr_width","rr_height","safeAttrs","formValue","optionElement","selected","stylesheet","styleSheets","_cssText","sheet","scrollLeft","checked","mediaElement","rr_mediaState","paused","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","serializeAttributes","hasChildNodes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","serializeDocument","isTouchEvent","changedTouches","getEventTarget","composed","composedPath","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","isVisualViewportFactoredIn","getVisualViewport","assembleIncrementalSnapshot","trackMove","moveCb","coordinates","tryToComputeCoordinates","timeOffset","positions","updatePosition","cancelThrottle","isFinite","eventTypeToMouseInteraction","trackMouseInteraction","mouseInteractionCb","recordIds","record","getIdForEvent","trackScroll","scrollCb","scrollPositions","trackViewportResize","viewportResizeCb","viewportResizeSubscription","trackVisualViewportResize","visualViewportResizeCb","trackMediaInteraction","mediaInteractionCb","trackStyleSheet","styleSheetCb","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","adds","removes","instrumentGroupingCSSRuleClass","cls","parentStyleSheet","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","stopper","currentRule","parentRule","index_1","trackFocus","focusCb","has_focus","trackFrustration","frustrationCb","frustrationSubscription","trackViewEnd","viewEndCb","viewEndSubscription","trackInput","inputCb","stopPropertySetterInstrumentation","lastInputStateMap","HTMLTextAreaElement","HTMLSelectElement","onElementChange","instrumentationStoppers_1","inputState","isChecked","text","cbWithDedup","lastInputState","trackMutation","mutationCallback","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","throttledFlush","addMutations","mutations","createMutationBatch","nodePrivacyLevelCache","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","addedNodes","mutations_1","sortedAddedAndMovedNodes","nodes","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","shadowDomRemovedCallback","emit","scrollPositionsByElement","emitAndComputeStats","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","initShadowRootsController","stopFullSnapshots","flushMutations","fullSnapshotCallback","takeFullSnapshot","records","initialOffset","startFullSnapshots","initRecordIds","trackers","viewEndRecord","createSegment","creationReason","encodedBytesCount","metadata","creation_reason","has_full_snapshot","index_in_view","addRecord","prefix","additionalBytesCount","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","segment","rawSegmentBytesCount","formData","FormData","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","buildReplayPayload","expirationTimeoutId","doStartSegmentCollection","computeSegmentContext","createDeflateEncoder","streamId","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","workerResponse","trailer","nextPendingAction","writeCallback","finishCallback","consumeResult","buffers","reduce","total","offset","buffers_1","concatBuffers","sendResetIfNeeded","postMessage","pendingWriteAction","createDeflateWorker","Worker","createObjectURL","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener_1","onError","removeMessageListener_1","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","baseMessage","worker_version","stream_id","isBrowserSupported","NodeList","getSessionReplayLink","isRecordingStarted","getErrorType","startRecordingImpl","getOrCreateDeflateEncoder","stopRecording","force","canStartRecording","isRecordingInProgress","deflateEncoder","shouldForceReplay","isRecording","existingGlobalVariable","onRumStart","shouldStartImmediately","cachedDeflateEncoder","makeRecorderApi","cleanupTasks","replayRequest","startRecordBridge","segmentCollection","datadogRum","startRumImpl","currentConsent","customerDataTrackerManager","globalContextManager","userContextManager","buildCommonContext","stub","preStartStrategy","createPostStartStrategy","sanitizedOptions","feature","rumPublicApi","setTrackingConsent","setGlobalContext","getGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","getInitConfiguration","setUser","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","clearUser","startSessionReplayRecording","stopSessionReplayRecording","onReady","enumerable","makeRumPublicApi","bridge_1","startRumTelemetry","currentContext","startFeatureFlagContexts","stopBeforeUnloadListener","createPageExitObservable","startRumSessionManagerStub","startRumEventBridge","batch_1","batchFlushObservable","startCustomerDataTelemetry","stopWindowOpen","viewValueHistory","buildViewHistoryEntry","viewUpdate","startViewHistory","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","viewport","animationFrameId","DELAY_VIEWPORT_COLLECTION","requestAnimationFrame","unsubscribeViewport","viewportDimension","cancelAnimationFrame","startDisplayContext","cookieObservable","testExecutionId","Cypress","cookieObservableSubscription","test_execution_id","startCiVisibilityContext","startRumEventCollection","stopRumEventCollection","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","q","datadogEnvironment","datadogVersion","datadogSampleRate"],"sourceRoot":""}