{"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/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/jsonStringify.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/serialisation/heavyCustomerDataWarning.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/serialisation/contextManager.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.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/user/user.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/observable.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/storeStrategies/sessionStoreStrategy.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/configuration.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/sendToExtension.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/browser/addEventListener.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/browser/runOnReadyState.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceUtils.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/tracing/getDocumentTraceId.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/error/error.types.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/contexts/displayContext.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-rum-core/esm/domain/contexts/ciTestContext.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/browser/xhrObservable.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/viewContexts.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.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/trackEventCounts.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/clickChain.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getActionNameFromElement.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getSelectorFromElement.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/listenActionEvents.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/computeFrustration.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/trackClickActions.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/actionCollection.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.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/rumEventsCollection/view/trackFirstHidden.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/errorCollection.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackConsoleError.js","webpack://market-storefront/../node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackReportError.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/matchRequestTiming.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceCollection.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/contexts/foregroundContexts.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackInitialViewTimings.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/rumEventsCollection/view/trackViewMetrics.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewEventCounts.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViews.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/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/flushController.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-rum-core/esm/transport/startRumBatch.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/domain/getSessionReplayUrl.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/constants.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/serialization/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/observers/moveObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/scrollObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/mouseInteractionObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/inputObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/styleSheetObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/viewportResizeObserver.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/observers/mutationObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/observers.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/mediaInteractionObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/focusObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/recordIds.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/observers/frustrationObserver.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/replayStats.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-worker/esm/entries/string.js","webpack://market-storefront/../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startDeflateWorker.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/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/startRecording.js","webpack://market-storefront/../node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.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/domain/rumEventsCollection/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};\nexport var display = function (api) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {\n        api = ConsoleApiName.log;\n    }\n    display[api].apply(display, args);\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;\ndisplay.debug = globalConsole.debug.bind(globalConsole);\ndisplay.log = globalConsole.log.bind(globalConsole);\ndisplay.info = globalConsole.info.bind(globalConsole);\ndisplay.warn = globalConsole.warn.bind(globalConsole);\ndisplay.error = globalConsole.error.bind(globalConsole);\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 { ConsoleApiName, 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(ConsoleApiName.error, e);\n        if (onMonitorErrorCollected) {\n            try {\n                onMonitorErrorCollected(e);\n            }\n            catch (e) {\n                displayIfDebugEnabled(ConsoleApiName.error, e);\n            }\n        }\n    }\n}\nexport function displayIfDebugEnabled(api) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (debugMode) {\n        display.apply(void 0, __spreadArray([api, '[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 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// 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 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}\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(window, 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n    getZoneJsOriginalValue(window, '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","/**\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 { 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 { 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    var _a;\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 accumulatedCharacterCount = ((_a = JSON.stringify(sanitizedData)) === null || _a === void 0 ? void 0 : _a.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","import { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { display } from '../display';\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;\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n    if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n        display.warn(\"The \".concat(customerDataType, \" data exceeds the recommended \").concat(CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE, \"KiB threshold. More details: https://docs.datadoghq.com/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-3kib-warning\"));\n        return true;\n    }\n    return false;\n}\n//# sourceMappingURL=heavyCustomerDataWarning.js.map","import { computeBytesCount } from '../utils/byteUtils';\nimport { throttle } from '../utils/functionUtils';\nimport { deepClone } from '../mergeInto';\nimport { jsonStringify } from './jsonStringify';\nimport { sanitize } from './sanitize';\nimport { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning';\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createContextManager(customerDataType, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    var context = {};\n    var bytesCountCache;\n    var alreadyWarned = false;\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 computeBytesCountThrottled = throttle(function (context) {\n        bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n        if (!alreadyWarned) {\n            alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, customerDataType);\n        }\n    }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled;\n    return {\n        getBytesCount: function () { return bytesCountCache; },\n        /** @deprecated use getContext instead */\n        get: function () { return context; },\n        /** @deprecated use setContextProperty instead */\n        add: function (key, value) {\n            context[key] = value;\n            computeBytesCountThrottled(context);\n        },\n        /** @deprecated renamed to removeContextProperty */\n        remove: function (key) {\n            delete context[key];\n            computeBytesCountThrottled(context);\n        },\n        /** @deprecated use setContext instead */\n        set: function (newContext) {\n            context = newContext;\n            computeBytesCountThrottled(context);\n        },\n        getContext: function () { return deepClone(context); },\n        setContext: function (newContext) {\n            context = sanitize(newContext);\n            computeBytesCountThrottled(context);\n        },\n        setContextProperty: function (key, property) {\n            context[key] = sanitize(property);\n            computeBytesCountThrottled(context);\n        },\n        removeContextProperty: function (key) {\n            delete context[key];\n            computeBytesCountThrottled(context);\n        },\n        clearContext: function () {\n            context = {};\n            bytesCountCache = 0;\n        },\n    };\n}\n//# sourceMappingURL=contextManager.js.map","var BUFFER_LIMIT = 500;\nvar BoundedBuffer = /** @class */ (function () {\n    function BoundedBuffer() {\n        this.buffer = [];\n    }\n    BoundedBuffer.prototype.add = function (callback) {\n        var length = this.buffer.push(callback);\n        if (length > BUFFER_LIMIT) {\n            this.buffer.splice(0, 1);\n        }\n    };\n    BoundedBuffer.prototype.drain = function () {\n        this.buffer.forEach(function (callback) { return callback(); });\n        this.buffer.length = 0;\n    };\n    return BoundedBuffer;\n}());\nexport { BoundedBuffer };\n//# sourceMappingURL=boundedBuffer.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}\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}\nexport function resetNavigationStart() {\n    navigationStart = undefined;\n}\n//# sourceMappingURL=timeUtils.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, generateUUID } from '../tools/utils/stringUtils';\nexport function setCookie(name, value, expireDelay, options) {\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    document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure);\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\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","/**\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}\nexport function findCommaSeparatedValue(rawString, name) {\n    var regex = new RegExp(\"(?:^|;)\\\\s*\".concat(name, \"\\\\s*=\\\\s*([^;]+)\"));\n    var matches = regex.exec(rawString);\n    return matches ? matches[1] : undefined;\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 { getCookie } 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 || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    var value = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","import { endsWith } 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        getAllowedWebViewHosts: function () {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send: function (eventType, event) {\n            eventBridgeGlobal.send(JSON.stringify({ eventType: eventType, event: event }));\n        },\n    };\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 { startsWith } from '../../tools/utils/polyfills';\nvar UNKNOWN_FUNCTION = '?';\n/**\n * Computes a stack trace for an exception.\n */\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}\n//# sourceMappingURL=computeStackTrace.js.map","import { computeStackTrace } from '../tracekit';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { noop } from '../../tools/utils/functionUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\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 = originalError instanceof Error;\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 === null || stackTrace === void 0 ? void 0 : stackTrace.name;\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 originalError instanceof Error && 'dd_fingerprint' in originalError\n        ? String(originalError.dd_fingerprint)\n        : undefined;\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 getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function formatErrorMessage(stack) {\n    return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n/**\n Creates a stacktrace without SDK internal frames.\n \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 (e) {\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 flattenErrorCauses(error, parentSource) {\n    var currentError = error;\n    var causes = [];\n    while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && 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\n// eslint-disable-next-line no-restricted-syntax\nexport var ExperimentalFeature;\n(function (ExperimentalFeature) {\n    ExperimentalFeature[\"PAGEHIDE\"] = \"pagehide\";\n    ExperimentalFeature[\"FEATURE_FLAGS\"] = \"feature_flags\";\n    ExperimentalFeature[\"RESOURCE_PAGE_STATES\"] = \"resource_page_states\";\n    ExperimentalFeature[\"PAGE_STATES\"] = \"page_states\";\n    ExperimentalFeature[\"COLLECT_FLUSH_REASON\"] = \"collect_flush_reason\";\n    ExperimentalFeature[\"NO_RESOURCE_DURATION_FROZEN_STATE\"] = \"no_resource_duration_frozen_state\";\n    ExperimentalFeature[\"SCROLLMAP\"] = \"scrollmap\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nvar enabledExperimentalFeatures = new Set();\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","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}\n//# sourceMappingURL=user.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","var 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        if (!this.observers.length && this.onFirstSubscribe) {\n            this.onLastUnsubscribe = this.onFirstSubscribe() || undefined;\n        }\n        this.observers.push(f);\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    var globalObservable = new Observable(function () {\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    return globalObservable;\n}\n//# sourceMappingURL=observable.js.map","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\n//# sourceMappingURL=sessionConstants.js.map","export var SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants';\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport function isSessionInExpiredState(session) {\n    return isEmptyObject(session);\n}\nexport function expandSessionState(session) {\n    session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n    return objectEntries(session)\n        .map(function (_a) {\n        var key = _a[0], value = _a[1];\n        return \"\".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                session[key] = value;\n            }\n        });\n    }\n    return session;\n}\nfunction isValidSessionString(sessionString) {\n    return (!!sessionString &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\n//# sourceMappingURL=sessionState.js.map","import { getCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionInExpiredState } 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 = getCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        var oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME);\n        var oldRumType = getCookie(OLD_RUM_COOKIE_NAME);\n        var oldLogsType = getCookie(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 (!isSessionInExpiredState(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { getCurrentSite, areCookiesAuthorized, deleteCookie, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_EXPIRATION_DELAY } from '../sessionConstants';\nimport { toSessionString, toSessionState } 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        persistSession: persistSessionCookie(cookieOptions),\n        retrieveSession: retrieveSessionCookie,\n        clearSession: deleteSessionCookie(cookieOptions),\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 retrieveSessionCookie() {\n    var sessionString = getCookie(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction deleteSessionCookie(options) {\n    return function () {\n        deleteCookie(SESSION_STORE_KEY, options);\n    };\n}\nexport function buildCookieOptions(initConfiguration) {\n    var cookieOptions = {};\n    cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { toSessionString, toSessionState } 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 (e) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy() {\n    return {\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        clearSession: clearSessionFromLocalStorage,\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 clearSessionFromLocalStorage() {\n    localStorage.removeItem(SESSION_STORE_KEY);\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { isChromium } from '../../tools/utils/browserDetection';\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 retrieveSession = sessionStoreStrategy.retrieveSession, persistSession = sessionStoreStrategy.persistSession, clearSession = sessionStoreStrategy.clearSession;\n    var lockEnabled = isLockEnabled();\n    if (!ongoingOperations) {\n        ongoingOperations = operations;\n    }\n    if (operations !== ongoingOperations) {\n        bufferedOperations.push(operations);\n        return;\n    }\n    if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {\n        next(sessionStoreStrategy);\n        return;\n    }\n    var currentLock;\n    var currentSession = retrieveSession();\n    if (lockEnabled) {\n        // if someone has lock, retry later\n        if (currentSession.lock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n        // acquire lock\n        currentLock = generateUUID();\n        currentSession.lock = currentLock;\n        persistSession(currentSession);\n        // if lock is not acquired, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    var processedSession = operations.process(currentSession);\n    if (lockEnabled) {\n        // if lock corrupted after process, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    if (processedSession) {\n        if (isSessionInExpiredState(processedSession)) {\n            clearSession();\n        }\n        else {\n            expandSessionState(processedSession);\n            persistSession(processedSession);\n        }\n    }\n    if (lockEnabled) {\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            currentSession = retrieveSession();\n            if (currentSession.lock !== currentLock) {\n                retryLater(operations, sessionStoreStrategy, numberOfRetries);\n                return;\n            }\n            delete currentSession.lock;\n            persistSession(currentSession);\n            processedSession = currentSession;\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 || currentSession);\n    next(sessionStoreStrategy);\n}\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 */\nexport var isLockEnabled = function () { return isChromium(); };\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","export function isIE() {\n    return Boolean(document.documentMode);\n}\nexport function isChromium() {\n    return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);\n}\n//# sourceMappingURL=browserDetection.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 { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\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 sessionStoreStrategy = sessionStoreStrategyType.type === 'Cookie'\n        ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy();\n    var clearSession = sessionStoreStrategy.clearSession, retrieveSession = sessionStoreStrategy.retrieveSession;\n    var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n    var sessionCache = retrieveActiveSession();\n    function expandOrRenewSession() {\n        var isTracked;\n        processSessionStoreOperations({\n            process: function (sessionState) {\n                var synchronizedSession = synchronizeSession(sessionState);\n                isTracked = expandOrRenewSessionState(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (sessionState) {\n                if (isTracked && !hasSessionInCache()) {\n                    renewSessionInCache(sessionState);\n                }\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\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) { return (!isActiveSession(sessionState) ? {} : undefined); },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    function synchronizeSession(sessionState) {\n        if (!isActiveSession(sessionState)) {\n            sessionState = {};\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(sessionState)) {\n                expireSessionInCache();\n            }\n            else {\n                sessionCache = sessionState;\n            }\n        }\n        return sessionState;\n    }\n    function expandOrRenewSessionState(sessionState) {\n        var _a = computeSessionState(sessionState[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\n        sessionState[productKey] = trackingType;\n        if (isTracked && !sessionState.id) {\n            sessionState.id = generateUUID();\n            sessionState.created = String(dateNow());\n        }\n        return isTracked;\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 = {};\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function retrieveActiveSession() {\n        var session = retrieveSession();\n        if (isActiveSession(session)) {\n            return session;\n        }\n        return {};\n    }\n    function 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    }\n    return {\n        expandOrRenewSession: throttle(expandOrRenewSession, STORAGE_POLL_DELAY).throttled,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        expire: function () {\n            clearSession();\n            synchronizeSession({});\n        },\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { jsonStringify } from '../serialisation/jsonStringify';\nexport function normalizeUrl(url) {\n    return buildUrl(url, getLocationOrigin()).href;\n}\nexport function isValidUrl(url) {\n    try {\n        return !!buildUrl(url);\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getOrigin(url) {\n    return getLinkElementOrigin(buildUrl(url));\n}\nexport function getPathName(url) {\n    var pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function getSearch(url) {\n    return buildUrl(url).search;\n}\nexport function getHash(url) {\n    return buildUrl(url).hash;\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}\nexport function getLocationOrigin() {\n    return getLinkElementOrigin(window.location);\n}\n/**\n * Fallback\n * On IE HTMLAnchorElement origin is not supported: https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n * On Firefox window.location.origin is \"null\" for file: URIs: https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n */\nexport function getLinkElementOrigin(element) {\n    if (element.origin && element.origin !== 'null') {\n        return element.origin;\n    }\n    var sanitizedHost = element.host.replace(/(:80|:443)$/, '');\n    return \"\".concat(element.protocol, \"//\").concat(sanitizedHost);\n}\n//# sourceMappingURL=urlPolyfill.js.map","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport var INTAKE_SITE_AP1 = 'ap1.datadoghq.com';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';\n//# sourceMappingURL=intakeSites.js.map","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites';\nexport var ENDPOINTS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'session-replay',\n};\nvar INTAKE_TRACKS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'replay',\n};\nexport function createEndpointBuilder(initConfiguration, endpointType, configurationTags) {\n    var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType);\n    return {\n        build: function (api, flushReason, retry) {\n            var parameters = buildEndpointParameters(initConfiguration, endpointType, configurationTags, api, flushReason, retry);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\n        endpointType: endpointType,\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, endpointType) {\n    var path = \"/api/v2/\".concat(INTAKE_TRACKS[endpointType]);\n    var proxy = initConfiguration.proxy, proxyUrl = initConfiguration.proxyUrl;\n    if (proxy) {\n        var normalizedProxyUrl_1 = normalizeUrl(proxy);\n        return function (parameters) { return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters))); };\n    }\n    var host = buildEndpointHost(initConfiguration, endpointType);\n    if (proxy === undefined && proxyUrl) {\n        // TODO: remove this in a future major.\n        var normalizedProxyUrl_2 = normalizeUrl(proxyUrl);\n        return function (parameters) {\n            return \"\".concat(normalizedProxyUrl_2, \"?ddforward=\").concat(encodeURIComponent(\"https://\".concat(host).concat(path, \"?\").concat(parameters)));\n        };\n    }\n    return function (parameters) { return \"https://\".concat(host).concat(path, \"?\").concat(parameters); };\n}\nfunction buildEndpointHost(initConfiguration, endpointType) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US1 : _a, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\n    if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n        return \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n    }\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    var subdomain = site !== INTAKE_SITE_AP1 ? \"\".concat(ENDPOINTS[endpointType], \".\") : '';\n    return \"\".concat(subdomain, \"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, endpointType, configurationTags, api, flushReason, retry) {\n    var clientToken = _a.clientToken, internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n    var tags = [\"sdk_version:\".concat(\"4.45.0\"), \"api:\".concat(api)].concat(configurationTags);\n    if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {\n        tags.push(\"flush_reason:\".concat(flushReason));\n    }\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(\"4.45.0\")),\n        'dd-evp-origin=browser',\n        \"dd-request-id=\".concat(generateUUID()),\n    ];\n    if (endpointType === '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 { 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}\nvar FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/;\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 || FORBIDDEN_CHARACTERS.test(rawValue)) {\n        display.warn(\"\".concat(key, \" value doesn't meet tag requirements and will be sanitized\"));\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}\n//# sourceMappingURL=tags.js.map","import { objectValues, assign } from '../../tools/utils/polyfills';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1 } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeUrlPrefixes = objectValues(endpointBuilders).map(function (builder) { return builder.urlPrefix; });\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeUrlPrefixes.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n        site: initConfiguration.site || INTAKE_SITE_US1,\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, 'sessionReplay', tags),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, 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    intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.urlPrefix; }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { ExperimentalFeature, addExperimentalFeatures } from '../../tools/experimentalFeatures';\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 { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n};\nexport function validateAndBuildConfiguration(initConfiguration) {\n    var _a, _b, _c;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    var sessionSampleRate = (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.sampleRate;\n    if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {\n        display.error('Session Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n        display.error('Telemetry Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetryConfigurationSampleRate !== undefined &&\n        !isPercentage(initConfiguration.telemetryConfigurationSampleRate)) {\n        display.error('Telemetry Configuration Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // Set the experimental feature flags as early as possible, so we can use them in most places\n    if (Array.isArray(initConfiguration.enableExperimentalFeatures)) {\n        addExperimentalFeatures(initConfiguration.enableExperimentalFeatures.filter(function (flag) {\n            return objectHasValue(ExperimentalFeature, flag);\n        }));\n    }\n    return assign({\n        beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n        sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),\n        sessionSampleRate: sessionSampleRate !== null && sessionSampleRate !== void 0 ? sessionSampleRate : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\n        service: initConfiguration.service,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\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    var _a, _b;\n    var proxy = (_a = initConfiguration.proxy) !== null && _a !== void 0 ? _a : initConfiguration.proxyUrl;\n    return {\n        session_sample_rate: (_b = initConfiguration.sessionSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.sampleRate,\n        telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n        use_before_send: !!initConfiguration.beforeSend,\n        use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,\n        use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n        use_proxy: proxy !== undefined ? !!proxy : undefined,\n        silent_multiple_init: initConfiguration.silentMultipleInit,\n        track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n        track_resources: initConfiguration.trackResources,\n        track_long_task: initConfiguration.trackLongTasks,\n        allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,\n    };\n}\n//# sourceMappingURL=configuration.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","import { objectEntries, shallowClone, performDraw, isNumber, assign, find, getType, isMatchOption, matchList, } from '@datadog/browser-core';\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    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    context.traceSampled = !isNumber(configuration.traceSampleRate) || performDraw(configuration.traceSampleRate);\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes));\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\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.toDecimalString(),\n                    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n                    'x-datadog-trace-id': traceId.toDecimalString(),\n                });\n                break;\n            }\n            // https://www.w3.org/TR/trace-context/\n            case 'tracecontext': {\n                assign(tracingHeaders, {\n                    traceparent: \"00-0000000000000000\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-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(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            case 'b3multi': {\n                assign(tracingHeaders, {\n                    'X-B3-TraceId': traceId.toPaddedHexadecimalString(),\n                    'X-B3-SpanId': spanId.toPaddedHexadecimalString(),\n                    'X-B3-Sampled': traceSampled ? '1' : '0',\n                });\n                break;\n            }\n        }\n    });\n    return tracingHeaders;\n}\n/* eslint-disable no-bitwise */\nvar TraceIdentifier = /** @class */ (function () {\n    function TraceIdentifier() {\n        this.buffer = new Uint8Array(8);\n        getCrypto().getRandomValues(this.buffer);\n        this.buffer[0] = this.buffer[0] & 0x7f; // force 63-bit\n    }\n    TraceIdentifier.prototype.toString = function (radix) {\n        var high = this.readInt32(0);\n        var low = this.readInt32(4);\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     * Format used everywhere except the trace intake\n     */\n    TraceIdentifier.prototype.toDecimalString = function () {\n        return this.toString(10);\n    };\n    /**\n     * Format used by OTel headers\n     */\n    TraceIdentifier.prototype.toPaddedHexadecimalString = function () {\n        var traceId = this.toString(16);\n        return Array(17 - traceId.length).join('0') + traceId;\n    };\n    TraceIdentifier.prototype.readInt32 = function (offset) {\n        return (this.buffer[offset] * 16777216 +\n            (this.buffer[offset + 1] << 16) +\n            (this.buffer[offset + 2] << 8) +\n            this.buffer[offset + 3]);\n    };\n    return TraceIdentifier;\n}());\nexport { TraceIdentifier };\n/* eslint-enable no-bitwise */\n//# sourceMappingURL=tracer.js.map","import { getType, arrayFrom, getOrigin, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nimport { isTracingOption } from './tracing/tracer';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e, _f;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.sessionReplaySampleRate !== undefined &&\n        !isPercentage(initConfiguration.sessionReplaySampleRate)) {\n        display.error('Session Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // TODO remove fallback in next major\n    var premiumSampleRate = (_a = initConfiguration.premiumSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.replaySampleRate;\n    if (premiumSampleRate !== undefined && initConfiguration.sessionReplaySampleRate !== undefined) {\n        display.warn('Ignoring Premium Sample Rate because Session Replay Sample Rate is set');\n        premiumSampleRate = undefined;\n    }\n    if (premiumSampleRate !== undefined && !isPercentage(premiumSampleRate)) {\n        display.error('Premium Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    var traceSampleRate = (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.tracingSampleRate;\n    if (traceSampleRate !== undefined && !isPercentage(traceSampleRate)) {\n        display.error('Trace Sample Rate should be a number between 0 and 100');\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 trackUserInteractions = !!((_c = initConfiguration.trackUserInteractions) !== null && _c !== void 0 ? _c : initConfiguration.trackInteractions);\n    var trackFrustrations = !!initConfiguration.trackFrustrations;\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: (_e = (_d = initConfiguration.sessionReplaySampleRate) !== null && _d !== void 0 ? _d : premiumSampleRate) !== null && _e !== void 0 ? _e : 100,\n        oldPlansBehavior: initConfiguration.sessionReplaySampleRate === undefined,\n        traceSampleRate: traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_f = initConfiguration.excludedActivityUrls) !== null && _f !== void 0 ? _f : [],\n        trackUserInteractions: trackUserInteractions || trackFrustrations,\n        trackFrustrations: trackFrustrations,\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_USER_INPUT,\n        customerDataTelemetrySampleRate: 1,\n    }, baseConfiguration);\n}\n/**\n * Handles allowedTracingUrls and processes legacy allowedTracingOrigins\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    // Advise about parameters precedence.\n    if (initConfiguration.allowedTracingUrls !== undefined && initConfiguration.allowedTracingOrigins !== undefined) {\n        display.warn('Both allowedTracingUrls and allowedTracingOrigins (deprecated) have been defined. The parameter allowedTracingUrls will override allowedTracingOrigins.');\n    }\n    // Handle allowedTracingUrls first\n    if (initConfiguration.allowedTracingUrls !== undefined) {\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_1 = [];\n        initConfiguration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                tracingOptions_1.push({ match: option, propagatorTypes: ['datadog'] });\n            }\n            else if (isTracingOption(option)) {\n                tracingOptions_1.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_1;\n    }\n    // Handle conversion of allowedTracingOrigins to allowedTracingUrls\n    if (initConfiguration.allowedTracingOrigins !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingOrigins)) {\n            display.error('Allowed Tracing Origins should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingOrigins.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service needs to be configured when tracing is enabled');\n            return;\n        }\n        var tracingOptions_2 = [];\n        initConfiguration.allowedTracingOrigins.forEach(function (legacyMatchOption) {\n            var tracingOption = convertLegacyMatchOptionToTracingOption(legacyMatchOption);\n            if (tracingOption) {\n                tracingOptions_2.push(tracingOption);\n            }\n        });\n        return tracingOptions_2;\n    }\n    return [];\n}\n/**\n * Converts parameters from the deprecated allowedTracingOrigins\n * to allowedTracingUrls. Handles the change from origin to full URLs.\n */\nfunction convertLegacyMatchOptionToTracingOption(item) {\n    var match;\n    if (typeof item === 'string') {\n        match = item;\n    }\n    else if (item instanceof RegExp) {\n        match = function (url) { return item.test(getOrigin(url)); };\n    }\n    else if (typeof item === 'function') {\n        match = function (url) { return item(getOrigin(url)); };\n    }\n    if (match === undefined) {\n        display.warn('Allowed Tracing Origins parameters should be a string, RegExp or function. Ignoring parameter', item);\n        return undefined;\n    }\n    return { match: match, propagatorTypes: ['datadog'] };\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls,\n * and assumes 'datadog' has been selected when using allowedTracingOrigins\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                usedTracingPropagators.add('datadog');\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    if (Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0) {\n        usedTracingPropagators.add('datadog');\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a, _b;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\n        premium_sample_rate: configuration.premiumSampleRate,\n        replay_sample_rate: configuration.replaySampleRate,\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        trace_sample_rate: (_a = configuration.traceSampleRate) !== null && _a !== void 0 ? _a : configuration.tracingSampleRate,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_origins: Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0,\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        use_excluded_activity_urls: Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\n        track_frustrations: configuration.trackFrustrations,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: (_b = configuration.trackUserInteractions) !== null && _b !== void 0 ? _b : configuration.trackInteractions,\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.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","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 var TelemetryType = {\n    log: 'log',\n    configuration: 'configuration',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/error';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { computeStackTrace } from '../tracekit';\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 { 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];\nvar telemetryConfiguration = { maxEventsPerPage: 0, sentEventCount: 0, telemetryEnabled: false, telemetryConfigurationEnabled: false };\nvar onRawTelemetryEventCollected;\nexport function startTelemetry(telemetryService, configuration) {\n    var contextProvider;\n    var observable = new Observable();\n    telemetryConfiguration.telemetryEnabled =\n        !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n    telemetryConfiguration.telemetryConfigurationEnabled =\n        telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate);\n    onRawTelemetryEventCollected = function (rawEvent) {\n        if (telemetryConfiguration.telemetryEnabled) {\n            var event_1 = toTelemetryEvent(telemetryService, rawEvent);\n            observable.notify(event_1);\n            sendToExtension('telemetry', event_1);\n        }\n    };\n    startMonitorErrorCollection(addTelemetryError);\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: configuration.maxTelemetryEventsPerPage,\n        sentEventCount: 0,\n    });\n    function toTelemetryEvent(telemetryService, event) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: telemetryService,\n            version: \"4.45.0\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: event,\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: telemetryConfiguration.telemetryEnabled,\n    };\n}\nexport function startFakeTelemetry() {\n    var events = [];\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: Infinity,\n        sentEventCount: 0,\n    });\n    onRawTelemetryEventCollected = function (event) {\n        events.push(event);\n    };\n    return events;\n}\nexport function resetTelemetry() {\n    onRawTelemetryEventCollected = undefined;\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    addTelemetry(assign({\n        type: TelemetryType.log,\n        message: message,\n        status: \"debug\" /* StatusType.debug */,\n    }, context));\n}\nexport function addTelemetryError(e) {\n    addTelemetry(assign({\n        type: TelemetryType.log,\n        status: \"error\" /* StatusType.error */,\n    }, formatError(e)));\n}\nexport function addTelemetryConfiguration(configuration) {\n    if (telemetryConfiguration.telemetryConfigurationEnabled) {\n        addTelemetry({\n            type: TelemetryType.configuration,\n            configuration: configuration,\n        });\n    }\n}\nfunction addTelemetry(event) {\n    if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {\n        telemetryConfiguration.sentEventCount += 1;\n        onRawTelemetryEventCollected(event);\n    }\n}\nexport function formatError(e) {\n    if (e instanceof Error) {\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 { 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(eventTarget, eventName, listener, options) {\n    return addEventListeners(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(eventTarget, eventNames, listener, _a) {\n    var _b = _a === void 0 ? {} : _a, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var wrappedListener = monitor(once\n        ? function (event) {\n            stop();\n            listener(event);\n        }\n        : listener);\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');\n    eventNames.forEach(function (eventName) { return add.call(eventTarget, eventName, wrappedListener, options); });\n    function stop() {\n        var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');\n        eventNames.forEach(function (eventName) { return remove.call(eventTarget, eventName, wrappedListener, options); });\n    }\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures';\nimport { Observable } from '../tools/observable';\nimport { objectValues, includes } from '../tools/utils/polyfills';\nimport { noop } from '../tools/utils/functionUtils';\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() {\n    var observable = new Observable(function () {\n        var pagehideEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGEHIDE);\n        var stopListeners = addEventListeners(window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */, \"pagehide\" /* DOM_EVENT.PAGE_HIDE */], function (event) {\n            if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ && pagehideEnabled) {\n                /**\n                 * Only event that detect page unload events while being compatible with the back/forward cache (bfcache)\n                 */\n                observable.notify({ reason: PageExitReason.PAGEHIDE });\n            }\n            else 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 = noop;\n        if (!pagehideEnabled) {\n            stopBeforeUnloadListener = addEventListener(window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, function () {\n                observable.notify({ reason: PageExitReason.UNLOADING });\n            }).stop;\n        }\n        return function () {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n    return observable;\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    var observable = new Observable(function () {\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    return observable;\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","import { addEventListener } from './addEventListener';\nexport function runOnReadyState(expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n        addEventListener(window, eventName, callback, { once: true });\n    }\n}\n//# sourceMappingURL=runOnReadyState.js.map","import { assign, addTelemetryDebug, elapsed, getPathName, includes, isValidUrl, toServerDuration, } 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 computeResourceKind(timing) {\n    var url = timing.name;\n    if (!isValidUrl(url)) {\n        addTelemetryDebug(\"Failed to construct URL for \\\"\".concat(timing.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(timing.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 isRequestKind(timing) {\n    return timing.initiatorType === 'xmlhttprequest' || timing.initiatorType === 'fetch';\n}\nexport function computePerformanceResourceDuration(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 computePerformanceResourceDetails(entry) {\n    var validEntry = toValidEntry(entry);\n    if (!validEntry) {\n        return undefined;\n    }\n    var startTime = validEntry.startTime, fetchStart = validEntry.fetchStart, redirectStart = validEntry.redirectStart, redirectEnd = validEntry.redirectEnd, domainLookupStart = validEntry.domainLookupStart, domainLookupEnd = validEntry.domainLookupEnd, connectStart = validEntry.connectStart, secureConnectionStart = validEntry.secureConnectionStart, connectEnd = validEntry.connectEnd, requestStart = validEntry.requestStart, responseStart = validEntry.responseStart, responseEnd = validEntry.responseEnd;\n    var details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a connection occurred\n    if (connectEnd !== fetchStart) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (areInOrder(connectStart, secureConnectionStart, connectEnd)) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (domainLookupEnd !== fetchStart) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    if (hasRedirection(entry)) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\nexport function toValidEntry(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    if (!areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd)) {\n        return undefined;\n    }\n    if (!hasRedirection(entry)) {\n        return entry;\n    }\n    var redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd;\n    // Firefox doesn't provide redirect timings on cross origin requests.\n    // Provide a default for those.\n    if (redirectStart < entry.startTime) {\n        redirectStart = entry.startTime;\n    }\n    if (redirectEnd < entry.startTime) {\n        redirectEnd = entry.fetchStart;\n    }\n    // Make sure redirect timings are in order\n    if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {\n        return undefined;\n    }\n    return assign({}, entry, {\n        redirectEnd: redirectEnd,\n        redirectStart: redirectStart,\n    });\n}\nfunction hasRedirection(entry) {\n    // The only time fetchStart is different than startTime is if a redirection occurred.\n    return entry.fetchStart !== entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    return {\n        duration: toServerDuration(elapsed(start, end)),\n        start: toServerDuration(elapsed(origin, start)),\n    };\n}\nexport function computeSize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        return entry.decodedBodySize;\n    }\n    return undefined;\n}\nexport function isAllowedRequestUrl(configuration, url) {\n    return url && !configuration.isIntakeUrl(url);\n}\n//# sourceMappingURL=resourceUtils.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 getChildNodes(node) {\n    return isNodeShadowHost(node) ? node.shadowRoot.childNodes : node.childNodes;\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 { 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 { dateNow, assign, addEventListeners, getRelativeTime, isNumber, monitor, setTimeout, relativeNow, runOnReadyState, addEventListener, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/rumEventsCollection/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\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}\nexport function startPerformanceCollection(lifeCycle, configuration) {\n    retrieveInitialDocumentResourceTiming(function (timing) {\n        handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n    });\n    if (supportPerformanceObject()) {\n        var performanceEntries_1 = performance.getEntries();\n        // Because the performance entry list can be quite large\n        // delay the computation to prevent the SDK from blocking the main thread on init\n        setTimeout(function () { return handleRumPerformanceEntries(lifeCycle, configuration, performanceEntries_1); });\n    }\n    if (window.PerformanceObserver) {\n        var handlePerformanceEntryList_1 = monitor(function (entries) {\n            return handleRumPerformanceEntries(lifeCycle, configuration, entries.getEntries());\n        });\n        var mainEntries = ['resource', 'navigation', 'longtask', 'paint'];\n        var experimentalEntries = ['largest-contentful-paint', 'first-input', 'layout-shift'];\n        try {\n            // Experimental entries are not retrieved by performance.getEntries()\n            // use a single PerformanceObserver with buffered flag by type\n            // to get values that could happen before SDK init\n            experimentalEntries.forEach(function (type) {\n                var observer = new PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({ type: type, buffered: true });\n            });\n        }\n        catch (e) {\n            // Some old browser versions (ex: chrome 67) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to PerformanceObserver with entryTypes\n            mainEntries.push.apply(mainEntries, experimentalEntries);\n        }\n        var mainObserver = new PerformanceObserver(handlePerformanceEntryList_1);\n        mainObserver.observe({ entryTypes: mainEntries });\n        if (supportPerformanceObject() && 'addEventListener' in performance) {\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n            addEventListener(performance, 'resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            });\n        }\n    }\n    if (!supportPerformanceTimingEvent('navigation')) {\n        retrieveNavigationTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent('first-input')) {\n        retrieveFirstInputTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n}\nexport function retrieveInitialDocumentResourceTiming(callback) {\n    runOnReadyState('interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: 'resource',\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n        };\n        if (supportPerformanceTimingEvent('navigation') && performance.getEntriesByType('navigation').length > 0) {\n            var navigationEntry = performance.getEntriesByType('navigation')[0];\n            timing = assign(navigationEntry.toJSON(), forcedAttributes);\n        }\n        else {\n            var relativePerformanceTiming = computeRelativePerformanceTiming();\n            timing = assign(relativePerformanceTiming, {\n                decodedBodySize: 0,\n                duration: relativePerformanceTiming.responseEnd,\n                name: window.location.href,\n                startTime: 0,\n            }, forcedAttributes);\n        }\n        callback(timing);\n    });\n}\nfunction retrieveNavigationTiming(callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: 'navigation',\n        }));\n    }\n    runOnReadyState('complete', function () {\n        // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        setTimeout(sendFakeTiming);\n    });\n}\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nfunction retrieveFirstInputTiming(callback) {\n    var startTimeStamp = dateNow();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(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            startTime: evt.timeStamp,\n        };\n        if (evt.type === \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true }).stop;\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(timing) {\n        addEventListeners(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}\nfunction computeRelativePerformanceTiming() {\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}\nfunction handleRumPerformanceEntries(lifeCycle, configuration, entries) {\n    var rumPerformanceEntries = entries.filter(function (entry) {\n        return entry.entryType === 'resource' ||\n            entry.entryType === 'navigation' ||\n            entry.entryType === 'paint' ||\n            entry.entryType === 'longtask' ||\n            entry.entryType === 'largest-contentful-paint' ||\n            entry.entryType === 'first-input' ||\n            entry.entryType === 'layout-shift';\n    });\n    var rumAllowedPerformanceEntries = rumPerformanceEntries.filter(function (entry) { return !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry); });\n    if (rumAllowedPerformanceEntries.length) {\n        lifeCycle.notify(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, rumAllowedPerformanceEntries);\n    }\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.entryType === 'navigation' && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === 'resource' && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.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 { Observable, throttle, addEventListener } from '@datadog/browser-core';\nvar viewportObservable;\nexport function initViewportObservable() {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable();\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable() {\n    var observable = new Observable(function () {\n        var updateDimension = throttle(function () {\n            observable.notify(getViewportDimension());\n        }, 200).throttled;\n        return addEventListener(window, \"resize\" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true }).stop;\n    });\n    return observable;\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 { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nvar viewport;\nvar stopListeners;\nexport function getDisplayContext() {\n    if (!viewport) {\n        viewport = getViewportDimension();\n        stopListeners = initViewportObservable().subscribe(function (viewportDimension) {\n            viewport = viewportDimension;\n        }).unsubscribe;\n    }\n    return {\n        viewport: viewport,\n    };\n}\nexport function resetDisplayContext() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    viewport = undefined;\n}\n//# sourceMappingURL=displayContext.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, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { getCiTestContext } from './contexts/ciTestContext';\nimport { getDisplayContext } from './contexts/displayContext';\nimport { limitModification } from './limitModification';\nvar VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nvar USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nvar modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, buildCommonContext, reportError) {\n    var _a, _b;\n    modifiableFieldPathsByEvent = (_a = {},\n        _a[\"view\" /* RumEventType.VIEW */] = 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),\n        _a[\"resource\" /* RumEventType.RESOURCE */] = assign({\n            'resource.url': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"action\" /* RumEventType.ACTION */] = assign({\n            'action.target.name': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"long_task\" /* RumEventType.LONG_TASK */] = 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);\n    var syntheticsContext = getSyntheticsContext();\n    var ciTestContext = getCiTestContext();\n    lifeCycle.subscribe(10 /* 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 viewContext = viewContexts.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (session && viewContext && urlContext) {\n            var commonContext = savedCommonContext || buildCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.plan,\n                    },\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() ? \"4.45.0\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: viewContext.service || configuration.service,\n                version: viewContext.version || configuration.version,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SessionType.SYNTHETICS */ : ciTestContext ? \"ci_test\" /* SessionType.CI_TEST */ : \"user\" /* SessionType.USER */,\n                },\n                view: {\n                    id: viewContext.id,\n                    name: viewContext.name,\n                    url: urlContext.url,\n                    referrer: urlContext.referrer,\n                },\n                action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n                display: getDisplayContext(),\n            };\n            var serverRumEvent = combine(rumContext, rawRumEvent);\n            serverRumEvent.context = combine(commonContext.context, customerContext);\n            if (!('has_replay' in serverRumEvent.session)) {\n                ;\n                serverRumEvent.session.has_replay = commonContext.hasReplay;\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(11 /* 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","export function getCiTestContext() {\n    var _a;\n    var testExecutionId = (_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId');\n    if (typeof testExecutionId === 'string') {\n        return {\n            test_execution_id: testExecutionId,\n        };\n    }\n}\n//# sourceMappingURL=ciTestContext.js.map","var 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 { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, relativeNow, 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() {\n    if (!xhrObservable) {\n        xhrObservable = createXhrObservable();\n    }\n    return xhrObservable;\n}\nfunction createXhrObservable() {\n    var observable = new Observable(function () {\n        var stopInstrumentingStart = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {\n            before: openXhr,\n        }).stop;\n        var stopInstrumentingSend = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {\n            before: function () {\n                sendXhr.call(this, observable);\n            },\n        }).stop;\n        var stopInstrumentingAbort = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {\n            before: abortXhr,\n        }).stop;\n        return function () {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n    return observable;\n}\nfunction openXhr(method, url) {\n    xhrContexts.set(this, {\n        state: 'open',\n        method: method,\n        url: normalizeUrl(String(url)),\n    });\n}\nfunction sendXhr(observable) {\n    var _this = this;\n    var context = xhrContexts.get(this);\n    if (!context) {\n        return;\n    }\n    var startContext = context;\n    startContext.state = 'start';\n    startContext.startTime = relativeNow();\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = this;\n    var hasBeenReported = false;\n    var stopInstrumentingOnReadyStateChange = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {\n        before: function () {\n            if (this.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 a onreadystatechange event, so the status becomes '0'\n                // before the request is collected.\n                onEnd();\n            }\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 = _this.status;\n        observable.notify(shallowClone(completeContext));\n    };\n    var unsubscribeLoadEndListener = addEventListener(this, 'loadend', onEnd).stop;\n    observable.notify(startContext);\n}\nfunction abortXhr() {\n    var context = xhrContexts.get(this);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","import { setInterval, clearInterval } from './timer';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of values spans. This whole class assumes that values are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ValueHistory = /** @class */ (function () {\n    function ValueHistory(expireDelay, maxEntries) {\n        var _this = this;\n        this.expireDelay = expireDelay;\n        this.maxEntries = maxEntries;\n        this.entries = [];\n        this.clearOldValuesInterval = setInterval(function () { return _this.clearOldValues(); }, CLEAR_OLD_VALUES_INTERVAL);\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    ValueHistory.prototype.add = function (value, startTime) {\n        var _this = this;\n        var entry = {\n            value: value,\n            startTime: startTime,\n            endTime: END_OF_TIMES,\n            remove: function () {\n                var index = _this.entries.indexOf(entry);\n                if (index >= 0) {\n                    _this.entries.splice(index, 1);\n                }\n            },\n            close: function (endTime) {\n                entry.endTime = endTime;\n            },\n        };\n        if (this.maxEntries && this.entries.length >= this.maxEntries) {\n            this.entries.pop();\n        }\n        this.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    ValueHistory.prototype.find = function (startTime) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {\n            var entry = _a[_i];\n            if (entry.startTime <= startTime) {\n                if (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    ValueHistory.prototype.closeActive = function (endTime) {\n        var latestEntry = this.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    ValueHistory.prototype.findAll = function (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 this.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    ValueHistory.prototype.reset = function () {\n        this.entries = [];\n    };\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    ValueHistory.prototype.stop = function () {\n        clearInterval(this.clearOldValuesInterval);\n    };\n    ValueHistory.prototype.clearOldValues = function () {\n        var oldTimeThreshold = relativeNow() - this.expireDelay;\n        while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n            this.entries.pop();\n        }\n    };\n    return ValueHistory;\n}());\nexport { ValueHistory };\n//# sourceMappingURL=valueHistory.js.map","import { SESSION_TIME_OUT_DELAY, ValueHistory } from '@datadog/browser-core';\nexport var VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewContexts(lifeCycle) {\n    var viewContextHistory = new ValueHistory(VIEW_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        viewContextHistory.add(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        viewContextHistory.reset();\n    });\n    function buildViewContext(view) {\n        return {\n            service: view.service,\n            version: view.version,\n            id: view.id,\n            name: view.name,\n            startClocks: view.startClocks,\n        };\n    }\n    return {\n        findView: function (startTime) { return viewContextHistory.find(startTime); },\n        stop: function () {\n            viewContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=viewContexts.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nexport function instrumentMethod(object, method, instrumentationFactory) {\n    var original = object[method];\n    var instrumentation = instrumentationFactory(original);\n    var instrumentationWrapper = function () {\n        if (typeof instrumentation !== 'function') {\n            return undefined;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return instrumentation.apply(this, arguments);\n    };\n    object[method] = instrumentationWrapper;\n    return {\n        stop: function () {\n            if (object[method] === instrumentationWrapper) {\n                object[method] = original;\n            }\n            else {\n                instrumentation = original;\n            }\n        },\n    };\n}\nexport function instrumentMethodAndCallOriginal(object, method, _a) {\n    var before = _a.before, after = _a.after;\n    return instrumentMethod(object, method, function (original) {\n        return function () {\n            var args = arguments;\n            var result;\n            if (before) {\n                callMonitored(before, this, args);\n            }\n            if (typeof original === 'function') {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n                result = original.apply(this, args);\n            }\n            if (after) {\n                callMonitored(after, this, args);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n            return result;\n        };\n    });\n}\nexport function instrumentSetter(object, property, after) {\n    var originalDescriptor = Object.getOwnPropertyDescriptor(object, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    var instrumentation = function (thisObject, value) {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(function () {\n            after(thisObject, value);\n        }, 0);\n    };\n    var instrumentationWrapper = function (value) {\n        originalDescriptor.set.call(this, value);\n        instrumentation(this, value);\n    };\n    Object.defineProperty(object, property, {\n        set: instrumentationWrapper,\n    });\n    return {\n        stop: function () {\n            var _a;\n            if (((_a = Object.getOwnPropertyDescriptor(object, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n                Object.defineProperty(object, property, originalDescriptor);\n            }\n            else {\n                instrumentation = noop;\n            }\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { callMonitored, monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\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}\nfunction createFetchObservable() {\n    var observable = new Observable(function () {\n        if (!window.fetch) {\n            return;\n        }\n        var stop = instrumentMethod(window, 'fetch', function (originalFetch) {\n            return function (input, init) {\n                var responsePromise;\n                var context = callMonitored(beforeSend, null, [observable, input, init]);\n                if (context) {\n                    responsePromise = originalFetch.call(this, context.input, context.init);\n                    callMonitored(afterSend, null, [observable, responsePromise, context]);\n                }\n                else {\n                    responsePromise = originalFetch.call(this, input, init);\n                }\n                return responsePromise;\n            };\n        }).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction beforeSend(observable, input, init) {\n    var method = (init && init.method) || (input instanceof Request && input.method) || '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    };\n    observable.notify(context);\n    return context;\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    var reportFetch = function (response) {\n        var context = startContext;\n        context.state = 'resolve';\n        if ('stack' in response || response instanceof Error) {\n            context.status = 0;\n            context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;\n            context.error = response;\n        }\n        else if ('status' in response) {\n            context.response = response;\n            context.responseType = response.type;\n            context.status = response.status;\n            context.isAborted = false;\n        }\n        observable.notify(context);\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './rumEventsCollection/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, configuration, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, 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(5 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(6 /* 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                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nexport function trackFetch(lifeCycle, configuration, tracer) {\n    var subscription = initFetchObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(5 /* 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(6 /* 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                    });\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","export function isServerError(status) {\n    return status >= 500;\n}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (e) {\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 { 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(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        if (event.type === 'view' || !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                eventCounts.resourceCount += 1;\n                callback();\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { instrumentMethodAndCallOriginal, matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout, } from '@datadog/browser-core';\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, configuration, pageActivityEndCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, 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, configuration) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (entry) { return entry.entryType === 'resource' && !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(5 /* 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(6 /* 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        var stopTrackingWindowOpen = trackWindowOpen(notifyPageActivity).stop;\n        return function () {\n            stopTrackingWindowOpen();\n            subscriptions.forEach(function (s) { return s.unsubscribe(); });\n        };\n        function notifyPageActivity() {\n            observable.notify({ isBusy: pendingRequestsCount > 0 });\n        }\n    });\n    return observable;\n}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction trackWindowOpen(callback) {\n    return instrumentMethodAndCallOriginal(window, 'open', { before: callback });\n}\n//# sourceMappingURL=waitPageActivityEnd.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 { safeTruncate, isIE, find } from '@datadog/browser-core';\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 function getActionNameFromElement(element, userProgrammaticAttribute) {\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, use strategies that are known to return good results. Those strategies will be used on\n    //   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    return (getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute)) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies) ||\n        '');\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 = element.parentElement;\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) {\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 getTextualContent(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 && getTextualContent(label, userProgrammaticAttribute);\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 input.value;\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    function (element, userProgrammaticAttribute) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getTextualContent(element, userProgrammaticAttribute);\n        }\n    },\n    function (element) { return element.getAttribute('aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return 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); })\n                .join(' ');\n        }\n    },\n    function (element) { return element.getAttribute('alt'); },\n    function (element) { return element.getAttribute('name'); },\n    function (element) { return element.getAttribute('title'); },\n    function (element) { return element.getAttribute('placeholder'); },\n    // SELECT first OPTION text\n    function (element, userProgrammaticAttribute) {\n        if ('options' in element && element.options.length > 0) {\n            return getTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nvar fallbackStrategies = [\n    function (element, userProgrammaticAttribute) { return getTextualContent(element, userProgrammaticAttribute); },\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) {\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 name_1 = strategy(element, userProgrammaticAttribute);\n            if (typeof name_1 === 'string') {\n                var trimmedName = name_1.trim();\n                if (trimmedName) {\n                    return truncate(normalizeWhitespace(trimmedName));\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".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 getTextualContent(element, userProgrammaticAttribute) {\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        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 } from '@datadog/browser-core';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './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    var targetElementSelector = '';\n    var element = targetElement;\n    while (element && element.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(element, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(element, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(element), targetElementSelector);\n        element = element.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if a 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. We might want to allow customers to\n    // provide their own `isGeneratedValue` at some point.\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    if (element.classList.length > 0) {\n        for (var i = 0; i < element.classList.length; i += 1) {\n            var className = element.classList[i];\n            if (isGeneratedValue(className)) {\n                continue;\n            }\n            return \"\".concat(element.tagName, \".\").concat(cssEscape(className));\n        }\n    }\n}\nfunction getTagNameSelector(element) {\n    return 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(element.tagName, \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = element.parentElement.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(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        var fullSelector = combineSelector(elementSelector, childSelector);\n        if (predicate(element, fullSelector)) {\n            return fullSelector;\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, selector) {\n    return element.ownerDocument.querySelectorAll(selector).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 > SELECTOR\" returns a single element.\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 SELECTOR\" returns a single element), regardless of whether the selector is a\n * direct descendent 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 */\nfunction isSelectorUniqueAmongSiblings(element, selector) {\n    return (element.parentElement.querySelectorAll(supportScopeSelector() ? combineSelector(':scope', selector) : selector)\n        .length === 1);\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//# sourceMappingURL=getSelectorFromElement.js.map","import { addEventListener } from '@datadog/browser-core';\nexport function listenActionEvents(_a) {\n    var onPointerDown = _a.onPointerDown, onPointerUp = _a.onPointerUp;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(window, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, function (event) {\n            if (isValidPointerEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: false,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(window, \"selectionchange\" /* DOM_EVENT.SELECTION_CHANGE */, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(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(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 { elementMatches, ONE_SECOND } from '@datadog/browser-core';\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; })) {\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) {\n        return false;\n    }\n    return !elementMatches(click.event.target, DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { includes, timeStampNow, Observable, assign, getRelativeTime, ONE_MINUTE, ValueHistory, generateUUID, clocksNow, ONE_SECOND, elapsed, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { getSelectorFromElement } from './getSelectorFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\n// Maximum duration for click actions\nexport var CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, configuration) {\n    var history = new ValueHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    var stopObservable = new Observable();\n    var currentClickChain;\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents({\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent);\n        },\n        onPointerUp: function (_a, startEvent, getUserActivity) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            return startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) {\n            return configuration.trackFrustrations ? history.findAll(startTime) : history.find(startTime);\n        },\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, history, pointerDownEvent) {\n    if (!configuration.trackFrustrations && history.find()) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any new\n        // action if another one is already occurring.\n        return;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, configuration.actionNameAttribute);\n    if (!configuration.trackFrustrations && !clickActionBase.name) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any action\n        // with a blank name\n        return;\n    }\n    var hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, 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, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    if (configuration.trackFrustrations) {\n        appendClickToClickChain(click);\n    }\n    var stopWaitPageActivityEnd = waitPageActivityEnd(lifeCycle, domMutationObservable, 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            // Validate or discard the click only if we don't track frustrations. It'll be done when\n            // the click chain is finalized.\n            if (!configuration.trackFrustrations) {\n                if (!pageActivityEndEvent.hadActivity) {\n                    // If we are not tracking frustrations, we should discard the click to keep backward\n                    // compatibility.\n                    click.discard();\n                }\n                else {\n                    click.validate();\n                }\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, actionNameAttribute) {\n    var rect = event.target.getBoundingClientRect();\n    return {\n        type: \"click\" /* ActionType.CLICK */,\n        target: {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector: getSelectorFromElement(event.target, actionNameAttribute),\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: getActionNameFromElement(event.target, actionNameAttribute),\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(1 /* 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 } from '@datadog/browser-core';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, configuration, pageStateHistory) {\n    lifeCycle.subscribe(1 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action, pageStateHistory));\n    });\n    var actionContexts = { findActionId: noop };\n    if (configuration.trackUserInteractions) {\n        actionContexts = trackClickActions(lifeCycle, domMutationObservable, configuration).actionContexts;\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(10 /* 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: 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                },\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.isInActivePageStateAt(action.startClocks.relative) },\n    }, autoActionProperties);\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: isAutoAction(action) ? { event: action.event, events: action.events } : {},\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* ActionType.CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","import { instrumentMethodAndCallOriginal } from '../../tools/instrumentMethod';\nimport { computeStackTrace } from './computeStackTrace';\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]*)$/;\n/**\n * Cross-browser collection of unhandled errors\n *\n * Supports:\n * - Firefox: full stack trace with line numbers, plus column number\n * on top frame; column number is not guaranteed\n * - Opera: full stack trace with line and column numbers\n * - Chrome: full stack trace with line and column numbers\n * - Safari: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n * - IE: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n * - IE5.5+ (only 8.0 tested)\n * - Firefox 0.9+ (only 3.5+ tested)\n * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n * Exceptions Have Stacktrace to be enabled in opera:config)\n * - Safari 3+ (only 4+ tested)\n * - Chrome 1+ (only 5+ tested)\n * - Konqueror 3.5+ (untested)\n *\n * Tries to catch all unhandled errors and report them to the\n * callback.\n *\n * Callbacks receive a StackTrace object as described in the\n * computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\nexport function startUnhandledErrorCollection(callback) {\n    var stopInstrumentingOnError = instrumentOnError(callback).stop;\n    var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(callback).stop;\n    return {\n        stop: function () {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        },\n    };\n}\n/**\n * Install a global onerror handler\n */\nfunction instrumentOnError(callback) {\n    return instrumentMethodAndCallOriginal(window, 'onerror', {\n        before: function (messageObj, url, line, column, errorObj) {\n            var stackTrace;\n            if (errorObj instanceof Error) {\n                stackTrace = computeStackTrace(errorObj);\n            }\n            else {\n                var stack = [{ url: url, column: column, line: line }];\n                var _a = tryToParseMessage(messageObj), name_1 = _a.name, message = _a.message;\n                stackTrace = {\n                    name: name_1,\n                    message: message,\n                    stack: stack,\n                };\n            }\n            callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);\n        },\n    });\n}\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/**\n * Install a global onunhandledrejection handler\n */\nfunction instrumentUnhandledRejection(callback) {\n    return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {\n        before: function (e) {\n            var reason = e.reason || 'Empty reason';\n            var stack = computeStackTrace(reason);\n            callback(stack, reason);\n        },\n    });\n}\n//# sourceMappingURL=tracekit.js.map","import { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString, 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';\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    var consoleObservables = apis.map(function (api) {\n        if (!consoleObservablesByApi[api]) {\n            consoleObservablesByApi[api] = createConsoleObservable(api);\n        }\n        return consoleObservablesByApi[api];\n    });\n    return mergeObservables.apply(void 0, consoleObservables);\n}\nexport function resetConsoleObservable() {\n    consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n    var observable = new Observable(function () {\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    return observable;\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    // Todo: remove console error prefix in the next major version\n    var message = params.map(function (param) { return formatConsoleParameters(param); }).join(' ');\n    var stack;\n    var fingerprint;\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, function (param) { return param instanceof Error; });\n        stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n        fingerprint = tryToGetFingerprint(firstErrorParam);\n        message = \"console error: \".concat(message);\n    }\n    return {\n        api: api,\n        message: message,\n        stack: stack,\n        handlingStack: handlingStack,\n        fingerprint: fingerprint,\n    };\n}\nfunction formatConsoleParameters(param) {\n    if (typeof param === 'string') {\n        return sanitize(param);\n    }\n    if (param instanceof Error) {\n        return formatErrorMessage(computeStackTrace(param));\n    }\n    return jsonStringify(sanitize(param), undefined, 2);\n}\n//# sourceMappingURL=consoleObservable.js.map","import { toStackTraceString } from '../error/error';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { addEventListener } from '../../browser/addEventListener';\nimport { includes } from '../../tools/utils/polyfills';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nexport var RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(apis) {\n    var observables = [];\n    if (includes(apis, RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable());\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    var observable = new Observable(function () {\n        if (!window.ReportingObserver) {\n            return;\n        }\n        var handleReports = monitor(function (reports, _) {\n            return reports.forEach(function (report) {\n                observable.notify(buildRawReportFromReport(report));\n            });\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    return observable;\n}\nfunction createCspViolationReportObservable() {\n    var observable = new Observable(function () {\n        var stop = addEventListener(document, \"securitypolicyviolation\" /* DOM_EVENT.SECURITY_POLICY_VIOLATION */, function (event) {\n            observable.notify(buildRawReportFromCspViolation(event));\n        }).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction buildRawReportFromReport(_a) {\n    var type = _a.type, body = _a.body;\n    return {\n        type: type,\n        subtype: body.id,\n        message: \"\".concat(type, \": \").concat(body.message),\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    };\n}\nfunction buildRawReportFromCspViolation(event) {\n    var type = RawReportType.cspViolation;\n    var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n    return {\n        type: RawReportType.cspViolation,\n        subtype: event.effectiveDirective,\n        message: \"\".concat(type, \": \").concat(message),\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 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 { addEventListeners } from '@datadog/browser-core';\nvar trackFirstHiddenSingleton;\nvar stopListeners;\nexport function trackFirstHidden(eventTarget) {\n    if (eventTarget === void 0) { eventTarget = window; }\n    if (!trackFirstHiddenSingleton) {\n        if (document.visibilityState === 'hidden') {\n            trackFirstHiddenSingleton = {\n                timeStamp: 0,\n            };\n        }\n        else {\n            trackFirstHiddenSingleton = {\n                timeStamp: Infinity,\n            };\n            (stopListeners = addEventListeners(eventTarget, [\"pagehide\" /* DOM_EVENT.PAGE_HIDE */, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */], function (event) {\n                if (event.type === 'pagehide' || document.visibilityState === 'hidden') {\n                    trackFirstHiddenSingleton.timeStamp = event.timeStamp;\n                    stopListeners();\n                }\n            }, { capture: true }).stop);\n        }\n    }\n    return trackFirstHiddenSingleton;\n}\nexport function resetFirstHidden() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    trackFirstHiddenSingleton = undefined;\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts) {\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(10 /* 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 = error instanceof 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(12 /* 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        },\n        type: \"error\" /* RumEventType.ERROR */,\n        view: { in_foreground: pageStateHistory.isInActivePageStateAt(error.startClocks.relative) },\n    };\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\n    }\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: {\n            error: error.originalError,\n        },\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { clocksNow, initConsoleObservable, ErrorSource, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    var subscription = initConsoleObservable([ConsoleApiName.error]).subscribe(function (consoleError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: consoleError.message,\n            stack: consoleError.stack,\n            fingerprint: consoleError.fingerprint,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            handlingStack: consoleError.handlingStack,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { clocksNow } from '../../tools/utils/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nimport { computeRawError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError(errorObservable) {\n    return startUnhandledErrorCollection(function (stackTrace, originalError) {\n        errorObservable.notify(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    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { clocksNow, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(errorObservable) {\n    var subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(function (reportError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: reportError.message,\n            stack: reportError.stack,\n            type: reportError.subtype,\n            source: ErrorSource.REPORT,\n            handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { addDuration } from '@datadog/browser-core';\nimport { toValidEntry } from './resourceUtils';\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 * - if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestTiming(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        .map(function (entry) { return entry.toJSON(); })\n        .filter(toValidEntry)\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        return candidates[0];\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=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, isExperimentalFeatureEnabled, ExperimentalFeature, } from '@datadog/browser-core';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle, configuration, sessionManager, pageStateHistory) {\n    lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processRequest(request, configuration, sessionManager, pageStateHistory));\n    });\n    lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, 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 === 'resource' && !isRequestKind(entry)) {\n                lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processResourceEntry(entry, configuration, sessionManager, pageStateHistory));\n            }\n        }\n    });\n}\nfunction processRequest(request, configuration, sessionManager, pageStateHistory) {\n    var _a;\n    var type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.FETCH */;\n    var matchingTiming = matchRequestTiming(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined;\n    var tracingInfo = computeRequestTracingInfo(request, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var duration = computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, (_a = matchingTiming === null || matchingTiming === void 0 ? void 0 : matchingTiming.duration) !== null && _a !== void 0 ? _a : 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            url: request.url,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides, indexingInfo, pageStateInfo);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming && toPerformanceEntryRepresentation(matchingTiming),\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n        },\n    };\n}\nfunction processResourceEntry(entry, configuration, sessionManager, pageStateHistory) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeEntryTracingInfo(entry, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, entry.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, entryMetrics, indexingInfo, pageStateInfo);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: toPerformanceEntryRepresentation(entry),\n        },\n    };\n}\nfunction computePerformanceEntryMetrics(timing) {\n    return {\n        resource: assign({\n            duration: computePerformanceResourceDuration(timing),\n            size: computeSize(timing),\n        }, computePerformanceResourceDetails(timing)),\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.toDecimalString(),\n            trace_id: request.traceId.toDecimalString(),\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry, configuration) {\n    var hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\n// TODO next major: use directly PerformanceEntry type in domain context\nfunction toPerformanceEntryRepresentation(entry) {\n    return entry;\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 computeIndexingInfo(sessionManager, resourceStart) {\n    var session = sessionManager.findTrackedSession(resourceStart.relative);\n    return {\n        _dd: {\n            discarded: !session || !session.resourceAllowed,\n        },\n    };\n}\nfunction computePageStateInfo(pageStateHistory, startClocks, duration) {\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.RESOURCE_PAGE_STATES)) {\n        return;\n    }\n    return {\n        _dd: {\n            page_states: pageStateHistory.findAll(startClocks.relative, duration),\n            page_was_discarded: String(document.wasDiscarded),\n        },\n    };\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    var _a;\n    // TODO remove FF in next major\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.NO_RESOURCE_DURATION_FROZEN_STATE)) {\n        return toServerDuration(duration);\n    }\n    var requestCrossedFrozenState = (_a = pageStateHistory\n        .findAll(startClocks.relative, duration)) === null || _a === void 0 ? void 0 : _a.some(function (pageState) { return pageState.state === \"frozen\" /* PageState.FROZEN */; });\n    return !requestCrossedFrozenState ? toServerDuration(duration) : undefined;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { toServerDuration } from '@datadog/browser-core';\n// Todo: Remove in the next major release\nexport function mapToForegroundPeriods(pageStateServerEntries, duration) {\n    var foregroundPeriods = [];\n    for (var i = 0; i < pageStateServerEntries.length; i++) {\n        var current = pageStateServerEntries[i];\n        var next = pageStateServerEntries[i + 1];\n        if (current.state === \"active\" /* PageState.ACTIVE */) {\n            var start = current.start >= 0 ? current.start : 0;\n            var end = next ? next.start : toServerDuration(duration);\n            foregroundPeriods.push({\n                start: start,\n                duration: (end - start),\n            });\n        }\n    }\n    return foregroundPeriods;\n}\n//# sourceMappingURL=foregroundContexts.js.map","import { setTimeout, assign, addEventListeners, elapsed, ONE_MINUTE, find, findLast, relativeNow, } from '@datadog/browser-core';\nimport { trackFirstHidden } from './trackFirstHidden';\n// Discard LCP and 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 TIMING_MAXIMUM_DELAY = 10 * ONE_MINUTE;\n/**\n * The initial view can finish quickly, before some metrics can be produced (ex: before the page load\n * event, or the first input). Also, we don't want to trigger a view update indefinitely, to avoid\n * updates on views that ended a long time ago. Keep watching for metrics after the view ends for a\n * limited amount of time.\n */\nexport var KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackInitialViewTimings(lifeCycle, setLoadEvent, scheduleViewUpdate) {\n    var timings = {};\n    function setTimings(newTimings) {\n        assign(timings, newTimings);\n        scheduleViewUpdate();\n    }\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, function (newTimings) {\n        setLoadEvent(newTimings.loadEvent);\n        setTimings(newTimings);\n    }).stop;\n    var stopFCPTracking = trackFirstContentfulPaintTiming(lifeCycle, function (firstContentfulPaint) {\n        return setTimings({ firstContentfulPaint: firstContentfulPaint });\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaintTiming(lifeCycle, window, function (largestContentfulPaint) {\n        setTimings({\n            largestContentfulPaint: largestContentfulPaint,\n        });\n    }).stop;\n    var stopFIDTracking = trackFirstInputTimings(lifeCycle, function (_a) {\n        var firstInputDelay = _a.firstInputDelay, firstInputTime = _a.firstInputTime;\n        setTimings({\n            firstInputDelay: firstInputDelay,\n            firstInputTime: firstInputTime,\n        });\n    }).stop;\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n    }\n    return {\n        stop: stop,\n        timings: timings,\n        scheduleStop: function () {\n            setTimeout(stop, KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY);\n        },\n    };\n}\nexport function trackNavigationTimings(lifeCycle, callback) {\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, 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 === 'navigation') {\n                callback({\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            }\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\nexport function trackFirstContentfulPaintTiming(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === 'paint' &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\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/getLCP.ts\n */\nexport function trackLargestContentfulPaintTiming(lifeCycle, eventTarget, callback) {\n    var firstHidden = trackFirstHidden();\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(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 unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === 'largest-contentful-paint' &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (lcpEntry) {\n            callback(lcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\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 trackFirstInputTimings(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === 'first-input' && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                firstInputDelay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                firstInputTime: firstInputEntry.startTime,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=trackInitialViewTimings.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 { ExperimentalFeature, isExperimentalFeatureEnabled, ONE_SECOND, addEventListener, elapsed, noop, relativeNow, round, throttle, } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { getScrollY } from '../../../browser/scroll';\nimport { getViewportDimension } from '../../../browser/viewportObservable';\n/** Arbitrary scroll throttle duration */\nexport var THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    var viewMetrics = {};\n    var scrollMetrics;\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadingType, viewStart, function (newLoadingTime) {\n        viewMetrics.loadingTime = newLoadingTime;\n        // We compute scroll metrics at loading time to ensure we have scroll data when loading the view initially\n        // This is to ensure that we have the depth data even if the user didn't scroll or if the view is not scrollable.\n        if (isExperimentalFeatureEnabled(ExperimentalFeature.SCROLLMAP)) {\n            var _a = computeScrollValues(), scrollHeight = _a.scrollHeight, scrollDepth = _a.scrollDepth, scrollTop = _a.scrollTop;\n            scrollMetrics = {\n                maxDepth: scrollDepth,\n                maxDepthScrollHeight: scrollHeight,\n                maxDepthTime: newLoadingTime,\n                maxDepthScrollTop: scrollTop,\n            };\n        }\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopScrollMetricsTracking = trackScrollMetrics(viewStart, function (newScrollMetrics) {\n        scrollMetrics = newScrollMetrics;\n    }, computeScrollValues).stop;\n    var stopCLSTracking;\n    if (isLayoutShiftSupported()) {\n        viewMetrics.cumulativeLayoutShift = 0;\n        (stopCLSTracking = trackCumulativeLayoutShift(lifeCycle, function (cumulativeLayoutShift) {\n            viewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n            scheduleViewUpdate();\n        }).stop);\n    }\n    else {\n        stopCLSTracking = noop;\n    }\n    return {\n        stop: function () {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        viewMetrics: viewMetrics,\n        getScrollMetrics: function () { return scrollMetrics; },\n    };\n}\nexport function trackScrollMetrics(viewStart, callback, getScrollValues) {\n    if (getScrollValues === void 0) { getScrollValues = computeScrollValues; }\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.SCROLLMAP)) {\n        return { stop: noop };\n    }\n    var maxDepth = 0;\n    var handleScrollEvent = throttle(function () {\n        var _a = getScrollValues(), scrollHeight = _a.scrollHeight, scrollDepth = _a.scrollDepth, scrollTop = _a.scrollTop;\n        if (scrollDepth > maxDepth) {\n            var now = relativeNow();\n            var maxDepthTime = elapsed(viewStart.relative, now);\n            maxDepth = scrollDepth;\n            callback({\n                maxDepth: maxDepth,\n                maxDepthScrollHeight: scrollHeight,\n                maxDepthTime: maxDepthTime,\n                maxDepthScrollTop: scrollTop,\n            });\n        }\n    }, THROTTLE_SCROLL_DURATION, { leading: false, trailing: true });\n    var stop = addEventListener(window, \"scroll\" /* DOM_EVENT.SCROLL */, handleScrollEvent.throttled, { passive: true }).stop;\n    return {\n        stop: function () {\n            handleScrollEvent.cancel();\n            stop();\n        },\n    };\n}\nfunction 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}\nfunction trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadType, viewStart, callback) {\n    var isWaitingForLoadEvent = loadType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */;\n    var isWaitingForActivityLoadingTime = true;\n    var loadingTimeCandidates = [];\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            callback(Math.max.apply(Math, loadingTimeCandidates));\n        }\n    }\n    var stop = waitPageActivityEnd(lifeCycle, domMutationObservable, 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: stop,\n        setLoadEvent: function (loadEvent) {\n            if (isWaitingForLoadEvent) {\n                isWaitingForLoadEvent = false;\n                loadingTimeCandidates.push(loadEvent);\n                invokeCallbackIfAllCandidatesAreReceived();\n            }\n        },\n    };\n}\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 */\nfunction trackCumulativeLayoutShift(lifeCycle, callback) {\n    var maxClsValue = 0;\n    var window = slidingSessionWindow();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, 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 === 'layout-shift' && !entry.hadRecentInput) {\n                window.update(entry);\n                if (window.value() > maxClsValue) {\n                    maxClsValue = window.value();\n                    callback(round(maxClsValue, 4));\n                }\n            }\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\nfunction slidingSessionWindow() {\n    var value = 0;\n    var startTime;\n    var endTime;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= ONE_SECOND ||\n                entry.startTime - startTime >= 5 * ONE_SECOND;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                value = entry.value;\n            }\n            else {\n                value += entry.value;\n                endTime = entry.startTime;\n            }\n        },\n        value: function () { return value; },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nfunction isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent('layout-shift');\n}\n//# sourceMappingURL=trackViewMetrics.js.map","import { ONE_MINUTE, setTimeout } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\n// Some events are not being counted as they transcend views. To reduce the occurrence;\n// an arbitrary delay is added for stopping event counting after the view ends.\n//\n// Ideally, we would not stop and keep counting events until the end of the session.\n// But this might have a small performance impact if there are many many views:\n// we would need to go through each event to see if the related view matches.\n// So let's have a fairly short delay to avoid impacting performances too much.\n//\n// In the future, we could have views stored in a data structure similar to ContextHistory. Whenever\n// a child event is collected, we could look into this history to find the matching view and\n// increase the associated and increase its counter. Having a centralized data structure for it\n// would allow us to look for views more efficiently.\n//\n// For now, having a small cleanup delay will already improve the situation in most cases.\nexport var KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\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        scheduleStop: function () {\n            setTimeout(stop, KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY);\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { noop, PageExitReason, shallowClone, assign, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, } from '@datadog/browser-core';\nimport { trackInitialViewTimings } from './trackInitialViewTimings';\nimport { trackViewMetrics } from './trackViewMetrics';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\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        return newView(lifeCycle, domMutationObservable, configuration, location, loadingType, startClocks, viewOptions);\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(8 /* 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            });\n        });\n        lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n            currentView.end({ sessionIsActive: false });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(9 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING || pageExitEvent.reason === PageExitReason.PAGEHIDE) {\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        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            currentView.end();\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, configuration, initialLocation, loadingType, startClocks, viewOptions) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    var sessionIsActive = true;\n    var name;\n    var service;\n    var version;\n    if (viewOptions) {\n        name = viewOptions.name;\n        service = viewOptions.service;\n        version = viewOptions.version;\n    }\n    lifeCycle.notify(2 /* LifeCycleEventType.VIEW_CREATED */, {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n    });\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 = trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopViewMetricsTracking = _b.stop, viewMetrics = _b.viewMetrics, getScrollMetrics = _b.getScrollMetrics;\n    var _c = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewTimings(lifeCycle, setLoadEvent, scheduleViewUpdate)\n        : { scheduleStop: noop, timings: {} }, scheduleStopInitialViewTimingsTracking = _c.scheduleStop, timings = _c.timings;\n    var _d = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), scheduleStopEventCountsTracking = _d.scheduleStop, eventCounts = _d.eventCounts;\n    // Session keep alive\n    var keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(3 /* LifeCycleEventType.VIEW_UPDATED */, assign({\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            service: service,\n            version: version,\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            timings: timings,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive: sessionIsActive,\n            eventCounts: eventCounts,\n            scrollMetrics: getScrollMetrics(),\n        }, viewMetrics));\n    }\n    return {\n        name: name,\n        service: service,\n        version: version,\n        end: function (options) {\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            clearInterval(keepAliveIntervalId);\n            stopViewMetricsTracking();\n            scheduleStopInitialViewTimingsTracking();\n            scheduleStopEventCountsTracking();\n            triggerViewUpdate();\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    };\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.substr(1);\n    return !!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 { isExperimentalFeatureEnabled, ExperimentalFeature, isEmptyObject, mapValues, toServerDuration, isNumber, } from '@datadog/browser-core';\nimport { mapToForegroundPeriods } from '../../contexts/foregroundContexts';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory));\n    });\n    var trackViewResult = trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n    return trackViewResult;\n}\nfunction processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory) {\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\n    var pageStatesEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGE_STATES);\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: pageStatesEnabled ? pageStates : undefined,\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: view.cumulativeLayoutShift,\n            first_byte: toServerDuration(view.timings.firstByte),\n            dom_complete: toServerDuration(view.timings.domComplete),\n            dom_content_loaded: toServerDuration(view.timings.domContentLoaded),\n            dom_interactive: toServerDuration(view.timings.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.timings.firstContentfulPaint),\n            first_input_delay: toServerDuration(view.timings.firstInputDelay),\n            first_input_time: toServerDuration(view.timings.firstInputTime),\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration(view.timings.largestContentfulPaint),\n            load_event: toServerDuration(view.timings.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.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            in_foreground_periods: !pageStatesEnabled && pageStates ? mapToForegroundPeriods(pageStates, view.duration) : undefined, // Todo: Remove in the next major release\n        },\n        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\n        display: view.scrollMetrics\n            ? {\n                scroll: {\n                    max_depth: view.scrollMetrics.maxDepth,\n                    max_depth_scroll_height: view.scrollMetrics.maxDepthScrollHeight,\n                    max_depth_scroll_top: view.scrollMetrics.maxDepthScrollTop,\n                    max_depth_time: toServerDuration(view.scrollMetrics.maxDepthTime),\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}\nfunction discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=viewCollection.js.map","import { ValueHistory } 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(sessionStoreStrategyType, productKey, computeSessionState) {\n    var sessionStore = startSessionStore(sessionStoreStrategyType, productKey, computeSessionState);\n    stopCallbacks.push(function () { return sessionStore.stop(); });\n    var sessionContextHistory = new ValueHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n    });\n    sessionStore.expireObservable.subscribe(function () {\n        sessionContextHistory.closeActive(relativeNow());\n    });\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n    trackActivity(function () { return sessionStore.expandOrRenewSession(); });\n    trackVisibility(function () { return sessionStore.expandSession(); });\n    function buildSessionContext() {\n        return {\n            id: sessionStore.getSession().id,\n            trackingType: sessionStore.getSession()[productKey],\n        };\n    }\n    return {\n        findActiveSession: function (startTime) { return sessionContextHistory.find(startTime); },\n        renewObservable: sessionStore.renewObservable,\n        expireObservable: sessionStore.expireObservable,\n        expire: sessionStore.expire,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(expandOrRenewSession) {\n    var stop = addEventListeners(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(expandSession) {\n    var expandSessionWhenVisible = function () {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    };\n    var stop = addEventListener(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}\n//# sourceMappingURL=sessionManager.js.map","import { Observable, noop, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle) {\n    var sessionManager = startSessionManager(\n    // TODO - Improve configuration type and remove assertion\n    configuration.sessionStoreStrategyType, RUM_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); });\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(7 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(8 /* LifeCycleEventType.SESSION_RENEWED */);\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findActiveSession(startTime);\n            if (!session || !isTypeTracked(session.trackingType)) {\n                return;\n            }\n            var plan = session.trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */\n                ? 2 /* RumSessionPlan.WITH_SESSION_REPLAY */\n                : 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */;\n            return {\n                id: session.id,\n                plan: plan,\n                sessionReplayAllowed: plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                longTaskAllowed: configuration.trackLongTasks !== undefined\n                    ? configuration.trackLongTasks\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                resourceAllowed: configuration.trackResources !== undefined\n                    ? configuration.trackResources\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n            };\n        },\n        expire: sessionManager.expire,\n        expireObservable: sessionManager.expireObservable,\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        plan: 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */,\n        sessionReplayAllowed: false,\n        longTaskAllowed: true,\n        resourceAllowed: true,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n        expire: noop,\n        expireObservable: new Observable(),\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 { 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 flushObservable = new Observable();\n    pageExitObservable.subscribe(function (event) { return flush(event.reason); });\n    sessionExpireObservable.subscribe(function () { return flush('session_expire'); });\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        notifyBeforeAddMessage: function (messageBytesCount) {\n            if (currentBytesCount + messageBytesCount >= 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 += messageBytesCount;\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        notifyAfterAddMessage: function () {\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        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 { display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageExitObservable';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nvar Batch = /** @class */ (function () {\n    function Batch(request, flushController, messageBytesLimit) {\n        var _this = this;\n        this.request = request;\n        this.flushController = flushController;\n        this.messageBytesLimit = messageBytesLimit;\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        this.flushController.flushObservable.subscribe(function (event) { return _this.flush(event); });\n    }\n    Batch.prototype.add = function (message) {\n        this.addOrUpdate(message);\n    };\n    Batch.prototype.upsert = function (message, key) {\n        this.addOrUpdate(message, key);\n    };\n    Batch.prototype.flush = function (event) {\n        var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        var payload = { data: messages.join('\\n'), bytesCount: event.bytesCount, flushReason: event.reason };\n        if (isPageExitReason(event.reason)) {\n            this.request.sendOnExit(payload);\n        }\n        else {\n            this.request.send(payload);\n        }\n    };\n    Batch.prototype.addOrUpdate = function (message, key) {\n        var _a = this.process(message), processedMessage = _a.processedMessage, messageBytesCount = _a.messageBytesCount;\n        if (messageBytesCount >= this.messageBytesLimit) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.messageBytesLimit, \"KB.\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        this.push(processedMessage, messageBytesCount, key);\n    };\n    Batch.prototype.process = function (message) {\n        var processedMessage = jsonStringify(message);\n        var messageBytesCount = computeBytesCount(processedMessage);\n        return { processedMessage: processedMessage, messageBytesCount: messageBytesCount };\n    };\n    Batch.prototype.push = function (processedMessage, messageBytesCount, key) {\n        // If there are other messages, a '\\n' will be added at serialization\n        var separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0;\n        this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount);\n        if (key !== undefined) {\n            this.upsertBuffer[key] = processedMessage;\n        }\n        else {\n            this.pushOnlyBuffer.push(processedMessage);\n        }\n        this.flushController.notifyAfterAddMessage();\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesCount = computeBytesCount(removedMessage);\n        // If there are other messages, a '\\n' will be added at serialization\n        var separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0;\n        this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount);\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    return Batch;\n}());\nexport { Batch };\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, endpointType, 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, endpointType, reportError); },\n            onFailure: function () {\n                state.queuedPayloads.enqueue(payload);\n                scheduleRetry(state, sendStrategy, endpointType, reportError);\n            },\n        });\n    }\n    else {\n        state.queuedPayloads.enqueue(payload);\n    }\n}\nfunction scheduleRetry(state, sendStrategy, endpointType, 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, endpointType, reportError);\n            },\n            onFailure: function () {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, endpointType, 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, endpointType, reportError) {\n    if (reason === 0 /* RetryReason.AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n        reportError({\n            message: \"Reached max \".concat(endpointType, \" 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, endpointType, 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.endpointType, 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, _a) {\n    var data = _a.data, bytesCount = _a.bytesCount, flushReason = _a.flushReason;\n    var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            var beaconUrl = endpointBuilder.build('beacon', flushReason);\n            var isQueued = navigator.sendBeacon(beaconUrl, data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    var xhrUrl = endpointBuilder.build('xhr', flushReason);\n    sendXHR(xhrUrl, data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, _a, onResponse) {\n    var data = _a.data, bytesCount = _a.bytesCount, flushReason = _a.flushReason, retry = _a.retry;\n    var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        var fetchUrl = endpointBuilder.build('fetch', flushReason, retry);\n        fetch(fetchUrl, { method: 'POST', body: 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', flushReason, retry);\n            // failed to queue the request\n            sendXHR(xhrUrl, data, onResponse);\n        }));\n    }\n    else {\n        var xhrUrl = endpointBuilder.build('xhr', flushReason, retry);\n        sendXHR(xhrUrl, 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    addEventListener(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 { createFlushController, Batch, combine, createHttpRequest, isTelemetryReplicationAllowed, } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable, sessionExpireObservable) {\n    var batch = makeRumBatch(configuration, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(11 /* 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}\nfunction makeRumBatch(configuration, reportError, pageExitObservable, sessionExpireObservable) {\n    var _a = createRumBatch(configuration.rumEndpointBuilder), primaryBatch = _a.batch, primaryFlushController = _a.flushController;\n    var replicaBatch;\n    var replica = configuration.replica;\n    if (replica !== undefined) {\n        replicaBatch = createRumBatch(replica.rumEndpointBuilder).batch;\n    }\n    function createRumBatch(endpointBuilder) {\n        var flushController = createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageExitObservable: pageExitObservable,\n            sessionExpireObservable: sessionExpireObservable,\n        });\n        var batch = new Batch(createHttpRequest(endpointBuilder, configuration.batchBytesLimit, reportError), flushController, configuration.messageBytesLimit);\n        return {\n            batch: batch,\n            flushController: flushController,\n        };\n    }\n    function withReplicaApplicationId(message) {\n        return combine(message, { application: { id: replica.applicationId } });\n    }\n    return {\n        flushObservable: primaryFlushController.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(withReplicaApplicationId(message));\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(withReplicaApplicationId(message), key);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startRumBatch.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, ValueHistory } 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 = new ValueHistory(URL_CONTEXT_TIME_OUT_DELAY);\n    var previousViewUrl;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.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    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, instrumentMethodAndCallOriginal, Observable, shallowClone, } from '@datadog/browser-core';\nexport function createLocationChangeObservable(location) {\n    var currentLocation = shallowClone(location);\n    var observable = new Observable(function () {\n        var stopHistoryTracking = trackHistory(onLocationChange).stop;\n        var stopHashTracking = trackHash(onLocationChange).stop;\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\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 observable;\n}\nfunction trackHistory(onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethodAndCallOriginal(history, 'pushState', {\n        after: onHistoryChange,\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethodAndCallOriginal(history, 'replaceState', {\n        after: onHistoryChange,\n    }).stop;\n    var removeListener = addEventListener(window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(onHashChange) {\n    return addEventListener(window, \"hashchange\" /* DOM_EVENT.HASH_CHANGE */, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { warnIfCustomerDataLimitReached, throttle, jsonStringify, computeBytesCount, noop, isExperimentalFeatureEnabled, SESSION_TIME_OUT_DELAY, ValueHistory, ExperimentalFeature, } 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, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.FEATURE_FLAGS)) {\n        return {\n            findFeatureFlagEvaluations: function () { return undefined; },\n            getFeatureFlagBytesCount: function () { return 0; },\n            addFeatureFlagEvaluation: noop,\n            stop: noop,\n        };\n    }\n    var featureFlagContexts = new ValueHistory(FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY);\n    var bytesCountCache = 0;\n    var alreadyWarned = false;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        bytesCountCache = 0;\n    });\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call addFeatureFlagEvaluation API synchronously multiple times in a row\n    var _a = throttle(function (context) {\n        bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n        if (!alreadyWarned) {\n            alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, \"feature flag evaluation\" /* CustomerDataType.FeatureFlag */);\n        }\n    }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a.throttled, cancelPendingComputation = _a.cancel;\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        getFeatureFlagBytesCount: function () {\n            var currentContext = featureFlagContexts.find();\n            if (!currentContext) {\n                return 0;\n            }\n            return bytesCountCache;\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n                computeBytesCountThrottled(currentContext);\n            }\n        },\n        stop: cancelPendingComputation,\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { isEmptyObject, 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, globalContextManager, userContextManager, featureFlagContexts, 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(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, !isEmptyObject(globalContextManager.get()) ? globalContextManager.getBytesCount() : 0);\n        updateMeasure(currentBatchMeasures.userContextBytes, !isEmptyObject(userContextManager.get()) ? userContextManager.getBytesCount() : 0);\n        var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations();\n        var hasFeatureFlagContext = includes([\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */], event.type) &&\n            featureFlagContext &&\n            !isEmptyObject(featureFlagContext);\n        updateMeasure(currentBatchMeasures.featureFlagBytes, hasFeatureFlagContext ? featureFlagContexts.getFeatureFlagBytesCount() : 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, ValueHistory, 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(maxPageStateEntriesSelectable) {\n    if (maxPageStateEntriesSelectable === void 0) { maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE; }\n    var pageStateHistory = new ValueHistory(PAGE_STATE_CONTEXT_TIME_OUT_DELAY, MAX_PAGE_STATE_ENTRIES);\n    var currentPageState;\n    addPageState(getPageState(), relativeNow());\n    var stopEventListeners = addEventListeners(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        // Only get events fired by the browser to avoid false currentPageState changes done with custom events\n        // cf: developer extension auto flush: https://github.com/DataDog/browser-sdk/blob/2f72bf05a672794c9e33965351964382a94c72ba/developer-extension/src/panel/flushEvents.ts#L11-L12\n        if (event.isTrusted) {\n            addPageState(computePageState(event), event.timeStamp);\n        }\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        pageStateHistory.closeActive(startTime);\n        pageStateHistory.add({ state: currentPageState, startTime: startTime }, startTime);\n    }\n    return {\n        findAll: function (eventStartTime, duration) {\n            var pageStateEntries = pageStateHistory.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        isInActivePageStateAt: function (startTime) {\n            var pageStateEntry = pageStateHistory.find(startTime);\n            return pageStateEntry !== undefined && pageStateEntry.state === \"active\" /* PageState.ACTIVE */;\n        },\n        addPageState: addPageState,\n        stop: function () {\n            stopEventListeners();\n            pageStateHistory.stop();\n        },\n    };\n}\nfunction computePageState(event) {\n    if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */) {\n        return event.persisted ? \"frozen\" /* PageState.FROZEN */ : \"terminated\" /* PageState.TERMINATED */;\n    }\n    return getPageState();\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* PageState.HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* PageState.ACTIVE */;\n    }\n    return \"passive\" /* PageState.PASSIVE */;\n}\n//# sourceMappingURL=pageStateHistory.js.map","import { 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 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","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 { DefaultPrivacyLevel } from '@datadog/browser-core';\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_ALLOW = 'dd-privacy-allow';\nexport var PRIVACY_CLASS_MASK = 'dd-privacy-mask';\nexport var PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input';\nexport var PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden';\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};\n//# sourceMappingURL=constants.js.map","import { isElementNode, getParentNode, isTextNode } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_CLASS_ALLOW, PRIVACY_CLASS_MASK, PRIVACY_CLASS_MASK_USER_INPUT, PRIVACY_CLASS_HIDDEN, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, } from '../../constants';\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100000;\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) {\n    var parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel) : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\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    var privAttr = node.getAttribute(PRIVACY_ATTR_NAME);\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]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_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 isStyle = parentTagName === 'STYLE' ? true : undefined;\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        // Style tags are `overruled` (Use `hide` to enforce privacy)\n        !isStyle) {\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}\n//# sourceMappingURL=privacy.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nimport { CENSORED_STRING_MARK } from '../../../constants';\nimport { shouldMaskNode } from '../privacy';\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 (_) {\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}\n//# sourceMappingURL=serializationUtils.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 { STABLE_ATTRIBUTES } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK } from '../../../constants';\nimport { MAX_ATTRIBUTE_VALUE_CHAR_LENGTH } from '../privacy';\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' || tagName === 'SOURCE') {\n            if (attributeName === 'src' || attributeName === 'srcset') {\n                return CENSORED_IMG_MARK;\n            }\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    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n        return 'data:truncated';\n    }\n    return attributeValue;\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel } from '../../../constants';\nimport { shouldMaskNode } from '../privacy';\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' &&\n        element.sheet &&\n        // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n        !(element.innerText || element.textContent || '').trim().length) {\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}\nfunction 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, getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleString(rule) {\n    return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { isNodeShadowRoot, isNodeShadowHost } from '@datadog/browser-rum-core';\nimport { assign } from '@datadog/browser-core';\nimport { NodeType } from '../../../types';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN } from '../../../constants';\nimport { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent } from '../privacy';\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    node.childNodes.forEach(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 childNodes = [];\n    if (element.childNodes.length) {\n        childNodes = serializeChildNodes(element, options);\n    }\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: childNodes,\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 (element.childNodes.length) {\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    if (isNodeShadowHost(element)) {\n        var shadowRoot = serializeNodeWithId(element.shadowRoot, options);\n        if (shadowRoot !== null) {\n            childNodes.push(shadowRoot);\n        }\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 _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 = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\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 { 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';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function initMoveObserver(cb) {\n    var updatePosition = 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            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\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=moveObserver.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { NodePrivacyLevel } from '../../../constants';\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nexport function initScrollObserver(cb, defaultPrivacyLevel, elementsScrollPositions) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, 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        cb({\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        });\n    }, SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\n//# sourceMappingURL=scrollObserver.js.map","var _a;\nimport { assign, addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './moveObserver';\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 initMouseInteractionObserver(cb, defaultPrivacyLevel, recordIds) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !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        cb(record);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\n//# sourceMappingURL=mouseInteractionObserver.js.map","import { instrumentSetter, assign, addEventListeners, forEach, noop } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel, shouldMaskNode } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initInputObserver(cb, defaultPrivacyLevel, target) {\n    if (target === void 0) { target = document; }\n    var lastInputStateMap = new WeakMap();\n    var isShadowRoot = target !== document;\n    var stopEventListeners = addEventListeners(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 function () {\n        stopPropertySetterInstrumentation();\n        stopEventListeners();\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(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            cb(assign({\n                id: getSerializedNodeId(target),\n            }, inputState));\n        }\n    }\n}\n//# sourceMappingURL=inputObserver.js.map","import { instrumentMethodAndCallOriginal } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initStyleSheetObserver(cb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n            before: function (rule, index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, adds: [{ rule: rule, index: index }] }); });\n            },\n        }),\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n            before: function (index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, removes: [{ index: index }] }); });\n            },\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethodAndCallOriginal(cls.prototype, 'insertRule', {\n            before: function (rule, index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index || 0);\n                        cb({ id: id, adds: [{ rule: rule, index: path }] });\n                    }\n                });\n            },\n        }), instrumentMethodAndCallOriginal(cls.prototype, 'deleteRule', {\n            before: function (index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index);\n                        cb({ id: id, removes: [{ index: path }] });\n                    }\n                });\n            },\n        }));\n    }\n    return function () { return instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); }); };\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=styleSheetObserver.js.map","import { throttle, addEventListeners, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { getVisualViewport } from '../viewports';\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function initViewportResizeObserver(cb) {\n    return initViewportObservable().subscribe(cb).unsubscribe;\n}\nexport function initVisualViewportResizeObserver(cb) {\n    var visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return noop;\n    }\n    var _a = throttle(function () {\n        cb(getVisualViewport(visualViewport));\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\n//# sourceMappingURL=viewportResizeObserver.js.map","import { noop, monitor } 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;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n        },\n    };\n}\n/**\n * Use 'requestIdleCallback' when available: it will throttle the mutation processing if the\n * browser is busy rendering frames (ex: when frames are below 60fps). When not available, the\n * fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any\n * browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes efficiently.\n *\n * Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n */\nfunction requestIdleCallback(callback, opts) {\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    var id = window.requestAnimationFrame(monitor(callback));\n    return function () { return window.cancelAnimationFrame(id); };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { getChildNodes, isNodeShadowHost, getMutationObserverConstructor, getParentNode, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getNodePrivacyLevel, getTextContent } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function initMutationObserver(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, target);\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, target) {\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 target.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController), 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);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback({\n        adds: adds,\n        removes: removes,\n        texts: texts,\n        attributes: attributes,\n    });\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController) {\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);\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) {\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);\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) {\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 === null || handledAttributes === void 0 ? void 0 : 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);\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    getChildNodes(removedNode).forEach(function (child) { return traverseRemovedShadowDom(child, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=mutationObserver.js.map","import { initMoveObserver } from './moveObserver';\nimport { initScrollObserver } from './scrollObserver';\nimport { initMouseInteractionObserver } from './mouseInteractionObserver';\nimport { initInputObserver } from './inputObserver';\nimport { initStyleSheetObserver } from './styleSheetObserver';\nimport { initMediaInteractionObserver } from './mediaInteractionObserver';\nimport { initFrustrationObserver } from './frustrationObserver';\nimport { initViewportResizeObserver, initVisualViewportResizeObserver } from './viewportResizeObserver';\nimport { initMutationObserver } from './mutationObserver';\nimport { initFocusObserver } from './focusObserver';\nimport { initRecordIds } from './recordIds';\nexport function initObservers(o) {\n    var recordIds = initRecordIds();\n    var mutationHandler = initMutationObserver(o.mutationCb, o.configuration, o.shadowRootsController, document);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.configuration.defaultPrivacyLevel, recordIds);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.configuration.defaultPrivacyLevel, o.elementsScrollPositions);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.configuration.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.configuration.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    var frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb, recordIds);\n    return {\n        flush: function () {\n            mutationHandler.flush();\n        },\n        stop: function () {\n            mutationHandler.stop();\n            mousemoveHandler();\n            mouseInteractionHandler();\n            scrollHandler();\n            viewportResizeHandler();\n            inputHandler();\n            mediaInteractionHandler();\n            styleSheetObserver();\n            focusHandler();\n            visualViewportResizeHandler();\n            frustrationHandler();\n        },\n    };\n}\n//# sourceMappingURL=observers.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb({\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* DOM_EVENT.PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        });\n    };\n    return addEventListeners(document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], handler, { capture: true, passive: true }).stop;\n}\n//# sourceMappingURL=mediaInteractionObserver.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function initFocusObserver(focusCb) {\n    return addEventListeners(window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\n//# sourceMappingURL=focusObserver.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 { RecordType } from '../../../types';\nexport function initFrustrationObserver(lifeCycle, frustrationCb, recordIds) {\n    return lifeCycle.subscribe(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (data) {\n        var _a, _b, _c;\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            ((_c = data.domainContext.events) === null || _c === void 0 ? void 0 : _c.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    }).unsubscribe;\n}\n//# sourceMappingURL=frustrationObserver.js.map","import { initInputObserver, initMutationObserver } from './observers';\nexport var initShadowRootsController = function (configuration, _a) {\n    var mutationCb = _a.mutationCb, inputCb = _a.inputCb;\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            var _a = initMutationObserver(mutationCb, configuration, shadowRootsController, shadowRoot), stopMutationObserver = _a.stop, flush = _a.flush;\n            // the change event no do bubble up across the shadow root, we have to listen on the shadow root\n            var stopInputObserver = initInputObserver(inputCb, configuration.defaultPrivacyLevel, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: flush,\n                stop: function () {\n                    stopMutationObserver();\n                    stopInputObserver();\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 { timeStampNow } from '@datadog/browser-core';\nimport { getViewportDimension, getScrollX, getScrollY } from '@datadog/browser-rum-core';\nimport { RecordType, IncrementalSource } from '../../types';\nimport { assembleIncrementalSnapshot } from './assembly';\nimport { serializeDocument } from './serialization';\nimport { initObservers } from './observers';\nimport { getVisualViewport } from './viewports';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nexport function record(options) {\n    var emit = options.emit;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var elementsScrollPositions = createElementsScrollPositions();\n    var mutationCb = function (mutation) {\n        emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, mutation));\n    };\n    var inputCb = function (s) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, s)); };\n    var shadowRootsController = initShadowRootsController(options.configuration, { mutationCb: mutationCb, inputCb: inputCb });\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        emit({\n            data: {\n                height: height,\n                href: window.location.href,\n                width: width,\n            },\n            type: RecordType.Meta,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, options.configuration, serializationContext),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp: timestamp,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var _a = initObservers({\n        lifeCycle: options.lifeCycle,\n        configuration: options.configuration,\n        elementsScrollPositions: elementsScrollPositions,\n        inputCb: inputCb,\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (mouseInteractionRecord) { return emit(mouseInteractionRecord); },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: mutationCb,\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        frustrationCb: function (frustrationRecord) { return emit(frustrationRecord); },\n        focusCb: function (data) {\n            return emit({\n                data: data,\n                type: RecordType.Focus,\n                timestamp: timeStampNow(),\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n                timestamp: timeStampNow(),\n            });\n        },\n        shadowRootsController: shadowRootsController,\n    }), stopObservers = _a.stop, flushMutationsFromObservers = _a.flush;\n    function flushMutations() {\n        shadowRootsController.flush();\n        flushMutationsFromObservers();\n    }\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            stopObservers();\n        },\n        takeSubsequentFullSnapshot: function (timestamp) {\n            flushMutations();\n            takeFullSnapshot(timestamp, {\n                shadowRootsController: shadowRootsController,\n                status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n                elementsScrollPositions: elementsScrollPositions,\n            });\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","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        statsPerView.delete(statsPerView.keys().next().value);\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 { addTelemetryDebug, assign, sendToExtension, addEventListener } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar nextId = 0;\nvar Segment = /** @class */ (function () {\n    function Segment(worker, context, creationReason, initialRecord, onWrote, onFlushed) {\n        var _this = this;\n        this.worker = worker;\n        this.id = nextId++;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: initialRecord.timestamp,\n            end: initialRecord.timestamp,\n            creation_reason: creationReason,\n            records_count: 1,\n            has_full_snapshot: initialRecord.type === RecordType.FullSnapshot,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n            source: 'browser',\n        }, context);\n        replayStats.addSegment(viewId);\n        replayStats.addRecord(viewId);\n        var removeMessageListener = addEventListener(worker, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored' || data.type === 'initialized') {\n                return;\n            }\n            if (data.id === _this.id) {\n                replayStats.addWroteData(viewId, data.additionalBytesCount);\n                if (data.type === 'flushed') {\n                    onFlushed(data.result, data.rawBytesCount);\n                    removeMessageListener();\n                }\n                else {\n                    onWrote(data.compressedBytesCount);\n                }\n            }\n            else if (data.id > _this.id) {\n                // Messages should be received in the same order as they are sent, so if we receive a\n                // message with an id superior to this Segment instance id, we know that another, more\n                // recent Segment instance is being used.\n                //\n                // In theory, a \"flush\" response should have been received at this point, so the listener\n                // should already have been removed. But if something goes wrong and we didn't receive a\n                // \"flush\" response, remove the listener to avoid any leak, and send a monitor message to\n                // help investigate the issue.\n                removeMessageListener();\n                addTelemetryDebug(\"Segment did not receive a 'flush' response before being replaced.\");\n            }\n        }).stop;\n        sendToExtension('record', { record: initialRecord, segment: this.metadata });\n        this.worker.postMessage({ data: \"{\\\"records\\\":[\".concat(JSON.stringify(initialRecord)), id: this.id, action: 'write' });\n    }\n    Segment.prototype.addRecord = function (record) {\n        var _a;\n        this.metadata.start = Math.min(this.metadata.start, record.timestamp);\n        this.metadata.end = Math.max(this.metadata.end, record.timestamp);\n        this.metadata.records_count += 1;\n        replayStats.addRecord(this.metadata.view.id);\n        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        sendToExtension('record', { record: record, segment: this.metadata });\n        this.worker.postMessage({ data: \",\".concat(JSON.stringify(record)), id: this.id, action: 'write' });\n    };\n    Segment.prototype.flush = function (reason) {\n        this.worker.postMessage({\n            data: \"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"),\n            id: this.id,\n            action: 'flush',\n        });\n        this.flushReason = reason;\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { Segment } from './segment';\nexport var SEGMENT_DURATION_LIMIT = 30 * 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, applicationId, sessionManager, viewContexts, httpRequest, worker) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(applicationId, sessionManager, viewContexts); }, httpRequest, worker);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, worker) {\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(9 /* 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(flushReason);\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    function createNewSegment(creationReason, initialRecord) {\n        var context = getSegmentContext();\n        if (!context) {\n            return;\n        }\n        var segment = new Segment(worker, context, creationReason, initialRecord, function (compressedSegmentBytesCount) {\n            if (!segment.flushReason && compressedSegmentBytesCount > SEGMENT_BYTES_LIMIT) {\n                flushSegment('segment_bytes_limit');\n            }\n        }, function (data, rawSegmentBytesCount) {\n            var payload = buildReplayPayload(data, segment.metadata, rawSegmentBytesCount);\n            if (isPageExitReason(segment.flushReason)) {\n                httpRequest.sendOnExit(payload);\n            }\n            else {\n                httpRequest.send(payload);\n            }\n        });\n        state = {\n            status: 1 /* SegmentCollectionStatus.SegmentPending */,\n            segment: segment,\n            expirationTimeoutId: setTimeout(function () {\n                flushSegment('segment_duration_limit');\n            }, SEGMENT_DURATION_LIMIT),\n        };\n    }\n    return {\n        addRecord: function (record) {\n            switch (state.status) {\n                case 0 /* SegmentCollectionStatus.WaitingForInitialRecord */:\n                    createNewSegment(state.nextSegmentCreationReason, record);\n                    break;\n                case 1 /* SegmentCollectionStatus.SegmentPending */:\n                    state.segment.addRecord(record);\n                    break;\n            }\n        },\n        stop: function () {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewContexts) {\n    var session = sessionManager.findTrackedSession();\n    var viewContext = viewContexts.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","export const workerString = \"!function(){\\\"use strict\\\";function t(t){for(var e=t.length;--e>=0;)t[e]=0}var e=256,a=286,n=30,r=15,i=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]),s=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]),h=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),l=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),_=new Array(576);t(_);var o=new Array(60);t(o);var d=new Array(512);t(d);var u=new Array(256);t(u);var f=new Array(29);t(f);var c,p,g,w=new Array(n);function v(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 b(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}t(w);var m=function(t){return t<256?d[t]:d[256+(t>>>7)]},y=function(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},k=function(t,e,a){t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,y(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)},z=function(t,e,a){k(t,a[2*e],a[2*e+1])},x=function(t,e){var a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},A=function(t,e,a){var n,i,s=new Array(16),h=0;for(n=1;n<=r;n++)s[n]=h=h+a[n-1]<<1;for(i=0;i<=e;i++){var l=t[2*i+1];0!==l&&(t[2*i]=x(s[l]++,l))}},U=function(t){var e;for(e=0;e<a;e++)t.dyn_ltree[2*e]=0;for(e=0;e<n;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?y(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},C=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]},E=function(t,e,a){for(var n=t.heap[a],r=a<<1;r<=t.heap_len&&(r<t.heap_len&&C(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!C(e,n,t.heap[r],t.depth));)t.heap[a]=t.heap[r],a=r,r<<=1;t.heap[a]=n},S=function(t,a,n){var r,h,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],h=t.pending_buf[t.l_buf+o],o++,0===r?z(t,h,a):(l=u[h],z(t,l+e+1,a),0!==(_=i[l])&&(h-=f[l],k(t,h,_)),r--,l=m(r),z(t,l,n),0!==(_=s[l])&&(r-=w[l],k(t,r,_)))}while(o<t.last_lit);z(t,256,a)},D=function(t,e){var a,n,i,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*(i=t.heap[++t.heap_len]=o<2?++o:0)]=1,t.depth[i]=0,t.opt_len--,l&&(t.static_len-=h[2*i+1]);for(e.max_code=o,a=t.heap_len>>1;a>=1;a--)E(t,s,a);i=_;do{a=t.heap[1],t.heap[1]=t.heap[t.heap_len--],E(t,s,1),n=t.heap[1],t.heap[--t.heap_max]=a,t.heap[--t.heap_max]=n,s[2*i]=s[2*a]+s[2*n],t.depth[i]=(t.depth[a]>=t.depth[n]?t.depth[a]:t.depth[n])+1,s[2*a+1]=s[2*n+1]=i,t.heap[1]=i++,E(t,s,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var a,n,i,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<=r;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;)(i=t.heap[--a])>o||(_[2*i+1]!==s&&(t.opt_len+=(s-_[2*i+1])*_[2*i],_[2*i+1]=s),n--)}}(t,e),A(s,o,t.bl_count)},M=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))},j=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{z(t,r,t.bl_tree)}while(0!=--h);else 0!==r?(r!==i&&(z(t,r,t.bl_tree),h--),z(t,16,t.bl_tree),k(t,h-3,2)):h<=10?(z(t,17,t.bl_tree),k(t,h-3,3)):(z(t,18,t.bl_tree),k(t,h-11,7));h=0,i=r,0===s?(l=138,_=3):r===s?(l=6,_=3):(l=7,_=4)}},I=!1,L=function(t,e,a,n){k(t,0+(n?1:0),3),function(t,e,a,n){B(t),n&&(y(t,a),y(t,~a)),t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a}(t,e,a,!0)},T=function(t,a,n,r){var i,s,h=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=function(t){var a,n=4093624447;for(a=0;a<=31;a++,n>>>=1)if(1&n&&0!==t.dyn_ltree[2*a])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(a=32;a<e;a++)if(0!==t.dyn_ltree[2*a])return 1;return 0}(t)),D(t,t.l_desc),D(t,t.d_desc),h=function(t){var e;for(M(t,t.dyn_ltree,t.l_desc.max_code),M(t,t.dyn_dtree,t.d_desc.max_code),D(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*l[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!==a?L(t,a,n,r):4===t.strategy||s===i?(k(t,2+(r?1:0),3),S(t,_,o)):(k(t,4+(r?1:0),3),function(t,e,a,n){var r;for(k(t,e-257,5),k(t,a-1,5),k(t,n-4,4),r=0;r<n;r++)k(t,t.bl_tree[2*l[r]+1],3);j(t,t.dyn_ltree,e-1),j(t,t.dyn_dtree,a-1)}(t,t.l_desc.max_code+1,t.d_desc.max_code+1,h+1),S(t,t.dyn_ltree,t.dyn_dtree)),U(t),r&&B(t)},H={_tr_init:function(t){I||(!function(){var t,e,l,b,m,y=new Array(16);for(l=0,b=0;b<28;b++)for(f[b]=l,t=0;t<1<<i[b];t++)u[l++]=b;for(u[l-1]=b,m=0,b=0;b<16;b++)for(w[b]=m,t=0;t<1<<s[b];t++)d[m++]=b;for(m>>=7;b<n;b++)for(w[b]=m<<7,t=0;t<1<<s[b]-7;t++)d[256+m++]=b;for(e=0;e<=r;e++)y[e]=0;for(t=0;t<=143;)_[2*t+1]=8,t++,y[8]++;for(;t<=255;)_[2*t+1]=9,t++,y[9]++;for(;t<=279;)_[2*t+1]=7,t++,y[7]++;for(;t<=287;)_[2*t+1]=8,t++,y[8]++;for(A(_,287,y),t=0;t<n;t++)o[2*t+1]=5,o[2*t]=x(t,5);c=new v(_,i,257,a,r),p=new v(o,s,0,n,r),g=new v(new Array(0),h,0,19,7)}(),I=!0),t.l_desc=new b(t.dyn_ltree,c),t.d_desc=new b(t.dyn_dtree,p),t.bl_desc=new b(t.bl_tree,g),t.bi_buf=0,t.bi_valid=0,U(t)},_tr_stored_block:L,_tr_flush_block:T,_tr_tally:function(t,a,n){return t.pending_buf[t.d_buf+2*t.last_lit]=a>>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&a,t.pending_buf[t.l_buf+t.last_lit]=255&n,t.last_lit++,0===a?t.dyn_ltree[2*n]++:(t.matches++,a--,t.dyn_ltree[2*(u[n]+e+1)]++,t.dyn_dtree[2*m(a)]++),t.last_lit===t.lit_bufsize-1},_tr_align:function(t){k(t,2,3),z(t,256,_),function(t){16===t.bi_valid?(y(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)}(t)}},R=function(t,e,a,n){for(var r=65535&t|0,i=t>>>16&65535|0,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|0},K=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}()),N=function(t,e,a,n){var r=K,i=n+a;t^=-1;for(var s=n;s<i;s++)t=t>>>8^r[255&(t^e[s])];return-1^t},O={2:\\\"need dictionary\\\",1:\\\"stream end\\\",0:\\\"\\\",\\\"-1\\\":\\\"file error\\\",\\\"-2\\\":\\\"stream error\\\",\\\"-3\\\":\\\"data error\\\",\\\"-4\\\":\\\"insufficient memory\\\",\\\"-5\\\":\\\"buffer error\\\",\\\"-6\\\":\\\"incompatible version\\\"},q=0,F=2,G=3,J=4,P=0,Q=1,V=-1,W=0,X=8,Y=H._tr_init,Z=H._tr_stored_block,$=H._tr_flush_block,tt=H._tr_tally,et=H._tr_align,at=q,nt=1,rt=G,it=J,st=5,ht=P,lt=Q,_t=-2,ot=-3,dt=-5,ut=V,ft=1,ct=2,pt=3,gt=4,wt=W,vt=2,bt=X,mt=258,yt=262,kt=103,zt=113,xt=666,At=function(t,e){return t.msg=O[e],e},Ut=function(t){return(t<<1)-(t>4?9:0)},Bt=function(t){for(var e=t.length;--e>=0;)t[e]=0},Ct=function(t,e,a){return(e<<t.hash_shift^a)&t.hash_mask},Et=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))},St=function(t,e){$(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,Et(t.strm)},Dt=function(t,e){t.pending_buf[t.pending++]=e},Mt=function(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},jt=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-yt?t.strstart-(t.w_size-yt):0,_=t.window,o=t.w_mask,d=t.prev,u=t.strstart+mt,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=mt-(u-i),i=u-mt,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},It=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-yt)){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=R(s.adler,h,o,l):2===s.state.wrap&&(s.adler=N(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=Ct(t,t.ins_h,t.window[i+1]);t.insert&&(t.ins_h=Ct(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<yt&&0!==t.strm.avail_in)},Lt=function(t,e){for(var a,n;;){if(t.lookahead<yt){if(It(t),t.lookahead<yt&&e===at)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=Ct(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-yt&&(t.match_length=jt(t,a)),t.match_length>=3)if(n=tt(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=Ct(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=Ct(t,t.ins_h,t.window[t.strstart+1]);else n=tt(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(n&&(St(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===it?(St(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(St(t,!1),0===t.strm.avail_out)?1:2},Tt=function(t,e){for(var a,n,r;;){if(t.lookahead<yt){if(It(t),t.lookahead<yt&&e===at)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=Ct(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-yt&&(t.match_length=jt(t,a),t.match_length<=5&&(t.strategy===ft||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=tt(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=Ct(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&&(St(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if((n=tt(t,0,t.window[t.strstart-1]))&&St(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=tt(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===it?(St(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(St(t,!1),0===t.strm.avail_out)?1:2};function Ht(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 Rt=[new Ht(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(It(t),0===t.lookahead&&e===at)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,St(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-yt&&(St(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===it?(St(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(St(t,!1),t.strm.avail_out),1)})),new Ht(4,4,8,4,Lt),new Ht(4,5,16,8,Lt),new Ht(4,6,32,32,Lt),new Ht(4,4,16,16,Tt),new Ht(8,16,32,32,Tt),new Ht(8,16,128,128,Tt),new Ht(8,32,128,256,Tt),new Ht(32,128,258,1024,Tt),new Ht(32,258,258,4096,Tt)];function Kt(){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=bt,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 Nt=function(t){if(!t||!t.state)return At(t,_t);t.total_in=t.total_out=0,t.data_type=vt;var e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:zt,t.adler=2===e.wrap?0:1,e.last_flush=at,Y(e),ht},Ot=function(t){var e,a=Nt(t);return a===ht&&((e=t.state).window_size=2*e.w_size,Bt(e.head),e.max_lazy_match=Rt[e.level].max_lazy,e.good_match=Rt[e.level].good_length,e.nice_match=Rt[e.level].nice_length,e.max_chain_length=Rt[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},qt=function(t,e,a,n,r,i){if(!t)return _t;var s=1;if(e===ut&&(e=6),n<0?(s=0,n=-n):n>15&&(s=2,n-=16),r<1||r>9||a!==bt||n<8||n>15||e<0||e>9||i<0||i>gt)return At(t,_t);8===n&&(n=9);var h=new Kt;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,Ot(t)},Ft={deflateInit:function(t,e){return qt(t,e,bt,15,8,wt)},deflateInit2:qt,deflateReset:Ot,deflateResetKeep:Nt,deflateSetHeader:function(t,e){return t&&t.state?2!==t.state.wrap?_t:(t.state.gzhead=e,ht):_t},deflate:function(t,e){var a,n;if(!t||!t.state||e>st||e<0)return t?At(t,_t):_t;var r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===xt&&e!==it)return At(t,0===t.avail_out?dt:_t);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>=ct||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=N(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>=ct||r.level<2?4:0),Dt(r,3),r.status=zt);else{var s=bt+(r.w_bits-8<<4)<<8;s|=(r.strategy>=ct||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=zt,Mt(r,s),0!==r.strstart&&(Mt(r,t.adler>>>16),Mt(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=N(t.adler,r.pending_buf,r.pending-a,a)),Et(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=N(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=N(t.adler,r.pending_buf,r.pending-a,a)),Et(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=N(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=N(t.adler,r.pending_buf,r.pending-a,a)),Et(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=N(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.status=kt)}else r.status=kt;if(r.status===kt&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&Et(t),r.pending+2<=r.pending_buf_size&&(Dt(r,255&t.adler),Dt(r,t.adler>>8&255),t.adler=0,r.status=zt)):r.status=zt),0!==r.pending){if(Et(t),0===t.avail_out)return r.last_flush=-1,ht}else if(0===t.avail_in&&Ut(e)<=Ut(i)&&e!==it)return At(t,dt);if(r.status===xt&&0!==t.avail_in)return At(t,dt);if(0!==t.avail_in||0!==r.lookahead||e!==at&&r.status!==xt){var h=r.strategy===ct?function(t,e){for(var a;;){if(0===t.lookahead&&(It(t),0===t.lookahead)){if(e===at)return 1;break}if(t.match_length=0,a=tt(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(St(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===it?(St(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(St(t,!1),0===t.strm.avail_out)?1:2}(r,e):r.strategy===pt?function(t,e){for(var a,n,r,i,s=t.window;;){if(t.lookahead<=mt){if(It(t),t.lookahead<=mt&&e===at)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+mt;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=mt-(i-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=tt(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=tt(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(St(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===it?(St(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(St(t,!1),0===t.strm.avail_out)?1:2}(r,e):Rt[r.level].func(r,e);if(3!==h&&4!==h||(r.status=xt),1===h||3===h)return 0===t.avail_out&&(r.last_flush=-1),ht;if(2===h&&(e===nt?et(r):e!==st&&(Z(r,0,0,!1),e===rt&&(Bt(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),Et(t),0===t.avail_out))return r.last_flush=-1,ht}return e!==it?ht:r.wrap<=0?lt:(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)):(Mt(r,t.adler>>>16),Mt(r,65535&t.adler)),Et(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?ht:lt)},deflateEnd:function(t){if(!t||!t.state)return _t;var e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==kt&&e!==zt&&e!==xt?At(t,_t):(t.state=null,e===zt?At(t,ot):ht)},deflateSetDictionary:function(t,e){var a=e.length;if(!t||!t.state)return _t;var n=t.state,r=n.wrap;if(2===r||1===r&&42!==n.status||n.lookahead)return _t;if(1===r&&(t.adler=R(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,It(n);n.lookahead>=3;){var _=n.strstart,o=n.lookahead-2;do{n.ins_h=Ct(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,It(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,ht},deflateInfo:\\\"pako deflate (from Nodeca project)\\\"};for(var Gt=new Uint8Array(256),Jt=0;Jt<256;Jt++)Gt[Jt]=Jt>=252?6:Jt>=248?5:Jt>=240?4:Jt>=224?3:Jt>=192?2:1;Gt[254]=Gt[254]=1;var Pt=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},Qt=Object.prototype.toString,Vt=q,Wt=F,Xt=G,Yt=J,Zt=P,$t=Q,te=V,ee=W,ae=X;function ne(){this.options={level:te,method:ae,chunkSize:16384,windowBits:15,memLevel:8,strategy:ee};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 Pt,this.strm.avail_out=0;var e=Ft.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(e!==Zt)throw new Error(O[e]);if(t.header&&Ft.deflateSetHeader(this.strm,t.header),t.dictionary){var a;if(a=\\\"[object ArrayBuffer]\\\"===Qt.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,(e=Ft.deflateSetDictionary(this.strm,a))!==Zt)throw new Error(O[e]);this._dict_set=!0}}function re(t){return function(){for(var e=[],a=0;a<arguments.length;a++)e[a]=arguments[a];try{return t.apply(void 0,e)}catch(t){try{self.postMessage({type:\\\"errored\\\",error:t})}catch(e){self.postMessage({type:\\\"errored\\\",error:String(t)})}}}}ne.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?Yt:Vt,\\\"[object ArrayBuffer]\\\"===Qt.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===Wt||n===Xt)&&r.avail_out<=6)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else{if((a=Ft.deflate(r,n))===$t)return r.next_out>0&&this.onData(r.output.subarray(0,r.next_out)),a=Ft.deflateEnd(this.strm),this.onEnd(a),this.ended=!0,a===Zt;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},ne.prototype.onData=function(t){this.chunks.push(t)},ne.prototype.onEnd=function(t){t===Zt&&(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},re((function(){var t=new ne,e=0;function a(a){var n=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);return t.push(n,F),e+=n.length,n.length}self.addEventListener(\\\"message\\\",re((function(n){var r=n.data;switch(r.action){case\\\"init\\\":self.postMessage({type:\\\"initialized\\\"});break;case\\\"write\\\":var i=a(r.data);self.postMessage({type:\\\"wrote\\\",id:r.id,compressedBytesCount:t.chunks.reduce((function(t,e){return t+e.length}),0),additionalBytesCount:i});break;case\\\"flush\\\":i=r.data?a(r.data):0,t.push(\\\"\\\",J),self.postMessage({type:\\\"flushed\\\",id:r.id,result:t.result,additionalBytesCount:i,rawBytesCount:e}),t=new ne,e=0}})))}))()}();\"\n","import { addTelemetryError, display, includes, addEventListener } from '@datadog/browser-core';\nimport { workerString } from '@datadog/browser-worker/string';\nvar workerURL;\nexport function createDeflateWorker() {\n    // Lazily compute the worker URL to allow importing the SDK in NodeJS\n    if (!workerURL) {\n        workerURL = URL.createObjectURL(new Blob([workerString]));\n    }\n    return new Worker(workerURL);\n}\nvar state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(callback, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    switch (state.status) {\n        case 0 /* DeflateWorkerStatus.Nil */:\n            state = { status: 1 /* DeflateWorkerStatus.Loading */, callbacks: [callback] };\n            doStartDeflateWorker(createDeflateWorkerImpl);\n            break;\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.callbacks.push(callback);\n            break;\n        case 2 /* DeflateWorkerStatus.Error */:\n            callback();\n            break;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            callback(state.worker);\n            break;\n    }\n}\nexport function resetDeflateWorkerState() {\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\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(createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker_1 = createDeflateWorkerImpl();\n        addEventListener(worker_1, 'error', onError);\n        addEventListener(worker_1, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(data.error);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(worker_1);\n            }\n        });\n        worker_1.postMessage({ action: 'init' });\n        return worker_1;\n    }\n    catch (error) {\n        onError(error);\n    }\n}\nfunction onInitialized(worker) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.callbacks.forEach(function (callback) { return callback(worker); });\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: worker };\n    }\n}\nfunction onError(error) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error('Session Replay recording failed to start: an error occurred while creating the Worker:', error);\n        if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n            display.error('Please make sure CSP is correctly configured ' +\n                'https://docs.datadoghq.com/real_user_monitoring/faq/content_security_policy');\n        }\n        else {\n            addTelemetryError(error);\n        }\n        state.callbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error);\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=startDeflateWorker.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, viewContexts, isRecordingStarted) {\n    var session = sessionManager.findTrackedSession();\n    var errorType = getErrorType(session, isRecordingStarted);\n    var viewContext = viewContexts.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.sessionReplayAllowed) {\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","// 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';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi);\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';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"4.45.0\",\n        // This API method is intentionally not monitored, since the only thing executed is the\n        // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and\n        // we don't want to interfere with the user uncaught exceptions.\n        onReady: 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    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, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats } from '../domain/replayStats';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { startDeflateWorker } from '../domain/segmentCollection';\nimport { isBrowserSupported } from './isBrowserSupported';\nexport function makeRecorderApi(startRecordingImpl, startDeflateWorkerImpl) {\n    if (startDeflateWorkerImpl === void 0) { startDeflateWorkerImpl = startDeflateWorker; }\n    if (canUseEventBridge() || !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    var state = {\n        status: 0 /* RecorderStatus.Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* RecorderStatus.IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* RecorderStatus.Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getReplayStats: getReplayStats,\n        getSessionReplayLink: function (configuration, sessionManager, viewContexts) {\n            return getSessionReplayLink(configuration, sessionManager, viewContexts, state.status !== 0 /* RecorderStatus.Stopped */);\n        },\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts) {\n            lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n                if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.sessionReplayAllowed) {\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    return;\n                }\n                state = { status: 2 /* RecorderStatus.Starting */ };\n                runOnReadyState('interactive', function () {\n                    if (state.status !== 2 /* RecorderStatus.Starting */) {\n                        return;\n                    }\n                    startDeflateWorkerImpl(function (worker) {\n                        if (state.status !== 2 /* RecorderStatus.Starting */) {\n                            return;\n                        }\n                        if (!worker) {\n                            state = {\n                                status: 0 /* RecorderStatus.Stopped */,\n                            };\n                            return;\n                        }\n                        var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, worker).stop;\n                        state = {\n                            status: 3 /* RecorderStatus.Started */,\n                            stopRecording: stopRecording,\n                        };\n                    });\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* RecorderStatus.Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* RecorderStatus.Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* RecorderStatus.Stopped */,\n                };\n            };\n            if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () { return state.status === 3 /* RecorderStatus.Started */; },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { timeStampNow, createHttpRequest, addTelemetryDebug } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, worker, httpRequest) {\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* 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 _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, viewContexts, replayRequest, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n    }), stopRecording = _b.stop, takeSubsequentFullSnapshot = _b.takeSubsequentFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function () {\n        flushMutations();\n        addRecord({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        takeSubsequentFullSnapshot(view.startClocks.timeStamp);\n    }).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { noop, willSyntheticsInjectRum, assign, BoundedBuffer, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, checkUser, sanitizeUser, sanitize, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nexport function makeRumPublicApi(startRumImpl, recorderApi, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.ignoreInitIfSyntheticsWillInjectRum, ignoreInitIfSyntheticsWillInjectRum = _c === void 0 ? true : _c;\n    var isAlreadyInitialized = false;\n    var globalContextManager = createContextManager(\"global context\" /* CustomerDataType.GlobalContext */);\n    var userContextManager = createContextManager(\"user\" /* CustomerDataType.User */);\n    var getInternalContextStrategy = function () { return undefined; };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var stopSessionStrategy = noop;\n    var getSessionReplayLinkStrategy = function () { return undefined; };\n    var bufferApiCalls = new BoundedBuffer();\n    var addTimingStrategy = function (name, time) {\n        if (time === void 0) { time = timeStampNow(); }\n        bufferApiCalls.add(function () { return addTimingStrategy(name, time); });\n    };\n    var startViewStrategy = function (options, startClocks) {\n        if (startClocks === void 0) { startClocks = clocksNow(); }\n        bufferApiCalls.add(function () { return startViewStrategy(options, startClocks); });\n    };\n    var addActionStrategy = function (action, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    var addFeatureFlagEvaluationStrategy = function (key, value) {\n        bufferApiCalls.add(function () { return addFeatureFlagEvaluationStrategy(key, value); });\n    };\n    function initRum(initConfiguration) {\n        // This function should be available, regardless of initialization success.\n        getInitConfigurationStrategy = function () { return deepClone(initConfiguration); };\n        // If we are in a Synthetics test configured to automatically inject a RUM instance, we want to\n        // completely discard the customer application RUM instance by ignoring their init() call.  But,\n        // 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        var eventBridgeAvailable = canUseEventBridge();\n        if (eventBridgeAvailable) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        if (!canInitRum(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.trackViewsManually) {\n            doStartRum(initConfiguration, configuration);\n        }\n        else {\n            // drain beforeInitCalls by buffering them until we start RUM\n            // if we get a startView, drain re-buffered calls before continuing to drain beforeInitCalls\n            // in order to ensure that calls are processed in order\n            var beforeInitCalls = bufferApiCalls;\n            bufferApiCalls = new BoundedBuffer();\n            startViewStrategy = function (options) {\n                doStartRum(initConfiguration, configuration, options);\n            };\n            beforeInitCalls.drain();\n        }\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(initConfiguration, configuration, initialViewOptions) {\n        var startRumResults = startRumImpl(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions);\n        getSessionReplayLinkStrategy = function () {\n            return recorderApi.getSessionReplayLink(configuration, startRumResults.session, startRumResults.viewContexts);\n        };\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, addFeatureFlagEvaluationStrategy = startRumResults.addFeatureFlagEvaluation, getInternalContextStrategy = startRumResults.getInternalContext, stopSessionStrategy = startRumResults.stopSession);\n        bufferApiCalls.drain();\n        recorderApi.onRumStart(startRumResults.lifeCycle, configuration, startRumResults.session, startRumResults.viewContexts);\n    }\n    var startView = monitor(function (options) {\n        var sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        startViewStrategy(sanitizedOptions);\n    });\n    var rumPublicApi = makePublicApi({\n        init: monitor(initRum),\n        /** @deprecated: use setGlobalContextProperty instead */\n        addRumGlobalContext: monitor(globalContextManager.add),\n        setGlobalContextProperty: monitor(globalContextManager.setContextProperty),\n        /** @deprecated: use removeGlobalContextProperty instead */\n        removeRumGlobalContext: monitor(globalContextManager.remove),\n        removeGlobalContextProperty: monitor(globalContextManager.removeContextProperty),\n        /** @deprecated: use getGlobalContext instead */\n        getRumGlobalContext: monitor(globalContextManager.get),\n        getGlobalContext: monitor(globalContextManager.getContext),\n        /** @deprecated: use setGlobalContext instead */\n        setRumGlobalContext: monitor(globalContextManager.set),\n        setGlobalContext: monitor(globalContextManager.setContext),\n        clearGlobalContext: monitor(globalContextManager.clearContext),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        addAction: monitor(function (name, context) {\n            addActionStrategy({\n                name: sanitize(name),\n                context: sanitize(context),\n                startClocks: clocksNow(),\n                type: \"custom\" /* ActionType.CUSTOM */,\n            });\n        }),\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                addErrorStrategy({\n                    error: error,\n                    handlingStack: handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            addTimingStrategy(sanitize(name), time);\n        }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(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        }),\n        removeUserProperty: monitor(userContextManager.removeContextProperty),\n        /** @deprecated: renamed to clearUser */\n        removeUser: monitor(userContextManager.clearContext),\n        clearUser: monitor(userContextManager.clearContext),\n        startView: startView,\n        stopSession: monitor(function () {\n            stopSessionStrategy();\n        }),\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n        /**\n         * This feature is currently in beta. For more information see the full [feature flag tracking guide](https://docs.datadoghq.com/real_user_monitoring/feature_flag_tracking/).\n         */\n        addFeatureFlagEvaluation: monitor(function (key, value) {\n            addFeatureFlagEvaluationStrategy(sanitize(key), sanitize(value));\n        }),\n        getSessionReplayLink: monitor(function () { return getSessionReplayLinkStrategy(); }),\n    });\n    return rumPublicApi;\n    function canInitRum(initConfiguration) {\n        if (isAlreadyInitialized) {\n            if (!initConfiguration.silentMultipleInit) {\n                display.error('DD_RUM is already initialized.');\n            }\n            return false;\n        }\n        return true;\n    }\n    function overrideInitConfigurationForBridge(initConfiguration) {\n        return assign({}, initConfiguration, {\n            applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n            clientToken: 'empty',\n            sessionSampleRate: 100,\n        });\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","import { sendToExtension, createPageExitObservable, addTelemetryConfiguration, startTelemetry, canUseEventBridge, getEventBridge, addTelemetryDebug, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewContexts } from '../domain/contexts/viewContexts';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/rumEventsCollection/action/actionCollection';\nimport { startErrorCollection } from '../domain/rumEventsCollection/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/rumEventsCollection/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/rumEventsCollection/resource/resourceCollection';\nimport { startViewCollection } from '../domain/rumEventsCollection/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 { serializeRumConfiguration } from '../domain/configuration';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nexport function startRum(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions) {\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(11 /* 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 = viewContexts.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(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle);\n    var pageExitObservable = createPageExitObservable();\n    pageExitObservable.subscribe(function (event) {\n        lifeCycle.notify(9 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    var session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        var batch = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable);\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batch.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, domMutationObservable, function () { return buildCommonContext(globalContextManager, userContextManager, recorderApi); }, reportError), viewContexts = _a.viewContexts, pageStateHistory = _a.pageStateHistory, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction;\n    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n    startLongTaskCollection(lifeCycle, session);\n    startResourceCollection(lifeCycle, configuration, session, pageStateHistory);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView;\n    var addError = startErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    startPerformanceCollection(lifeCycle, configuration);\n    var internalContext = startInternalContext(configuration.applicationId, session, viewContexts, actionContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n        session: session,\n        stopSession: function () { return session.expire(); },\n        getInternalContext: internalContext.get,\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, locationChangeObservable, domMutationObservable, buildCommonContext, reportError) {\n    var viewContexts = startViewContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var pageStateHistory = startPageStateHistory();\n    var _a = startActionCollection(lifeCycle, domMutationObservable, configuration, pageStateHistory), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, buildCommonContext, reportError);\n    return {\n        viewContexts: viewContexts,\n        pageStateHistory: pageStateHistory,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            viewContexts.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(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nexport function startLongTaskCollection(lifeCycle, sessionManager) {\n    lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, 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 !== 'longtask') {\n                break;\n            }\n            var session = sessionManager.findTrackedSession(entry.startTime);\n            if (!session || !session.longTaskAllowed) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry.toJSON() },\n            });\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, viewContexts, actionContexts, urlContexts) {\n    return {\n        get: function (startTime) {\n            var viewContext = viewContexts.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    sampleRate: window.datadogSampleRate,\n    replaySampleRate: 0,\n    trackInteractions: true,\n    defaultPrivacyLevel: \"mask-user-input\",\n  })\n}\n"],"names":["ConsoleApiName","log","debug","info","warn","error","display","api","args","_i","arguments","length","Object","prototype","hasOwnProperty","call","apply","globalConsole","console","catchUserErrors","fn","errorMsg","err","bind","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","i","l","Array","slice","concat","debugMode","setDebugMode","newDebugMode","monitor","callMonitored","this","context","e","displayIfDebugEnabled","includes","candidate","search","indexOf","arrayFrom","arrayLike","array","Set","forEach","item","push","find","predicate","objectValues","object","keys","map","key","objectEntries","startsWith","cssEscape","str","window","CSS","escape","replace","ch","asCodePoint","charCodeAt","toString","target","toAssign","source","getGlobalObject","globalThis","defineProperty","get","configurable","globalObject","_dd_temp_","self","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","test","undefined","TextEncoder","encode","Blob","size","getZoneJsOriginalValue","name","original","browserWindow","Zone","__symbol__","callback","delay","timeoutId","throttle","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","cancel","noop","getType","value","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","has","add","createCircularReferenceChecker","Date","getTime","RegExp","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","_a","sources_1","jsonStringify","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","toJSON","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","JSON_PATH_ROOT_ELEMENT","KEY_DECORATION_LENGTH","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","accumulatedCharacterCount","containerToProcess","shift","separatorLength","targetData","path","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","description","sanitizePrimitivesAndFunctions","sanitizedSource","Event","isTrusted","match","sanitizeObjects","sourceAsObject","currentPath","set","changeType","CUSTOMER_DATA_BYTES_LIMIT","warnIfCustomerDataLimitReached","bytesCount","customerDataType","BYTES_COMPUTATION_THROTTLING_DELAY","createContextManager","computeBytesCountImpl","bytesCountCache","alreadyWarned","computeBytesCountThrottled","getBytesCount","remove","newContext","getContext","setContext","setContextProperty","property","removeContextProperty","clearContext","BoundedBuffer","buffer","splice","drain","performDraw","threshold","Math","random","round","num","decimals","toFixed","isPercentage","isNumber","navigationStart","getCurrentSiteCache","ONE_SECOND","ONE_MINUTE","ONE_HOUR","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","generateUUID","placeholder","parseInt","findCommaSeparatedValue","rawString","matches","exec","safeTruncate","suffix","lastChar","correctedLength","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","document","cookie","getCookie","deleteCookie","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","event","canUseEventBridge","currentHost","location","hostname","bridge","some","allowedHost","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","exString","String","split","line","stackFrame","parts","CHROME_LINE_RE","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","ExperimentalFeature","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","handlingStack","startClocks","nonErrorPrefix","handling","isErrorInstance","Error","computeMessage","hasUsableStack","toStackTraceString","causes","parentSource","currentError","cause","type","flattenErrorCauses","fingerprint","tryToGetFingerprint","dd_fingerprint","result","formatErrorMessage","frame","createHandlingStack","formattedStack","sanitizeUser","newUser","user","enabledExperimentalFeatures","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","shallowClone","objectHasValue","isEmptyObject","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","filter","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_STORE_KEY","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","isSessionInExpiredState","session","expandSessionState","expire","toSessionString","toSessionState","sessionString","isValidSessionString","entry","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","selectCookieStrategy","initConfiguration","cookieOptions","useSecureSessionCookie","useCrossSiteSessionCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","pop","getCurrentSite","buildCookieOptions","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","persistSession","retrieveSession","retrieveSessionCookie","clearSession","deleteSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","id","tryOldCookiesMigration","LOCAL_STORAGE_TEST_KEY","persistInLocalStorage","sessionState","localStorage","setItem","retrieveSessionFromLocalStorage","getItem","clearSessionFromLocalStorage","removeItem","ongoingOperations","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","bufferedOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","lockEnabled","isLockEnabled","next","currentLock","currentSession","lock","retryLater","processedSession","process","after","chrome","navigator","userAgent","sessionStore","currentNumberOfRetries","nextOperations","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionStoreStrategyType","allowFallbackToLocalStorage","testKey","retrievedId","selectLocalStorageStrategy","startSessionStore","productKey","computeSessionState","renewObservable","expireObservable","watchSessionTimeoutId","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","Number","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewSessionState","renewSessionInCache","expandSession","getSession","stop","normalizeUrl","buildUrl","getLinkElementOrigin","href","getOrigin","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","URL","element","origin","sanitizedHost","host","protocol","INTAKE_SITE_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_AP1","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","endpointType","configurationTags","buildUrlWithParameters","proxy","proxyUrl","normalizedProxyUrl_1","encodeURIComponent","site","internalAnalyticsSubdomain","domainParts","extension","subdomain","buildEndpointHost","normalizedProxyUrl_2","createEndpointUrlWithParametersBuilder","build","flushReason","retry","clientToken","tags","COLLECT_FLUSH_REASON","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","TAG_SIZE_LIMIT","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","configuration","env","service","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeUrlPrefixes","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","_b","_c","sessionSampleRate","sampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","enableExperimentalFeatures","flag","beforeSend","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","isMatchOption","itemType","matchList","list","useStartsWith","clearTracingIfNeeded","status","isAborted","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","getCrypto","findTrackedSession","propagatorTypes","tracingHeaders","tracingOption","allowedTracingUrls","TraceIdentifier","traceSampleRate","propagatorType","toDecimalString","traceparent","toPaddedHexadecimalString","b3","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","mod","floor","offset","validateAndBuildRumConfiguration","_d","_e","_f","sessionReplaySampleRate","premiumSampleRate","replaySampleRate","tracingSampleRate","excludedActivityUrls","allowedTracingOrigins","tracingOptions_1","option","expectedItem","tracingOptions_2","legacyMatchOption","convertLegacyMatchOptionToTracingOption","validateAndBuildTracingOptions","baseConfiguration","trackUserInteractions","trackInteractions","trackFrustrations","actionNameAttribute","oldPlansBehavior","trackViewsManually","trackResources","trackLongTasks","defaultPrivacyLevel","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","buildCommonContext","globalContextManager","userContextManager","recorderApi","hasReplay","isRecording","sendToExtension","payload","__ddBrowserSdkExtensionCallback","onRawTelemetryEventCollected","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","telemetryConfigurationEnabled","startTelemetry","telemetryService","contextProvider","rawEvent","event_1","_dd","format_version","telemetry","experimental_features","toTelemetryEvent","addTelemetryError","setContextProvider","provider","enabled","addTelemetryDebug","addTelemetry","kind","scrubCustomerFrames","formatError","allowedFrameUrl","addEventListener","eventTarget","eventName","listener","addEventListeners","eventNames","once","capture","passive","wrappedListener","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","isPageExitReason","reason","getMutationObserverConstructor","constructor","MutationObserver","originalInstance","runOnReadyState","expectedReadyState","readyState","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","computeResourceKind","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","areInOrder","numbers","computePerformanceResourceDetails","validEntry","toValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","responseEnd","first_byte","connect","ssl","dns","hasRedirection","redirect","computeSize","decodedBodySize","isAllowedRequestUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","getParentNode","parentNode","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","supportPerformanceObject","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","startPerformanceCollection","lifeCycle","handleRumPerformanceEntries","forcedAttributes","getEntriesByType","relativePerformanceTiming","computeRelativePerformanceTiming","performanceEntries_1","getEntries","handlePerformanceEntryList_1","entries","mainEntries","experimentalEntries","observe","buffered","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","sendTimingIfPointerIsNotCancelled","sendTiming","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","viewportObservable","viewport","ErrorSource","AGENT","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","getSyntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","initViewportObservable","updateDimension","getViewportDimension","visual","visualViewport","width","scale","height","innerWidth","innerHeight","limitModification","modifiableFieldPaths","modifier","clone","fieldPath","fieldType","newValue","current","field","isValidObjectContaining","newType","fields","isValidObject","modifiableFieldPathsByEvent","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","startRumAssembly","viewContexts","urlContexts","actionContexts","reportError","eventRateLimiters","syntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","commonContext","actionId","findActionId","serverRumEvent","drift","plan","session_sample_rate","session_replay_sample_rate","browser_sdk_version","application","view","referrer","action","synthetics","ci_test","viewportDimension","has_replay","usr","rateLimitReached","shouldSend","xhrObservable","LifeCycle","AbstractLifeCycle","callbacks","eventCallbacks","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","ValueHistory","maxEntries","clearOldValuesInterval","clearOldValues","endTime","index","close","unshift","closeActive","latestEntry","findAll","reset","oldTimeThreshold","VIEW_CONTEXT_TIME_OUT_DELAY","instrumentMethod","method","instrumentationFactory","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","state","startContext","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","initFetchObservable","fetch","originalFetch","input","init","responsePromise","afterSend","Request","reportFetch","response","DOMException","code","ABORT_ERR","responseType","then","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","rawContext","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","tryToClone","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer_1","offset_1","chunk","bytesLimit","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeoutId","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","every","isStopped","tryAppend","first","second","sqrt","pow","clientX","clientY","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","getActionNameFromElement","userProgrammaticAttribute","getActionNameFromElementProgrammatically","getActionNameFromElementForStrategies","priorityStrategies","fallbackStrategies","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","nodeName","labelledByAttribute","refElement","getElementById","MAX_PARENTS_TO_CONSIDER","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","query","element_1","textToReplace","documentMode","textContent","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","tagName","classList","className","getSelectorFromElement","targetElementSelector","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","childSelector","selectorGetters_1","elementSelector","selectorGetter","fullSelector","supportScopeSelector","parent","child","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","computeFrustration","clicks","rageClick","getUserActivity","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","msMatchesSelector","CLICK_ACTION_MAX_DURATION","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","currentClickChain","history","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onPointerUp","userActivity","listeners","localUserActivity_1","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","position","x","left","y","top","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","validate","viewEndedSubscription","endClocks","stopSubscription","startClickAction","rageClick_1","finalizeClicks","activityEndTime","historyEntry","eventCountsSubscription","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","events","processAction","pageStateHistory","autoActionProperties","isAutoAction","loading_time","long_task","resource","in_foreground","isInActivePageStateAt","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","messageObj","errorObj","tryToParseMessage","instrumentOnError","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","param","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","trackFirstHiddenSingleton","RawReportType","intervention","deprecation","cspViolation","initReportObservable","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","startErrorCollection","featureFlagContexts","errorObservable","consoleError","trackConsoleError","trackRuntimeError","trackReportError","handling_stack","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","processError","addError","rawError","doStartErrorCollection","matchRequestTiming","sameNameEntries","getEntriesByName","candidates","errorMargin","startResourceCollection","matchingTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","indexingInfo","computeIndexingInfo","NO_RESOURCE_DURATION_FROZEN_STATE","requestCrossedFrozenState","pageState","computeRequestDuration","pageStateInfo","computePageStateInfo","resourceEvent","status_code","performanceEntry","requestInput","requestInit","processRequest","entries_1","processResourceEntry","entryMetrics","computeEntryTracingInfo","resourceStart","discarded","resourceAllowed","RESOURCE_PAGE_STATES","page_states","page_was_discarded","wasDiscarded","mapToForegroundPeriods","pageStateServerEntries","foregroundPeriods","trackFirstHidden","visibilityState","TIMING_MAXIMUM_DELAY","KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY","trackInitialViewTimings","setLoadEvent","scheduleViewUpdate","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","trackFirstContentfulPaintTiming","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","trackLargestContentfulPaintTiming","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","scheduleStop","getScrollX","scrollX","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","THROTTLE_SCROLL_DURATION","trackViewMetrics","loadingType","viewStart","scrollMetrics","stopCLSTracking","viewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","max","trackLoadingTime","newLoadingTime","loadingTime","SCROLLMAP","computeScrollValues","scrollHeight","scrollDepth","scrollTop","maxDepth","maxDepthScrollHeight","maxDepthTime","maxDepthScrollTop","stopLoadingTimeTracking","stopScrollMetricsTracking","getScrollValues","handleScrollEvent","trackScrollMetrics","newScrollMetrics","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","getScrollMetrics","scrollingElement","documentElement","KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","trackViews","locationChangeObservable","areViewsTrackedAutomatically","initialViewOptions","locationChangeSubscription","currentView","startNewView","viewOptions","initialLocation","customTimings","documentVersion","sessionIsActive","triggerViewUpdate","cancelScheduleViewUpdate","stopViewMetricsTracking","scheduleStopInitialViewTimingsTracking","viewId","trackViewEventCounts","scheduleStopEventCountsTracking","keepAliveIntervalId","currentEnd","isActive","addTiming","time","looksLikeRelativeTime","sanitized","sanitizeTiming","newView","pageExitEvent","currentLocation","otherLocation","hash","correspondingId","oldLocation","newLocation","substr","getPathFromHash","renewViewOnLocationChange","startView","startViewCollection","replayStats","getReplayStats","pageStatesEnabled","PAGE_STATES","pageStates","viewEvent","document_version","replay_stats","cumulative_layout_shift","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","is_active","largest_contentful_paint","load_event","discardNegativeDuration","loading_type","time_spent","in_foreground_periods","scroll","max_depth","max_depth_scroll_height","max_depth_scroll_top","max_depth_time","privacy","replay_level","custom_timings","newObject","mapValues","processViewUpdate","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","startRumSessionManager","rawTrackingType","hasValidRumSession","isTypeTracked","sessionReplayAllowed","longTaskAllowed","rumSessionType","createFlushController","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","flushObservable","flush","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","messagesCount","cancelDurationLimitTimeout","notifyBeforeAddMessage","messageBytesCount","notifyAfterAddMessage","notifyAfterRemoveMessage","Batch","flushController","pushOnlyBuffer","upsertBuffer","addOrUpdate","upsert","messages","sendOnExit","processedMessage","hasMessageFor","separatorBytesCount","removedMessage","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","sendStrategy","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","dequeue","currentBackoffTime","min","onLine","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","open","startRumBatch","telemetryEventObservable","batch","replicaBatch","createRumBatch","primaryBatch","primaryFlushController","withReplicaApplicationId","replicated","makeRumBatch","isTelemetryReplicationAllowed","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","onHashChange","stopHistoryTracking","onLocationChange","stopHashTracking","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","MEASURES_PERIOD_DURATION","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","MAX_PAGE_STATE_ENTRIES","MAX_PAGE_STATE_ENTRIES_SELECTABLE","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","startPageStateHistory","maxPageStateEntriesSelectable","currentPageState","addPageState","getPageState","stopEventListeners","persisted","computePageState","nextPageState","eventStartTime","pageStateEntries","relativeStartTime","pageStateEntry","hasFocus","getSessionReplayUrl","errorType","sessionId","rumConfiguration","getSiteDefaultSubdomain","RecordType","FullSnapshot","IncrementalSnapshot","Meta","Focus","ViewEnd","VisualViewport","FrustrationRecord","NodeType","Document","DocumentType","Text","CDATA","DocumentFragment","IncrementalSource","Mutation","MouseMove","MouseInteraction","Scroll","ViewportResize","Input","TouchMove","MediaInteraction","StyleSheetRule","MouseInteractionType","MouseUp","MouseDown","Click","ContextMenu","DblClick","Blur","TouchStart","TouchEnd","MediaInteractionType","Play","Pause","assembleIncrementalSnapshot","NodePrivacyLevel","IGNORE","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_ALLOW","PRIVACY_ATTR_VALUE_MASK","PRIVACY_ATTR_VALUE_MASK_USER_INPUT","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_ALLOW","PRIVACY_CLASS_MASK","PRIVACY_CLASS_MASK_USER_INPUT","PRIVACY_CLASS_HIDDEN","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","getNodePrivacyLevel","parentNodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","privAttr","inputElement","autocomplete","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","censorText","text","getTextContent","textNode","ignoreWhiteSpace","parentTagName","nodePrivacyLevel","isStyle","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","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","cssRule","disabled","media","serializeAttribute","attributeValue","getCssRulesString","getCssRuleString","rule","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","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","MOUSE_MOVE_OBSERVER_THRESHOLD","tryToComputeCoordinates","isFinite","SCROLL_OBSERVER_THRESHOLD","eventTypeToMouseInteraction","initInputObserver","cb","stopPropertySetterInstrumentation","lastInputStateMap","HTMLTextAreaElement","HTMLSelectElement","onElementChange","instrumentationStoppers_1","stopper","inputState","isChecked","cbWithDedup","lastInputState","getPathToNestedCSSRule","currentRule","parentRule","index_1","parentStyleSheet","VISUAL_VIEWPORT_OBSERVER_THRESHOLD","MUTATION_PROCESS_MAX_DELAY","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","opts","requestIdleCallback","cancelIdleCallback","id_1","requestAnimationFrame","cancelAnimationFrame","timeout","initMutationObserver","mutationCallback","mutationBatch","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","Map","_loop_1","addedNodes","delete","mutations_1","sortedAddedAndMovedNodes","nodes","sort","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","adds","removes","nextSibling","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","initObservers","o","updatePosition","mediaInteractionCb","focusCb","recordIds","getIdForEvent","initRecordIds","mutationHandler","mutationCb","mousemoveHandler","mousemoveCb","coordinates","timeOffset","mouseInteractionHandler","interaction","record","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","scrollPositions","initScrollObserver","scrollCb","viewportResizeHandler","initViewportResizeObserver","viewportResizeCb","inputHandler","inputCb","mediaInteractionHandler","styleSheetObserver","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","instrumentGroupingCSSRuleClass","cls","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","initStyleSheetObserver","styleSheetCb","focusHandler","has_focus","visualViewportResizeHandler","cancelThrottle","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","frustrationCb","initFrustrationObserver","initShadowRootsController","controllerByShadowRoot","stopMutationObserver","stopInputObserver","emit","scrollPositionsByElement","takeFullSnapshot","initialOffset","p","mouseInteractionRecord","positions","r","d","frustrationRecord","stopObservers","flushMutationsFromObservers","flushMutations","takeSubsequentFullSnapshot","statsPerView","MAX_STATS_HISTORY","getSegmentsCount","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","isFirst_1","_value","deleteOldestStats","Segment","worker","creationReason","initialRecord","onWrote","onFlushed","metadata","creation_reason","has_full_snapshot","index_in_view","removeMessageListener","additionalBytesCount","rawBytesCount","compressedBytesCount","segment","postMessage","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","expirationTimeoutId","createNewSegment","compressedSegmentBytesCount","rawSegmentBytesCount","formData","FormData","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","buildReplayPayload","doStartSegmentCollection","computeSegmentContext","workerString","workerURL","createDeflateWorker","createObjectURL","Worker","startDeflateWorker","createDeflateWorkerImpl","worker_1","onError","doStartDeflateWorker","isBrowserSupported","NodeList","getSessionReplayLink","isRecordingStarted","getErrorType","existingGlobalVariable","startRecordingImpl","startDeflateWorkerImpl","onRumStart","startStrategy","stopStrategy","stopRecording","makeRecorderApi","replayRequest","stopSegmentCollection","unsubscribeViewEnded","datadogRum","startRumImpl","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","getInternalContextStrategy","getInitConfigurationStrategy","stopSessionStrategy","getSessionReplayLinkStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","addErrorStrategy","providedError","addFeatureFlagEvaluationStrategy","doStartRum","startRumResults","addAction","addFeatureFlagEvaluation","getInternalContext","stopSession","stub","publicApi","rumPublicApi","eventBridgeAvailable","overrideInitConfigurationForBridge","canInitRum","beforeInitCalls","addRumGlobalContext","setGlobalContextProperty","removeRumGlobalContext","removeGlobalContextProperty","getRumGlobalContext","getGlobalContext","setRumGlobalContext","setGlobalContext","clearGlobalContext","getInitConfiguration","setUser","isValid","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","removeUser","clearUser","startSessionReplayRecording","stopSessionReplayRecording","onReady","enumerable","makeRumPublicApi","bridge_1","startRumTelemetry","FEATURE_FLAGS","getFeatureFlagBytesCount","currentContext","startFeatureFlagContexts","pagehideEnabled","stopListeners","stopBeforeUnloadListener","startRumSessionManagerStub","startRumEventBridge","batchFlushObservable","hasFeatureFlagContext","startCustomerDataTelemetry","createDOMMutationObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","startRumEventCollection","addTelemetryConfiguration","baseSerializedConfiguration","telemetry_sample_rate","telemetry_configuration_sample_rate","use_before_send","use_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_resources","track_long_task","allow_fallback_to_local_storage","serializeConfiguration","premium_sample_rate","replay_sample_rate","trace_sample_rate","action_name_attribute","use_allowed_tracing_origins","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","use_excluded_activity_urls","track_frustrations","track_views_manually","track_user_interactions","serializeRumConfiguration","startLongTaskCollection","internalContext","application_id","session_id","user_action","startInternalContext","q","datadogEnvironment","datadogVersion","datadogSampleRate"],"sourceRoot":""}