{"version":3,"file":"js/752-fa9057f934ecfc2b7994.chunk.js","mappings":"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","sources":["webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/configuration.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/configuration/remoteConfiguration.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/boot/preStartRum.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/plugins.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/limitModification.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewContexts.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/discardNegativeDuration.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/polyfills.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/privacy.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/getActionNameFromElement.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/getSelectorFromElement.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/clickChain.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/listenActionEvents.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/computeFrustration.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/trackClickActions.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/action/actionCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/error/errorCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/error/trackConsoleError.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/error/trackReportError.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/resource/matchRequestTiming.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstContentfulPaint.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLargestContentfulPaint.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInitialViewMetrics.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackNavigationTimings.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstHidden.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstInput.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCumulativeLayoutShift.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/interactionCountPolyfill.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/viewportObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInteractionToNextPaint.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/scroll.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackScrollMetrics.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCommonViewMetrics.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLoadingTime.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/trackViews.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/trackViewEventCounts.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/view/viewCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/urlContexts.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/featureFlagContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/startCustomerDataTelemetry.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/pageStateHistory.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/vital/vitalCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/browser/cookieObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/ciVisibilityContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/getSessionReplayUrl.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeDocument.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMove.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMouseInteraction.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackScroll.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewportResize.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMediaInteraction.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackStyleSheet.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFocus.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFrustration.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewEnd.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackInput.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMutation.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/startFullSnapshots.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/record/recordIds.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/boot/isBrowserSupported.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/getSessionReplayLink.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateEncoder.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/deflate/deflateWorker.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum/esm/domain/startRecordBridge.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/displayContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/longTask/longTaskCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/internalContext.js"],"sourcesContent":["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, TraceContextInjection, } 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.traceSampled = !isNumber(configuration.traceSampleRate) || performDraw(configuration.traceSampleRate);\n    if (!context.traceSampled && configuration.traceContextInjection !== TraceContextInjection.ALL) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\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, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, TraceContextInjection, display, isPercentage, objectHasValue, validateAndBuildConfiguration, isExperimentalFeatureEnabled, ExperimentalFeature, } from '@datadog/browser-core';\nimport { isTracingOption } from '../tracing/tracer';\nexport var DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'datadog'];\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (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    if (initConfiguration.traceSampleRate !== undefined && !isPercentage(initConfiguration.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    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version || undefined,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: (_a = initConfiguration.sessionReplaySampleRate) !== null && _a !== void 0 ? _a : 0,\n        startSessionReplayRecordingManually: !!initConfiguration.startSessionReplayRecordingManually,\n        traceSampleRate: initConfiguration.traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_b = initConfiguration.excludedActivityUrls) !== null && _b !== void 0 ? _b : [],\n        workerUrl: initConfiguration.workerUrl,\n        compressIntakeRequests: !!initConfiguration.compressIntakeRequests,\n        trackUserInteractions: !!initConfiguration.trackUserInteractions,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: !!initConfiguration.trackResources,\n        trackLongTasks: !!initConfiguration.trackLongTasks,\n        subdomain: initConfiguration.subdomain,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK,\n        enablePrivacyForActionName: !!initConfiguration.enablePrivacyForActionName,\n        customerDataTelemetrySampleRate: 1,\n        traceContextInjection: objectHasValue(TraceContextInjection, initConfiguration.traceContextInjection)\n            ? initConfiguration.traceContextInjection\n            : TraceContextInjection.ALL,\n        plugins: (isExperimentalFeatureEnabled(ExperimentalFeature.PLUGINS) && initConfiguration.plugins) || [],\n    }, baseConfiguration);\n}\n/**\n * Validates allowedTracingUrls and converts match options to tracing options\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    if (initConfiguration.allowedTracingUrls !== undefined) {\n        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: DEFAULT_PROPAGATOR_TYPES });\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    return [];\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls\n */\nfunction getSelectedTracingPropagators(configuration) {\n    var usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                DEFAULT_PROPAGATOR_TYPES.forEach(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n            else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n                option.propagatorTypes.forEach(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n        });\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n        trace_sample_rate: configuration.traceSampleRate,\n        trace_context_injection: configuration.traceContextInjection,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_urls: Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\n        selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n        default_privacy_level: configuration.defaultPrivacyLevel,\n        enable_privacy_for_action_name: configuration.enablePrivacyForActionName,\n        use_excluded_activity_urls: Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\n        use_worker_url: !!configuration.workerUrl,\n        compress_intake_requests: configuration.compressIntakeRequests,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: configuration.trackUserInteractions,\n        track_resources: configuration.trackResources,\n        track_long_task: configuration.trackLongTasks,\n        plugins: (_a = configuration.plugins) === null || _a === void 0 ? void 0 : _a.map(function (plugin) { var _a; return assign({ name: plugin.name }, (_a = plugin.getConfigurationTelemetry) === null || _a === void 0 ? void 0 : _a.call(plugin)); }),\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","import { display, addEventListener, assign } from '@datadog/browser-core';\nexport var REMOTE_CONFIGURATION_URL = 'https://d3uc069fcn7uxw.cloudfront.net/configuration';\nexport function fetchAndApplyRemoteConfiguration(initConfiguration, callback) {\n    fetchRemoteConfiguration(initConfiguration, function (remoteInitConfiguration) {\n        callback(applyRemoteConfiguration(initConfiguration, remoteInitConfiguration));\n    });\n}\nexport function applyRemoteConfiguration(initConfiguration, remoteInitConfiguration) {\n    return assign({}, initConfiguration, remoteInitConfiguration);\n}\nexport function fetchRemoteConfiguration(configuration, callback) {\n    var xhr = new XMLHttpRequest();\n    addEventListener(configuration, xhr, 'load', function () {\n        if (xhr.status === 200) {\n            callback(JSON.parse(xhr.responseText));\n        }\n        else {\n            displayRemoteConfigurationFetchingError();\n        }\n    });\n    addEventListener(configuration, xhr, 'error', function () {\n        displayRemoteConfigurationFetchingError();\n    });\n    xhr.open('GET', \"\".concat(REMOTE_CONFIGURATION_URL, \"/\").concat(encodeURIComponent(configuration.remoteConfigurationId), \".json\"));\n    xhr.send();\n}\nfunction displayRemoteConfigurationFetchingError() {\n    display.error('Error fetching the remote configuration.');\n}\n//# sourceMappingURL=remoteConfiguration.js.map","import { BoundedBuffer, display, canUseEventBridge, displayAlreadyInitializedError, willSyntheticsInjectRum, noop, timeStampNow, clocksNow, assign, getEventBridge, ExperimentalFeature, isExperimentalFeatureEnabled, initFeatureFlags, addTelemetryConfiguration, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration, } from '../domain/configuration';\nimport { fetchAndApplyRemoteConfiguration, serializeRumConfiguration } from '../domain/configuration';\nimport { callPluginsMethod } from '../domain/plugins';\nexport function createPreStartStrategy(_a, getCommonContext, trackingConsentState, doStartRum) {\n    var ignoreInitIfSyntheticsWillInjectRum = _a.ignoreInitIfSyntheticsWillInjectRum, startDeflateWorker = _a.startDeflateWorker;\n    var bufferApiCalls = new BoundedBuffer();\n    var firstStartViewCall;\n    var deflateWorker;\n    var cachedInitConfiguration;\n    var cachedConfiguration;\n    var trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum);\n    function tryStartRum() {\n        if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        trackingConsentStateSubscription.unsubscribe();\n        var initialViewOptions;\n        if (cachedConfiguration.trackViewsManually) {\n            if (!firstStartViewCall) {\n                return;\n            }\n            // An initial view is always created when starting RUM.\n            // When tracking views automatically, any startView call before RUM start creates an extra\n            // view.\n            // When tracking views manually, we use the ViewOptions from the first startView call as the\n            // initial view options, and we remove the actual startView call so we don't create an extra\n            // view.\n            bufferApiCalls.remove(firstStartViewCall.callback);\n            initialViewOptions = firstStartViewCall.options;\n        }\n        var startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions);\n        bufferApiCalls.drain(startRumResult);\n    }\n    function doInit(initConfiguration) {\n        var eventBridgeAvailable = canUseEventBridge();\n        if (eventBridgeAvailable) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        // Update the exposed initConfiguration to reflect the bridge and remote configuration overrides\n        cachedInitConfiguration = initConfiguration;\n        addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n        if (cachedConfiguration) {\n            displayAlreadyInitializedError('DD_RUM', initConfiguration);\n            return;\n        }\n        var configuration = validateAndBuildRumConfiguration(initConfiguration);\n        if (!configuration) {\n            return;\n        }\n        if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {\n            display.warn('No storage available for session. We will not send any data.');\n            return;\n        }\n        if (configuration.compressIntakeRequests && !eventBridgeAvailable && startDeflateWorker) {\n            deflateWorker = startDeflateWorker(configuration, 'Datadog RUM', \n            // Worker initialization can fail asynchronously, especially in Firefox where even CSP\n            // issues are reported asynchronously. For now, the SDK will continue its execution even if\n            // data won't be sent to Datadog. We could improve this behavior in the future.\n            noop);\n            if (!deflateWorker) {\n                // `startDeflateWorker` should have logged an error message explaining the issue\n                return;\n            }\n        }\n        cachedConfiguration = configuration;\n        trackingConsentState.tryToInit(configuration.trackingConsent);\n        tryStartRum();\n    }\n    return {\n        init: function (initConfiguration, publicApi) {\n            if (!initConfiguration) {\n                display.error('Missing configuration');\n                return;\n            }\n            // Set the experimental feature flags as early as possible, so we can use them in most places\n            initFeatureFlags(initConfiguration.enableExperimentalFeatures);\n            // Expose the initial configuration regardless of initialization success.\n            cachedInitConfiguration = initConfiguration;\n            // If we are in a Synthetics test configured to automatically inject a RUM instance, we want\n            // to completely discard the customer application RUM instance by ignoring their init() call.\n            // But, we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n            // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n            if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n                return;\n            }\n            if (isExperimentalFeatureEnabled(ExperimentalFeature.PLUGINS)) {\n                callPluginsMethod(initConfiguration.plugins, 'onInit', { initConfiguration: initConfiguration, publicApi: publicApi });\n            }\n            if (initConfiguration.remoteConfigurationId &&\n                isExperimentalFeatureEnabled(ExperimentalFeature.REMOTE_CONFIGURATION)) {\n                fetchAndApplyRemoteConfiguration(initConfiguration, doInit);\n            }\n            else {\n                doInit(initConfiguration);\n            }\n        },\n        get initConfiguration() {\n            return cachedInitConfiguration;\n        },\n        getInternalContext: noop,\n        stopSession: noop,\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addTiming(name, time); });\n        },\n        startView: function (options, startClocks) {\n            if (startClocks === void 0) { startClocks = clocksNow(); }\n            var callback = function (startRumResult) {\n                startRumResult.startView(options, startClocks);\n            };\n            bufferApiCalls.add(callback);\n            if (!firstStartViewCall) {\n                firstStartViewCall = { options: options, callback: callback };\n                tryStartRum();\n            }\n        },\n        addAction: function (action, commonContext) {\n            if (commonContext === void 0) { commonContext = getCommonContext(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addAction(action, commonContext); });\n        },\n        addError: function (providedError, commonContext) {\n            if (commonContext === void 0) { commonContext = getCommonContext(); }\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addError(providedError, commonContext); });\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.addFeatureFlagEvaluation(key, value); });\n        },\n        startDurationVital: function (vitalStart) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.startDurationVital(vitalStart); });\n        },\n        stopDurationVital: function (vitalStart) {\n            bufferApiCalls.add(function (startRumResult) { return startRumResult.stopDurationVital(vitalStart); });\n        },\n    };\n}\nfunction overrideInitConfigurationForBridge(initConfiguration) {\n    var _a, _b;\n    return assign({}, initConfiguration, {\n        applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n        clientToken: 'empty',\n        sessionSampleRate: 100,\n        defaultPrivacyLevel: (_a = initConfiguration.defaultPrivacyLevel) !== null && _a !== void 0 ? _a : (_b = getEventBridge()) === null || _b === void 0 ? void 0 : _b.getPrivacyLevel(),\n    });\n}\n//# sourceMappingURL=preStartRum.js.map","export function callPluginsMethod(plugins, methodName, parameter) {\n    if (!plugins) {\n        return;\n    }\n    for (var _i = 0, plugins_1 = plugins; _i < plugins_1.length; _i++) {\n        var plugin = plugins_1[_i];\n        var method = plugin[methodName];\n        if (method) {\n            method(parameter);\n        }\n    }\n}\n//# sourceMappingURL=plugins.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    var MutationObserver = getMutationObserverConstructor();\n    return new Observable(function (observable) {\n        if (!MutationObserver) {\n            return;\n        }\n        var observer = new MutationObserver(monitor(function () { return observable.notify(); }));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return function () { return observer.disconnect(); };\n    });\n}\nexport function getMutationObserverConstructor() {\n    var constructor;\n    var browserWindow = window;\n    // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n    // global MutationObserver constructor with a patched version to support the context propagation.\n    // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n    // component: on some occasions, the callback is being called in an infinite loop, causing the\n    // page to freeze (even if the callback is completely empty).\n    //\n    // To work around this issue, we try to get the original MutationObserver constructor stored by\n    // Zone.js.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n        //\n        // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n        constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver');\n        if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n            // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n            // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n            // instance in its properties[4]. Let's get the original MutationObserver constructor from\n            // there.\n            //\n            // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n            var patchedInstance = new browserWindow.MutationObserver(noop);\n            var originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance');\n            constructor = originalInstance && originalInstance.constructor;\n        }\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { DOM_EVENT, addEventListener } from './addEventListener';\nexport function runOnReadyState(configuration, expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED;\n        addEventListener(configuration, window, eventName, callback, { once: true });\n    }\n}\n//# sourceMappingURL=runOnReadyState.js.map","import { addTelemetryDebug, elapsed, ExperimentalFeature, getPathName, includes, isExperimentalFeatureEnabled, 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    if (!isValidEntry(entry)) {\n        return undefined;\n    }\n    var startTime = entry.startTime, fetchStart = entry.fetchStart, redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd, domainLookupStart = entry.domainLookupStart, domainLookupEnd = entry.domainLookupEnd, connectStart = entry.connectStart, secureConnectionStart = entry.secureConnectionStart, connectEnd = entry.connectEnd, requestStart = entry.requestStart, responseStart = entry.responseStart, responseEnd = entry.responseEnd;\n    var details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a connection occurred\n    if (fetchStart < connectEnd) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (fetchStart < domainLookupEnd) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    // Make sure a redirection occurred\n    if (startTime < redirectEnd) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\nexport function isValidEntry(entry) {\n    if (isExperimentalFeatureEnabled(ExperimentalFeature.TOLERANT_RESOURCE_TIMINGS)) {\n        return true;\n    }\n    // Ensure timings are in the right order. On top of filtering out potential invalid\n    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n    // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n    // it.\n    var areCommonTimingsInOrder = areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd);\n    var areRedirectionTimingsInOrder = hasRedirection(entry)\n        ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart)\n        : true;\n    return areCommonTimingsInOrder && areRedirectionTimingsInOrder;\n}\nfunction hasRedirection(entry) {\n    return entry.redirectEnd > entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    if (origin <= start && start <= end) {\n        return {\n            duration: toServerDuration(elapsed(start, end)),\n            start: toServerDuration(elapsed(origin, start)),\n        };\n    }\n}\nexport function computeSize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        var encodedBodySize = entry.encodedBodySize, decodedBodySize = entry.decodedBodySize, transferSize = entry.transferSize;\n        return {\n            size: decodedBodySize,\n            encoded_body_size: encodedBodySize,\n            decoded_body_size: decodedBodySize,\n            transfer_size: transferSize,\n        };\n    }\n    return {\n        size: undefined,\n        encoded_body_size: undefined,\n        decoded_body_size: undefined,\n        transfer_size: undefined,\n    };\n}\nexport function isAllowedRequestUrl(configuration, url) {\n    return url && !configuration.isIntakeUrl(url);\n}\nvar DATA_URL_REGEX = /data:(.+)?(;base64)?,/g;\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 24000;\nexport function isLongDataUrl(url) {\n    if (url.length <= MAX_ATTRIBUTE_VALUE_CHAR_LENGTH) {\n        return false;\n    }\n    else if (url.substring(0, 5) === 'data:') {\n        // Avoid String.match RangeError: Maximum call stack size exceeded\n        url = url.substring(0, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH);\n        return true;\n    }\n    return false;\n}\nexport function sanitizeDataUrl(url) {\n    return \"\".concat(url.match(DATA_URL_REGEX)[0], \"[...]\");\n}\n//# sourceMappingURL=resourceUtils.js.map","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    var shadowRoot = node;\n    return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);\n}\nexport function hasChildNodes(node) {\n    return node.childNodes.length > 0 || isNodeShadowHost(node);\n}\nexport function forEachChildNodes(node, callback) {\n    var child = node.firstChild;\n    while (child) {\n        callback(child);\n        child = child.nextSibling;\n    }\n    if (isNodeShadowHost(node)) {\n        callback(node.shadowRoot);\n    }\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { 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, DOM_EVENT, getRelativeTime, isNumber, monitor, setTimeout, relativeNow, runOnReadyState, addEventListener, objectHasValue, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected performance entry\n// eslint-disable-next-line no-restricted-syntax\nexport var RumPerformanceEntryType;\n(function (RumPerformanceEntryType) {\n    RumPerformanceEntryType[\"EVENT\"] = \"event\";\n    RumPerformanceEntryType[\"FIRST_INPUT\"] = \"first-input\";\n    RumPerformanceEntryType[\"LARGEST_CONTENTFUL_PAINT\"] = \"largest-contentful-paint\";\n    RumPerformanceEntryType[\"LAYOUT_SHIFT\"] = \"layout-shift\";\n    RumPerformanceEntryType[\"LONG_TASK\"] = \"longtask\";\n    RumPerformanceEntryType[\"NAVIGATION\"] = \"navigation\";\n    RumPerformanceEntryType[\"PAINT\"] = \"paint\";\n    RumPerformanceEntryType[\"RESOURCE\"] = \"resource\";\n})(RumPerformanceEntryType || (RumPerformanceEntryType = {}));\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    var cleanupTasks = [];\n    retrieveInitialDocumentResourceTiming(configuration, 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 = [\n            RumPerformanceEntryType.RESOURCE,\n            RumPerformanceEntryType.NAVIGATION,\n            RumPerformanceEntryType.LONG_TASK,\n            RumPerformanceEntryType.PAINT,\n        ];\n        var experimentalEntries = [\n            RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n            RumPerformanceEntryType.FIRST_INPUT,\n            RumPerformanceEntryType.LAYOUT_SHIFT,\n            RumPerformanceEntryType.EVENT,\n        ];\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 window.PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({\n                    type: type,\n                    buffered: true,\n                    // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n                    // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L209\n                    durationThreshold: 40,\n                });\n                cleanupTasks.push(function () { return observer.disconnect(); });\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_1 = new PerformanceObserver(handlePerformanceEntryList_1);\n        mainObserver_1.observe({ entryTypes: mainEntries });\n        cleanupTasks.push(function () { return mainObserver_1.disconnect(); });\n        if (supportPerformanceObject() && 'addEventListener' in performance) {\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n            var removePerformanceListener = addEventListener(configuration, performance, 'resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            }).stop;\n            cleanupTasks.push(removePerformanceListener);\n        }\n    }\n    if (!supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n        retrieveNavigationTiming(configuration, function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT)) {\n        var stopFirstInputTiming = retrieveFirstInputTiming(configuration, function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        }).stop;\n        cleanupTasks.push(stopFirstInputTiming);\n    }\n    return {\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\nexport function retrieveInitialDocumentResourceTiming(configuration, callback) {\n    runOnReadyState(configuration, 'interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: RumPerformanceEntryType.RESOURCE,\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n            toJSON: function () { return assign({}, timing, { toJSON: undefined }); },\n        };\n        if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION) &&\n            performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION).length > 0) {\n            var navigationEntry = performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION)[0];\n            timing = assign(navigationEntry.toJSON(), forcedAttributes);\n        }\n        else {\n            var relativePerformanceTiming = computeRelativePerformanceTiming();\n            timing = assign(relativePerformanceTiming, {\n                decodedBodySize: 0,\n                encodedBodySize: 0,\n                transferSize: 0,\n                renderBlockingStatus: 'non-blocking',\n                duration: relativePerformanceTiming.responseEnd,\n                name: window.location.href,\n                startTime: 0,\n            }, forcedAttributes);\n        }\n        callback(timing);\n    });\n}\nfunction retrieveNavigationTiming(configuration, callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: RumPerformanceEntryType.NAVIGATION,\n        }));\n    }\n    runOnReadyState(configuration, '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(configuration, callback) {\n    var startTimeStamp = dateNow();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(configuration, window, [DOM_EVENT.CLICK, DOM_EVENT.MOUSE_DOWN, DOM_EVENT.KEY_DOWN, DOM_EVENT.TOUCH_START, 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: RumPerformanceEntryType.FIRST_INPUT,\n            processingStart: relativeNow(),\n            processingEnd: relativeNow(),\n            startTime: evt.timeStamp,\n            duration: 0, // arbitrary value to avoid nullable duration and simplify INP logic\n            name: '',\n        };\n        if (evt.type === DOM_EVENT.POINTER_DOWN) {\n            sendTimingIfPointerIsNotCancelled(configuration, timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true }).stop;\n    return { stop: removeEventListeners };\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(configuration, timing) {\n        addEventListeners(configuration, window, [DOM_EVENT.POINTER_UP, DOM_EVENT.POINTER_CANCEL], function (event) {\n            if (event.type === 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 objectHasValue(RumPerformanceEntryType, entry.entryType);\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 === RumPerformanceEntryType.NAVIGATION && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === RumPerformanceEntryType.RESOURCE && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.js.map","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core';\n/**\n * Current limitation:\n * - field path do not support array, 'a.b.c' only\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    var clone = deepClone(object);\n    var result = modifier(clone);\n    objectEntries(modifiableFieldPaths).forEach(function (_a) {\n        var fieldPath = _a[0], fieldType = _a[1];\n        var newValue = get(clone, fieldPath);\n        var newType = getType(newValue);\n        if (newType === fieldType) {\n            set(object, fieldPath, sanitize(newValue));\n        }\n        else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n            set(object, fieldPath, {});\n        }\n    });\n    return result;\n}\nfunction get(object, path) {\n    var current = object;\n    for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {\n        var field = _a[_i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        current = current[field];\n    }\n    return current;\n}\nfunction set(object, path, value) {\n    var current = object;\n    var fields = path.split('.');\n    for (var i = 0; i < fields.length; i += 1) {\n        var field = fields[i];\n        if (!isValidObject(current)) {\n            return;\n        }\n        if (i !== fields.length - 1) {\n            current = current[field];\n        }\n        else {\n            current[field] = value;\n        }\n    }\n}\nfunction isValidObject(object) {\n    return getType(object) === 'object';\n}\nfunction isValidObjectContaining(object, field) {\n    return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field);\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, assign, round, isExperimentalFeatureEnabled, ExperimentalFeature, getConnectivity, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { limitModification } from './limitModification';\nvar VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.name': 'string',\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nvar USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nvar ROOT_MODIFIABLE_FIELD_PATHS = {\n    service: 'string',\n    version: 'string',\n};\nvar modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, displayContext, ciVisibilityContext, getCommonContext, 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, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"resource\" /* RumEventType.RESOURCE */] = assign({\n            'resource.url': 'string',\n        }, isExperimentalFeatureEnabled(ExperimentalFeature.WRITABLE_RESOURCE_GRAPHQL)\n            ? {\n                'resource.graphql': 'object',\n            }\n            : {}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"action\" /* RumEventType.ACTION */] = assign({\n            'action.target.name': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS, ROOT_MODIFIABLE_FIELD_PATHS),\n        _a[\"long_task\" /* RumEventType.LONG_TASK */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"vital\" /* RumEventType.VITAL */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a);\n    var eventRateLimiters = (_b = {},\n        _b[\"error\" /* RumEventType.ERROR */] = createEventRateLimiter(\"error\" /* RumEventType.ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"action\" /* RumEventType.ACTION */] = createEventRateLimiter(\"action\" /* RumEventType.ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"vital\" /* RumEventType.VITAL */] = createEventRateLimiter(\"vital\" /* RumEventType.VITAL */, configuration.eventRateLimiterThreshold, reportError),\n        _b);\n    var syntheticsContext = getSyntheticsContext();\n    lifeCycle.subscribe(12 /* 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 || getCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    configuration: {\n                        session_sample_rate: round(configuration.sessionSampleRate, 3),\n                        session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"5.22.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\n                        ? \"synthetics\" /* SessionType.SYNTHETICS */\n                        : ciVisibilityContext.get()\n                            ? \"ci_test\" /* SessionType.CI_TEST */\n                            : \"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: ciVisibilityContext.get(),\n                display: displayContext.get(),\n                connectivity: getConnectivity(),\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 (serverRumEvent.type === 'view') {\n                ;\n                serverRumEvent.session.sampled_for_replay =\n                    session.sessionReplay === 1 /* SessionReplayState.SAMPLED */;\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(13 /* 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","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 { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.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.BEFORE_VIEW_CREATED */, function (view) {\n        viewContextHistory.add(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(10 /* 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 { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nvar nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    var tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, configuration, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable(configuration).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(7 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    traceSampled: context.traceSampled,\n                    type: \"xhr\" /* RequestType.XHR */,\n                    url: context.url,\n                    xhr: context.xhr,\n                    isAborted: context.isAborted,\n                    handlingStack: context.handlingStack,\n                });\n                break;\n        }\n    });\n    return { stop: 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(7 /* 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(8 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration: duration,\n                        method: context.method,\n                        requestIndex: context.requestIndex,\n                        responseType: context.responseType,\n                        spanId: context.spanId,\n                        startClocks: context.startClocks,\n                        status: context.status,\n                        traceId: context.traceId,\n                        traceSampled: context.traceSampled,\n                        type: \"fetch\" /* RequestType.FETCH */,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                        isAborted: context.isAborted,\n                        handlingStack: context.handlingStack,\n                    });\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nfunction getNextRequestIndex() {\n    var result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\nfunction waitForResponseToComplete(context, callback) {\n    var clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, function () {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","import { isNumber } from '@datadog/browser-core';\nexport function discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=discardNegativeDuration.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(_a) {\n    var lifeCycle = _a.lifeCycle, isChildEvent = _a.isChildEvent, _b = _a.onChange, callback = _b === void 0 ? noop : _b;\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        var _a;\n        if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event)) {\n            return;\n        }\n        switch (event.type) {\n            case \"error\" /* RumEventType.ERROR */:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case \"action\" /* RumEventType.ACTION */:\n                eventCounts.actionCount += 1;\n                if (event.action.frustration) {\n                    eventCounts.frustrationCount += event.action.frustration.type.length;\n                }\n                callback();\n                break;\n            case \"long_task\" /* RumEventType.LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case \"resource\" /* RumEventType.RESOURCE */:\n                if (!((_a = event._dd) === null || _a === void 0 ? void 0 : _a.discarded)) {\n                    eventCounts.resourceCount += 1;\n                    callback();\n                }\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { instrumentMethod, matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../browser/performanceCollection';\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    return new Observable(function (observable) {\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 === RumPerformanceEntryType.RESOURCE && !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(7 /* 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(8 /* 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}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction trackWindowOpen(callback) {\n    return instrumentMethod(window, 'open', callback);\n}\n//# sourceMappingURL=waitPageActivityEnd.js.map","// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str) {\n    if (window.CSS && window.CSS.escape) {\n        return window.CSS.escape(str);\n    }\n    // eslint-disable-next-line no-control-regex\n    return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n        if (asCodePoint) {\n            // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n            if (ch === '\\0') {\n                return '\\uFFFD';\n            }\n            // Control characters and (dependent upon position) numbers get escaped as code points\n            return \"\".concat(ch.slice(0, -1), \"\\\\\").concat(ch.charCodeAt(ch.length - 1).toString(16), \" \");\n        }\n        // Other potentially-special ASCII characters get backslash-escaped\n        return \"\\\\\".concat(ch);\n    });\n}\nexport function elementMatches(element, selector) {\n    if (element.matches) {\n        return element.matches(selector);\n    }\n    // IE11 support\n    if (element.msMatchesSelector) {\n        return element.msMatchesSelector(selector);\n    }\n    return false;\n}\n/**\n * Return the parentElement of an node\n *\n * In cases where parentElement is not supported, such as in IE11 for SVG nodes, we fallback to parentNode\n */\nexport function getParentElement(node) {\n    if (node.parentElement) {\n        return node.parentElement;\n    }\n    while (node.parentNode) {\n        if (node.parentNode.nodeType === Node.ELEMENT_NODE) {\n            return node.parentNode;\n        }\n        node = node.parentNode;\n    }\n    return null;\n}\n/**\n * Return the classList of an element or an array of classes if classList is not supported\n *\n * In cases where classList is not supported, such as in IE11 for SVG and MathML elements,\n * we fallback to using element.getAttribute('class').\n * We opt for element.getAttribute('class') over element.className because className returns an SVGAnimatedString for SVG elements.\n */\nexport function getClassList(element) {\n    var _a;\n    if (element.classList) {\n        return element.classList;\n    }\n    var classes = (_a = element.getAttribute('class')) === null || _a === void 0 ? void 0 : _a.trim();\n    return classes ? classes.split(/\\s+/) : [];\n}\n// ie11 supports WeakMap but not WeakSet\nvar PLACEHOLDER = 1;\nvar WeakSet = /** @class */ (function () {\n    function WeakSet(initialValues) {\n        var _this = this;\n        this.map = new WeakMap();\n        if (initialValues) {\n            initialValues.forEach(function (value) { return _this.map.set(value, PLACEHOLDER); });\n        }\n    }\n    WeakSet.prototype.add = function (value) {\n        this.map.set(value, PLACEHOLDER);\n        return this;\n    };\n    WeakSet.prototype.delete = function (value) {\n        return this.map.delete(value);\n    };\n    WeakSet.prototype.has = function (value) {\n        return this.map.has(value);\n    };\n    return WeakSet;\n}());\nexport { WeakSet };\n//# sourceMappingURL=polyfills.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nimport { isElementNode, getParentNode, isTextNode } from '../browser/htmlDomUtils';\nimport { elementMatches } from '../browser/polyfills';\nexport var NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n};\nexport var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_PREFIX = 'dd-privacy-';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\nvar TEXT_MASKING_CHAR = 'x';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel, cache) {\n    if (cache && cache.has(node)) {\n        return cache.get(node);\n    }\n    var parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode\n        ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel, cache)\n        : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    var nodePrivacyLevel = reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n    if (cache) {\n        cache.set(node, nodePrivacyLevel);\n    }\n    return nodePrivacyLevel;\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElementNode(node)) {\n        return;\n    }\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        var inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        var autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.HIDDEN))) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.MASK))) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.MASK_USER_INPUT))) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (elementMatches(node, getPrivacySelector(NodePrivacyLevel.ALLOW))) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    var element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport var censorText = function (text) { return text.replace(/\\S/g, TEXT_MASKING_CHAR); };\nexport function getTextContent(textNode, ignoreWhiteSpace, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel)) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        var relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\nexport function getPrivacySelector(privacyLevel) {\n    return \"[\".concat(PRIVACY_ATTR_NAME, \"=\\\"\").concat(privacyLevel, \"\\\"], .\").concat(PRIVACY_CLASS_PREFIX).concat(privacyLevel);\n}\n//# sourceMappingURL=privacy.js.map","import { safeTruncate, isIE, find } from '@datadog/browser-core';\nimport { getParentElement } from '../../browser/polyfills';\nimport { NodePrivacyLevel, getPrivacySelector } from '../privacy';\n/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nexport var DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name';\nexport var ACTION_NAME_PLACEHOLDER = 'Masked Element';\nexport function getActionNameFromElement(element, _a, nodePrivacyLevel) {\n    var enablePrivacyForActionName = _a.enablePrivacyForActionName, userProgrammaticAttribute = _a.actionNameAttribute;\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, 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    var defaultActionName = getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute));\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n        return defaultActionName || ACTION_NAME_PLACEHOLDER;\n    }\n    return (defaultActionName ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies, enablePrivacyForActionName) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies, enablePrivacyForActionName) ||\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 = getParentElement(element);\n        }\n    }\n    if (!elementWithAttribute) {\n        return;\n    }\n    var name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nvar priorityStrategies = [\n    // associated LABEL text\n    function (element, userProgrammaticAttribute, privacy) {\n        // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n        // instead\n        if (supportsLabelProperty()) {\n            if ('labels' in element && element.labels && element.labels.length > 0) {\n                return 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, privacy);\n        }\n    },\n    // INPUT button (and associated) value\n    function (element) {\n        if (element.nodeName === 'INPUT') {\n            var input = element;\n            var type = input.getAttribute('type');\n            if (type === 'button' || type === 'submit' || type === 'reset') {\n                return input.value;\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    function (element, userProgrammaticAttribute, privacyEnabledActionName) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName);\n        }\n    },\n    function (element) { return element.getAttribute('aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute, privacyEnabledActionName) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return labelledByAttribute\n                .split(/\\s+/)\n                .map(function (id) { return getElementById(element, id); })\n                .filter(function (label) { return Boolean(label); })\n                .map(function (element) { return getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName); })\n                .join(' ');\n        }\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, privacyEnabledActionName) {\n        return getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName);\n    },\n];\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nvar MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, userProgrammaticAttribute, strategies, privacyEnabledActionName) {\n    var element = targetElement;\n    var recursionCounter = 0;\n    while (recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n        element &&\n        element.nodeName !== 'BODY' &&\n        element.nodeName !== 'HTML' &&\n        element.nodeName !== 'HEAD') {\n        for (var _i = 0, strategies_1 = strategies; _i < strategies_1.length; _i++) {\n            var strategy = strategies_1[_i];\n            var name_1 = strategy(element, userProgrammaticAttribute, privacyEnabledActionName);\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 = getParentElement(element);\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".concat(safeTruncate(s, 100), \" [...]\") : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName) {\n    if (element.isContentEditable) {\n        return;\n    }\n    if ('innerText' in element) {\n        var text_1 = element.innerText;\n        var removeTextFromElements = function (query) {\n            var list = element.querySelectorAll(query);\n            for (var index = 0; index < list.length; index += 1) {\n                var element_1 = list[index];\n                if ('innerText' in element_1) {\n                    var textToReplace = element_1.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text_1 = text_1.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        if (!supportsInnerTextScriptAndStyleRemoval()) {\n            // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n            // be relatively fast and work in most cases.\n            removeTextFromElements('script, style');\n        }\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(\"[\".concat(DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, \"]\"));\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(\"[\".concat(userProgrammaticAttribute, \"]\"));\n        }\n        if (privacyEnabledActionName) {\n            // remove the text of elements with privacy override\n            removeTextFromElements(\"\".concat(getPrivacySelector(NodePrivacyLevel.HIDDEN), \", \").concat(getPrivacySelector(NodePrivacyLevel.MASK)));\n        }\n        return text_1;\n    }\n    return element.textContent;\n}\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n    return !isIE();\n}\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsLabelPropertyResult;\nfunction supportsLabelProperty() {\n    if (supportsLabelPropertyResult === undefined) {\n        supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype;\n    }\n    return supportsLabelPropertyResult;\n}\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsElementClosestResult;\nfunction supportsElementClosest() {\n    if (supportsElementClosestResult === undefined) {\n        supportsElementClosestResult = 'closest' in HTMLElement.prototype;\n    }\n    return supportsElementClosestResult;\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { cssEscape, elementMatches, getClassList, getParentElement } from '../browser/polyfills';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/getActionNameFromElement';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport var STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nvar GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nvar UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    if (!isConnected(targetElement)) {\n        // We cannot compute a selector for a detached element, as we don't have access to all of its\n        // parents, and we cannot determine if it's unique in the document.\n        return;\n    }\n    var targetElementSelector;\n    var currentElement = targetElement;\n    while (currentElement && currentElement.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(currentElement, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(currentElement, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector);\n        currentElement = getParentElement(currentElement);\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return \"#\".concat(cssEscape(element.id));\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    var classList = getClassList(element);\n    for (var i = 0; i < classList.length; i += 1) {\n        var className = classList[i];\n        if (isGeneratedValue(className)) {\n            continue;\n        }\n        return \"\".concat(cssEscape(element.tagName), \".\").concat(cssEscape(className));\n    }\n}\nfunction getTagNameSelector(element) {\n    return cssEscape(element.tagName);\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        var selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (var _i = 0, STABLE_ATTRIBUTES_1 = STABLE_ATTRIBUTES; _i < STABLE_ATTRIBUTES_1.length; _i++) {\n        var attributeName = STABLE_ATTRIBUTES_1[_i];\n        var selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return \"\".concat(cssEscape(element.tagName), \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = getParentElement(element).firstElementChild;\n    var elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return \"\".concat(cssEscape(element.tagName), \":nth-of-type(\").concat(elementIndex, \")\");\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (var _i = 0, selectorGetters_1 = selectorGetters; _i < selectorGetters_1.length; _i++) {\n        var selectorGetter = selectorGetters_1[_i];\n        var elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        if (predicate(element, elementSelector, childSelector)) {\n            return combineSelector(elementSelector, childSelector);\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, elementSelector, childSelector) {\n    return element.ownerDocument.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > CHILD_SELECTOR\" returns a single element.\n *\n * @param {Element} currentElement - the element being considered while iterating over the target\n * element ancestors.\n *\n * @param {string} currentElementSelector - a selector that matches the current element. That\n * selector is not a composed selector (i.e. it might be a single tag name, class name...).\n *\n * @param {string|undefined} childSelector - child selector is a selector that targets a descendant\n * of the current element. When undefined, the current element is the target element.\n *\n * # Scope selector usage\n *\n * When composed together, the final selector will be joined with `>` operators to make sure we\n * target direct descendants at each level. In this function, we'll use `querySelector` to check if\n * a selector matches descendants of the current element. But by default, the query selector match\n * elements at any level. Example:\n *\n * ```html\n * <main>\n *   <div>\n *     <span></span>\n *   </div>\n *   <marquee>\n *     <div>\n *       <span></span>\n *     </div>\n *   </marquee>\n * </main>\n * ```\n *\n * `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the\n * selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`\n * operator (`MAIN > DIV > SPAN`).\n *\n * To avoid this, we can use the `:scope` selector to make sure the selector starts from the current\n * sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).\n *\n * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT CHILD_SELECTOR\" returns a single element), regardless of whether the selector is\n * a direct descendant of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\n *\n * [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope\n *\n * # Performance considerations\n *\n * We compute selectors in performance-critical operations (ex: during a click), so we need to make\n * sure the function is as fast as possible. We observed that naively using `querySelectorAll` to\n * check if the selector matches more than 1 element is quite expensive, so we want to avoid it.\n *\n * Because we are iterating the DOM upward and we use that function at every level, we know the\n * child selector is already unique among the current element children, so we don't need to check\n * for the current element subtree.\n *\n * Instead, we can focus on the current element siblings. If we find a single element matching the\n * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`\n * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.\n */\nexport function isSelectorUniqueAmongSiblings(currentElement, currentElementSelector, childSelector) {\n    var isSiblingMatching;\n    if (childSelector === undefined) {\n        // If the child selector is undefined (meaning `currentElement` is the target element, not one\n        // of its ancestor), we need to use `matches` to check if the sibling is matching the selector,\n        // as `querySelector` only returns a descendant of the element.\n        isSiblingMatching = function (sibling) { return elementMatches(sibling, currentElementSelector); };\n    }\n    else {\n        var scopedSelector_1 = supportScopeSelector()\n            ? combineSelector(\"\".concat(currentElementSelector, \":scope\"), childSelector)\n            : combineSelector(currentElementSelector, childSelector);\n        isSiblingMatching = function (sibling) { return sibling.querySelector(scopedSelector_1) !== null; };\n    }\n    var parent = getParentElement(currentElement);\n    var sibling = parent.firstElementChild;\n    while (sibling) {\n        if (sibling !== currentElement && isSiblingMatching(sibling)) {\n            return false;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return true;\n}\nfunction combineSelector(parent, child) {\n    return child ? \"\".concat(parent, \">\").concat(child) : parent;\n}\nvar supportScopeSelectorCache;\nexport function supportScopeSelector() {\n    if (supportScopeSelectorCache === undefined) {\n        try {\n            document.querySelector(':scope');\n            supportScopeSelectorCache = true;\n        }\n        catch (_a) {\n            supportScopeSelectorCache = false;\n        }\n    }\n    return supportScopeSelectorCache;\n}\n/**\n * Polyfill-utility for the `isConnected` property not supported in IE11\n */\nfunction isConnected(element) {\n    if ('isConnected' in\n        // cast is to make sure `element` is not inferred as `never` after the check\n        element) {\n        return element.isConnected;\n    }\n    return element.ownerDocument.documentElement.contains(element);\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nexport var MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport var MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    var bufferedClicks = [];\n    var status = 0 /* ClickChainStatus.WaitingForMoreClicks */;\n    var maxDurationBetweenClicksTimeoutId;\n    appendClick(firstClick);\n    function appendClick(click) {\n        click.stopObservable.subscribe(tryFinalize);\n        bufferedClicks.push(click);\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        maxDurationBetweenClicksTimeoutId = setTimeout(dontAcceptMoreClick, MAX_DURATION_BETWEEN_CLICKS);\n    }\n    function tryFinalize() {\n        if (status === 1 /* ClickChainStatus.WaitingForClicksToStop */ && bufferedClicks.every(function (click) { return click.isStopped(); })) {\n            status = 2 /* ClickChainStatus.Finalized */;\n            onFinalize(bufferedClicks);\n        }\n    }\n    function dontAcceptMoreClick() {\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        if (status === 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n            status = 1 /* ClickChainStatus.WaitingForClicksToStop */;\n            tryFinalize();\n        }\n    }\n    return {\n        tryAppend: function (click) {\n            if (status !== 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n                return false;\n            }\n            if (bufferedClicks.length > 0 &&\n                !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)) {\n                dontAcceptMoreClick();\n                return false;\n            }\n            appendClick(click);\n            return true;\n        },\n        stop: function () {\n            dontAcceptMoreClick();\n        },\n    };\n}\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first, second) {\n    return (first.target === second.target &&\n        mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n        first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS);\n}\nfunction mouseEventDistance(origin, other) {\n    return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2));\n}\n//# sourceMappingURL=clickChain.js.map","import { addEventListener, DOM_EVENT } from '@datadog/browser-core';\nexport function listenActionEvents(configuration, _a) {\n    var onPointerDown = _a.onPointerDown, onPointerUp = _a.onPointerUp;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n        scroll: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(configuration, window, DOM_EVENT.POINTER_DOWN, function (event) {\n            if (isValidPointerEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: false,\n                    scroll: false,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, DOM_EVENT.SELECTION_CHANGE, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, DOM_EVENT.SCROLL, function () {\n            userActivity.scroll = true;\n        }, { capture: true, passive: true }),\n        addEventListener(configuration, window, DOM_EVENT.POINTER_UP, function (event) {\n            if (isValidPointerEvent(event) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                var localUserActivity_1 = userActivity;\n                onPointerUp(clickContext, event, function () { return localUserActivity_1; });\n                clickContext = undefined;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, DOM_EVENT.INPUT, function () {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: function () {\n            listeners.forEach(function (listener) { return listener.stop(); });\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    var selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidPointerEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        event.isPrimary !== false);\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { ONE_SECOND } from '@datadog/browser-core';\nimport { elementMatches } from '../../browser/polyfills';\nvar MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(\"rage_click\" /* FrustrationType.RAGE_CLICK */);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        return { isRage: true };\n    }\n    var hasSelectionChanged = clicks.some(function (click) { return click.getUserActivity().selection; });\n    clicks.forEach(function (click) {\n        if (click.hasError) {\n            click.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        if (isDead(click) &&\n            // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n            !hasSelectionChanged) {\n            click.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n    });\n    return { isRage: false };\n}\nexport function isRage(clicks) {\n    if (clicks.some(function (click) { return click.getUserActivity().selection || click.getUserActivity().scroll; })) {\n        return false;\n    }\n    for (var i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n        if (clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n            ONE_SECOND) {\n            return true;\n        }\n    }\n    return false;\n}\nvar DEAD_CLICK_EXCLUDE_SELECTOR = \n// inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n// inputs (using a negative selector is shorter here)\n'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n    'textarea,' +\n    'select,' +\n    // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n    '[contenteditable],' +\n    '[contenteditable] *,' +\n    // canvas, as there is no good way to detect activity occurring on them\n    'canvas,' +\n    // links that are interactive (have an href attribute) or any of their descendants, as they can\n    // open a new tab or navigate to a hash without triggering a meaningful event\n    'a[href],' +\n    'a[href] *';\nexport function isDead(click) {\n    if (click.hasPageActivity || click.getUserActivity().input || click.getUserActivity().scroll) {\n        return false;\n    }\n    return !elementMatches(click.event.target, DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { 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 { getSelectorFromElement } from '../getSelectorFromElement';\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '../privacy';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\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(10 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents(configuration, {\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent);\n        },\n        onPointerUp: function (_a, startEvent, getUserActivity) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) { return history.findAll(startTime); },\n    };\n    return {\n        stop: function () {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts: actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            var rageClick_1 = click.clone();\n            currentClickChain = createClickChain(click, function (clicks) {\n                finalizeClicks(clicks, rageClick_1);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent) {\n    var nodePrivacyLevel = configuration.enablePrivacyForActionName\n        ? getNodePrivacyLevel(pointerDownEvent.target, configuration.defaultPrivacyLevel)\n        : NodePrivacyLevel.ALLOW;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return undefined;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, nodePrivacyLevel, configuration);\n    var hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, 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    appendClickToClickChain(click);\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        }\n    }, CLICK_ACTION_MAX_DURATION).stop;\n    var viewEndedSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        click.stop(endClocks.timeStamp);\n    });\n    var stopSubscription = stopObservable.subscribe(function () {\n        click.stop();\n    });\n    click.stopObservable.subscribe(function () {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, nodePrivacyLevel, configuration) {\n    var rect = event.target.getBoundingClientRect();\n    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, configuration.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, configuration, nodePrivacyLevel),\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 { discardNegativeDuration } from '../discardNegativeDuration';\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(12 /* 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(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, pageStateHistory)));\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction processAction(action, pageStateHistory) {\n    var autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                id: action.id,\n                loading_time: discardNegativeDuration(toServerDuration(action.duration)),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\n                },\n            },\n        }\n        : undefined;\n    var customerContext = !isAutoAction(action) ? action.context : undefined;\n    var actionEvent = combine({\n        action: {\n            id: generateUUID(),\n            target: {\n                name: action.name,\n            },\n            type: action.type,\n        },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* RumEventType.ACTION */,\n        view: { in_foreground: pageStateHistory.wasInPageStateAt(\"active\" /* PageState.ACTIVE */, action.startClocks.relative) },\n    }, autoActionProperties);\n    var domainContext = isAutoAction(action) ? { events: action.events } : {};\n    if (!isAutoAction(action) && action.handlingStack) {\n        domainContext.handlingStack = action.handlingStack;\n    }\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: domainContext,\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* ActionType.CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","import { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(configuration, errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts) {\n    lifeCycle.subscribe(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(12 /* 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(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction processError(error, pageStateHistory, featureFlagContexts) {\n    var rawRumEvent = {\n        date: error.startClocks.timeStamp,\n        error: {\n            id: generateUUID(),\n            message: error.message,\n            source: error.source,\n            stack: error.stack,\n            handling_stack: error.handlingStack,\n            type: error.type,\n            handling: error.handling,\n            causes: error.causes,\n            source_type: 'browser',\n            fingerprint: error.fingerprint,\n            csp: error.csp,\n        },\n        type: \"error\" /* RumEventType.ERROR */,\n        view: { in_foreground: pageStateHistory.wasInPageStateAt(\"active\" /* PageState.ACTIVE */, error.startClocks.relative) },\n    };\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\n    }\n    var domainContext = {\n        error: error.originalError,\n        handlingStack: error.handlingStack,\n    };\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: domainContext,\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { 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, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(configuration, errorObservable) {\n    var subscription = initReportObservable(configuration, [\n        RawReportType.cspViolation,\n        RawReportType.intervention,\n    ]).subscribe(function (reportError) {\n        var rawError = {\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            originalError: reportError.originalReport,\n        };\n        if (reportError.originalReport.type === 'securitypolicyviolation') {\n            rawError.csp = {\n                disposition: reportError.originalReport.disposition,\n            };\n        }\n        return errorObservable.notify(rawError);\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { addDuration } from '@datadog/browser-core';\nimport { WeakSet } from '../../browser/polyfills';\nimport { isValidEntry } from './resourceUtils';\nvar alreadyMatchedEntries = new WeakSet();\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - filter out timing that were already matched to a request\n * - then, if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function 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        .filter(function (entry) { return !alreadyMatchedEntries.has(entry); })\n        .filter(function (entry) { return isValidEntry(entry); })\n        .filter(function (entry) {\n        return isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration }));\n    });\n    if (candidates.length === 1) {\n        alreadyMatchedEntries.add(candidates[0]);\n        return candidates[0].toJSON();\n    }\n    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceCollection';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, isLongDataUrl, sanitizeDataUrl, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle, configuration, pageStateHistory) {\n    lifeCycle.subscribe(8 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n        var rawEvent = processRequest(request, configuration, pageStateHistory);\n        if (rawEvent) {\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, rawEvent);\n        }\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 === RumPerformanceEntryType.RESOURCE && !isRequestKind(entry)) {\n                var rawEvent = processResourceEntry(entry, configuration);\n                if (rawEvent) {\n                    lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, rawEvent);\n                }\n            }\n        }\n    });\n}\nfunction processRequest(request, configuration, pageStateHistory) {\n    var matchingTiming = matchRequestTiming(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var tracingInfo = computeRequestTracingInfo(request, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    var type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.FETCH */;\n    var correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined;\n    var duration = computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: duration,\n            method: request.method,\n            status_code: request.status,\n            url: isLongDataUrl(request.url) ? sanitizeDataUrl(request.url) : request.url,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n        _dd: {\n            discarded: !configuration.trackResources,\n        },\n    }, tracingInfo, correspondingTimingOverrides);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming,\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n            isAborted: request.isAborted,\n            handlingStack: request.handlingStack,\n        },\n    };\n}\nfunction processResourceEntry(entry, configuration) {\n    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeEntryTracingInfo(entry, configuration);\n    if (!configuration.trackResources && !tracingInfo) {\n        return;\n    }\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n            status_code: discardZeroStatus(entry.responseStatus),\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n        _dd: {\n            discarded: !configuration.trackResources,\n        },\n    }, tracingInfo, entryMetrics);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: entry,\n        },\n    };\n}\nfunction computePerformanceEntryMetrics(timing) {\n    var renderBlockingStatus = timing.renderBlockingStatus;\n    return {\n        resource: assign({\n            duration: computePerformanceResourceDuration(timing),\n            render_blocking_status: renderBlockingStatus,\n        }, computeSize(timing), 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/**\n * @returns number between 0 and 1 which represents trace sample rate\n */\nfunction getRulePsr(configuration) {\n    return isNumber(configuration.traceSampleRate) ? configuration.traceSampleRate / 100 : undefined;\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, startClocks.relative, duration)\n        ? toServerDuration(duration)\n        : undefined;\n}\n/**\n * The status is 0 for cross-origin resources without CORS headers, so the status is meaningless, and we shouldn't report it\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus#cross-origin_response_status_codes\n */\nfunction discardZeroStatus(statusCode) {\n    return statusCode === 0 ? undefined : statusCode;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { ONE_MINUTE, find } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\n// Discard FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackFirstContentfulPaint(lifeCycle, firstHidden, callback) {\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.PAINT &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < FCP_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: unsubscribeLifeCycle,\n    };\n}\n//# sourceMappingURL=trackFirstContentfulPaint.js.map","import { DOM_EVENT, ONE_MINUTE, addEventListeners, findLast } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts\n */\nexport function trackLargestContentfulPaint(lifeCycle, configuration, firstHidden, eventTarget, callback) {\n    // Ignore entries that come after the first user interaction. According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    var firstInteractionTimestamp = Infinity;\n    var stopEventListener = addEventListeners(configuration, eventTarget, [DOM_EVENT.POINTER_DOWN, DOM_EVENT.KEY_DOWN], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var biggestLcpSize = 0;\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < LCP_MAXIMUM_DELAY &&\n                // Ensure to get the LCP entry with the biggest size, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655\n                entry.size > biggestLcpSize;\n        });\n        if (lcpEntry) {\n            var lcpTargetSelector = void 0;\n            if (lcpEntry.element) {\n                lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);\n            }\n            callback({\n                value: lcpEntry.startTime,\n                targetSelector: lcpTargetSelector,\n            });\n            biggestLcpSize = lcpEntry.size;\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\n//# sourceMappingURL=trackLargestContentfulPaint.js.map","import { trackFirstContentfulPaint } from './trackFirstContentfulPaint';\nimport { trackFirstInput } from './trackFirstInput';\nimport { trackNavigationTimings } from './trackNavigationTimings';\nimport { trackLargestContentfulPaint } from './trackLargestContentfulPaint';\nimport { trackFirstHidden } from './trackFirstHidden';\nexport function trackInitialViewMetrics(lifeCycle, configuration, setLoadEvent, scheduleViewUpdate) {\n    var initialViewMetrics = {};\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, function (navigationTimings) {\n        setLoadEvent(navigationTimings.loadEvent);\n        initialViewMetrics.navigationTimings = navigationTimings;\n        scheduleViewUpdate();\n    }).stop;\n    var firstHidden = trackFirstHidden(configuration);\n    var stopFCPTracking = trackFirstContentfulPaint(lifeCycle, firstHidden, function (firstContentfulPaint) {\n        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaint(lifeCycle, configuration, firstHidden, window, function (largestContentfulPaint) {\n        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopFIDTracking = trackFirstInput(lifeCycle, configuration, firstHidden, function (firstInput) {\n        initialViewMetrics.firstInput = firstInput;\n        scheduleViewUpdate();\n    }).stop;\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n        firstHidden.stop();\n    }\n    return {\n        stop: stop,\n        initialViewMetrics: initialViewMetrics,\n    };\n}\n//# sourceMappingURL=trackInitialViewMetrics.js.map","import { relativeNow } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\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 === RumPerformanceEntryType.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}\n//# sourceMappingURL=trackNavigationTimings.js.map","import { addEventListeners, DOM_EVENT } from '@datadog/browser-core';\nexport function trackFirstHidden(configuration, eventTarget) {\n    if (eventTarget === void 0) { eventTarget = window; }\n    var timeStamp;\n    var stopListeners;\n    if (document.visibilityState === 'hidden') {\n        timeStamp = 0;\n    }\n    else {\n        timeStamp = Infinity;\n        (stopListeners = addEventListeners(configuration, eventTarget, [DOM_EVENT.PAGE_HIDE, DOM_EVENT.VISIBILITY_CHANGE], function (event) {\n            if (event.type === DOM_EVENT.PAGE_HIDE || document.visibilityState === 'hidden') {\n                timeStamp = event.timeStamp;\n                stopListeners();\n            }\n        }, { capture: true }).stop);\n    }\n    return {\n        get timeStamp() {\n            return timeStamp;\n        },\n        stop: function () {\n            stopListeners === null || stopListeners === void 0 ? void 0 : stopListeners();\n        },\n    };\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { elapsed, find } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInput(lifeCycle, configuration, firstHidden, callback) {\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.FIRST_INPUT && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            var firstInputTargetSelector = void 0;\n            if (firstInputEntry.target && isElementNode(firstInputEntry.target)) {\n                firstInputTargetSelector = getSelectorFromElement(firstInputEntry.target, configuration.actionNameAttribute);\n            }\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                delay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                time: firstInputEntry.startTime,\n                targetSelector: firstInputTargetSelector,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: unsubscribeLifeCycle,\n    };\n}\n//# sourceMappingURL=trackFirstInput.js.map","import { round, find, ONE_SECOND, noop, elapsed } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nexport function trackCumulativeLayoutShift(configuration, lifeCycle, viewStart, callback) {\n    if (!isLayoutShiftSupported()) {\n        return {\n            stop: noop,\n        };\n    }\n    var maxClsValue = 0;\n    // WeakRef is not supported in IE11 and Safari mobile, but so is the layout shift API, so this code won't be executed in these browsers\n    var maxClsTarget;\n    var maxClsStartTime;\n    // if no layout shift happen the value should be reported as 0\n    callback({\n        value: 0,\n    });\n    var window = slidingSessionWindow();\n    var 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 === RumPerformanceEntryType.LAYOUT_SHIFT && !entry.hadRecentInput) {\n                var _a = window.update(entry), cumulatedValue = _a.cumulatedValue, isMaxValue = _a.isMaxValue;\n                if (isMaxValue) {\n                    var target = getTargetFromSource(entry.sources);\n                    maxClsTarget = target ? new WeakRef(target) : undefined;\n                    maxClsStartTime = elapsed(viewStart, entry.startTime);\n                }\n                if (cumulatedValue > maxClsValue) {\n                    maxClsValue = cumulatedValue;\n                    var target = maxClsTarget === null || maxClsTarget === void 0 ? void 0 : maxClsTarget.deref();\n                    callback({\n                        value: round(maxClsValue, 4),\n                        targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),\n                        time: maxClsStartTime,\n                    });\n                }\n            }\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\nfunction getTargetFromSource(sources) {\n    var _a;\n    if (!sources) {\n        return;\n    }\n    return (_a = find(sources, function (source) { return !!source.node && isElementNode(source.node); })) === null || _a === void 0 ? void 0 : _a.node;\n}\nexport var MAX_WINDOW_DURATION = 5 * ONE_SECOND;\nvar MAX_UPDATE_GAP = ONE_SECOND;\nfunction slidingSessionWindow() {\n    var cumulatedValue = 0;\n    var startTime;\n    var endTime;\n    var maxValue = 0;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= MAX_UPDATE_GAP ||\n                entry.startTime - startTime >= MAX_WINDOW_DURATION;\n            var isMaxValue;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                maxValue = cumulatedValue = entry.value;\n                isMaxValue = true;\n            }\n            else {\n                cumulatedValue += entry.value;\n                endTime = entry.startTime;\n                isMaxValue = entry.value > maxValue;\n                if (isMaxValue) {\n                    maxValue = entry.value;\n                }\n            }\n            return {\n                cumulatedValue: cumulatedValue,\n                isMaxValue: isMaxValue,\n            };\n        },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT);\n}\n//# sourceMappingURL=trackCumulativeLayoutShift.js.map","/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\nimport { monitor } from '@datadog/browser-core';\nvar observer;\nvar interactionCountEstimate = 0;\nvar minKnownInteractionId = Infinity;\nvar maxKnownInteractionId = 0;\nexport function initInteractionCountPolyfill() {\n    if ('interactionCount' in performance || observer) {\n        return;\n    }\n    observer = new window.PerformanceObserver(monitor(function (entries) {\n        entries.getEntries().forEach(function (e) {\n            var entry = e;\n            if (entry.interactionId) {\n                minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);\n                maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);\n                interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;\n            }\n        });\n    }));\n    observer.observe({ type: 'event', buffered: true, durationThreshold: 0 });\n}\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport var getInteractionCount = function () {\n    return observer ? interactionCountEstimate : window.performance.interactionCount || 0;\n};\n//# sourceMappingURL=interactionCountPolyfill.js.map","import { Observable, throttle, addEventListener, DOM_EVENT } from '@datadog/browser-core';\nvar viewportObservable;\nexport function initViewportObservable(configuration) {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable(configuration);\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable(configuration) {\n    return new Observable(function (observable) {\n        var updateDimension = throttle(function () {\n            observable.notify(getViewportDimension());\n        }, 200).throttled;\n        return addEventListener(configuration, window, DOM_EVENT.RESIZE, updateDimension, { capture: true, passive: true })\n            .stop;\n    });\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { elapsed, noop, ONE_MINUTE } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill';\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nvar MAX_INTERACTION_ENTRIES = 10;\n// Arbitrary value to cap INP outliers\nexport var MAX_INP_VALUE = (1 * ONE_MINUTE);\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(configuration, viewStart, viewLoadingType, lifeCycle) {\n    if (!isInteractionToNextPaintSupported()) {\n        return {\n            getInteractionToNextPaint: function () { return undefined; },\n            setViewEnd: noop,\n            stop: noop,\n        };\n    }\n    var _a = trackViewInteractionCount(viewLoadingType), getViewInteractionCount = _a.getViewInteractionCount, stopViewInteractionCount = _a.stopViewInteractionCount;\n    var viewEnd = Infinity;\n    var longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    var interactionToNextPaint = -1;\n    var interactionToNextPaintTargetSelector;\n    var interactionToNextPaintStartTime;\n    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 === RumPerformanceEntryType.EVENT ||\n                entry.entryType === RumPerformanceEntryType.FIRST_INPUT) &&\n                entry.interactionId &&\n                // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).\n                entry.startTime >= viewStart &&\n                entry.startTime <= viewEnd) {\n                longestInteractions.process(entry);\n            }\n        }\n        var newInteraction = longestInteractions.estimateP98Interaction();\n        if (newInteraction && newInteraction.duration !== interactionToNextPaint) {\n            interactionToNextPaint = newInteraction.duration;\n            interactionToNextPaintStartTime = elapsed(viewStart, newInteraction.startTime);\n            if (newInteraction.target && isElementNode(newInteraction.target)) {\n                interactionToNextPaintTargetSelector = getSelectorFromElement(newInteraction.target, configuration.actionNameAttribute);\n            }\n            else {\n                interactionToNextPaintTargetSelector = undefined;\n            }\n        }\n    }).unsubscribe;\n    return {\n        getInteractionToNextPaint: function () {\n            // If no INP duration where captured because of the performanceObserver 40ms threshold\n            // but the view interaction count > 0 then report 0\n            if (interactionToNextPaint >= 0) {\n                return {\n                    value: Math.min(interactionToNextPaint, MAX_INP_VALUE),\n                    targetSelector: interactionToNextPaintTargetSelector,\n                    time: interactionToNextPaintStartTime,\n                };\n            }\n            else if (getViewInteractionCount()) {\n                return {\n                    value: 0,\n                };\n            }\n        },\n        setViewEnd: function (viewEndTime) {\n            viewEnd = viewEndTime;\n            stopViewInteractionCount();\n        },\n        stop: stop,\n    };\n}\nfunction trackLongestInteractions(getViewInteractionCount) {\n    var longestInteractions = [];\n    function sortAndTrimLongestInteractions() {\n        longestInteractions.sort(function (a, b) { return b.duration - a.duration; }).splice(MAX_INTERACTION_ENTRIES);\n    }\n    return {\n        /**\n         * Process the performance entry:\n         * - if its duration is long enough, add the performance entry to the list of worst interactions\n         * - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions\n         */\n        process: function (entry) {\n            var interactionIndex = longestInteractions.findIndex(function (interaction) { return entry.interactionId === interaction.interactionId; });\n            var minLongestInteraction = longestInteractions[longestInteractions.length - 1];\n            if (interactionIndex !== -1) {\n                if (entry.duration > longestInteractions[interactionIndex].duration) {\n                    longestInteractions[interactionIndex] = entry;\n                    sortAndTrimLongestInteractions();\n                }\n            }\n            else if (longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n                entry.duration > minLongestInteraction.duration) {\n                longestInteractions.push(entry);\n                sortAndTrimLongestInteractions();\n            }\n        },\n        /**\n         * Compute the p98 longest interaction.\n         * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n         */\n        estimateP98Interaction: function () {\n            var interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));\n            return longestInteractions[interactionIndex];\n        },\n    };\n}\nexport function trackViewInteractionCount(viewLoadingType) {\n    initInteractionCountPolyfill();\n    var previousInteractionCount = viewLoadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */ ? 0 : getInteractionCount();\n    var state = { stopped: false };\n    function computeViewInteractionCount() {\n        return getInteractionCount() - previousInteractionCount;\n    }\n    return {\n        getViewInteractionCount: function () {\n            if (state.stopped) {\n                return state.interactionCount;\n            }\n            return computeViewInteractionCount();\n        },\n        stopViewInteractionCount: function () {\n            state = { stopped: true, interactionCount: computeViewInteractionCount() };\n        },\n    };\n}\nexport function isInteractionToNextPaintSupported() {\n    return (supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n        window.PerformanceEventTiming &&\n        'interactionId' in PerformanceEventTiming.prototype);\n}\n//# sourceMappingURL=trackInteractionToNextPaint.js.map","export function getScrollX() {\n    var scrollX;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    var scrollY;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=scroll.js.map","import { Observable, ONE_SECOND, elapsed, relativeNow, throttle, addEventListener, DOM_EVENT, monitor, } from '@datadog/browser-core';\nimport { getScrollY } from '../../../browser/scroll';\nimport { getViewportDimension } from '../../../browser/viewportObservable';\n/** Arbitrary scroll throttle duration */\nexport var THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackScrollMetrics(configuration, viewStart, callback, scrollValues) {\n    if (scrollValues === void 0) { scrollValues = createScrollValuesObservable(configuration); }\n    var maxScrollDepth = 0;\n    var maxScrollHeight = 0;\n    var maxScrollHeightTime = 0;\n    var subscription = scrollValues.subscribe(function (_a) {\n        var scrollDepth = _a.scrollDepth, scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight;\n        var shouldUpdate = false;\n        if (scrollDepth > maxScrollDepth) {\n            maxScrollDepth = scrollDepth;\n            shouldUpdate = true;\n        }\n        if (scrollHeight > maxScrollHeight) {\n            maxScrollHeight = scrollHeight;\n            var now = relativeNow();\n            maxScrollHeightTime = elapsed(viewStart.relative, now);\n            shouldUpdate = true;\n        }\n        if (shouldUpdate) {\n            callback({\n                maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n                maxDepthScrollTop: scrollTop,\n                maxScrollHeight: maxScrollHeight,\n                maxScrollHeightTime: maxScrollHeightTime,\n            });\n        }\n    });\n    return {\n        stop: function () { return subscription.unsubscribe(); },\n    };\n}\nexport function computeScrollValues() {\n    var scrollTop = getScrollY();\n    var height = getViewportDimension().height;\n    var scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);\n    var scrollDepth = Math.round(height + scrollTop);\n    return {\n        scrollHeight: scrollHeight,\n        scrollDepth: scrollDepth,\n        scrollTop: scrollTop,\n    };\n}\nexport function createScrollValuesObservable(configuration, throttleDuration) {\n    if (throttleDuration === void 0) { throttleDuration = THROTTLE_SCROLL_DURATION; }\n    return new Observable(function (observable) {\n        function notify() {\n            observable.notify(computeScrollValues());\n        }\n        if (window.ResizeObserver) {\n            var throttledNotify_1 = throttle(notify, throttleDuration, {\n                leading: false,\n                trailing: true,\n            });\n            var observerTarget_1 = document.scrollingElement || document.documentElement;\n            var resizeObserver_1 = new ResizeObserver(monitor(throttledNotify_1.throttled));\n            resizeObserver_1.observe(observerTarget_1);\n            var eventListener_1 = addEventListener(configuration, window, DOM_EVENT.SCROLL, throttledNotify_1.throttled, {\n                passive: true,\n            });\n            return function () {\n                throttledNotify_1.cancel();\n                resizeObserver_1.unobserve(observerTarget_1);\n                eventListener_1.stop();\n            };\n        }\n    });\n}\n//# sourceMappingURL=trackScrollMetrics.js.map","import { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift';\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint';\nimport { trackLoadingTime } from './trackLoadingTime';\nimport { trackScrollMetrics } from './trackScrollMetrics';\nexport function trackCommonViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    var commonViewMetrics = {};\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadingType, viewStart, function (newLoadingTime) {\n        commonViewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopScrollMetricsTracking = trackScrollMetrics(configuration, viewStart, function (newScrollMetrics) {\n        commonViewMetrics.scroll = newScrollMetrics;\n    }).stop;\n    var stopCLSTracking = trackCumulativeLayoutShift(configuration, lifeCycle, viewStart.relative, function (cumulativeLayoutShift) {\n        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n        scheduleViewUpdate();\n    }).stop;\n    var _b = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType, lifeCycle), stopINPTracking = _b.stop, getInteractionToNextPaint = _b.getInteractionToNextPaint, setViewEnd = _b.setViewEnd;\n    return {\n        stop: function () {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n        },\n        stopINPTracking: stopINPTracking,\n        setLoadEvent: setLoadEvent,\n        setViewEnd: setViewEnd,\n        getCommonViewMetrics: function () {\n            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();\n            return commonViewMetrics;\n        },\n    };\n}\n//# sourceMappingURL=trackCommonViewMetrics.js.map","import { elapsed } from '@datadog/browser-core';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nexport function 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//# sourceMappingURL=trackLoadingTime.js.map","import { noop, PageExitReason, shallowClone, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, setTimeout, Observable, } from '@datadog/browser-core';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nimport { trackInitialViewMetrics } from './viewMetrics/trackInitialViewMetrics';\nimport { trackCommonViewMetrics } from './viewMetrics/trackCommonViewMetrics';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\n// Some events or metrics can be captured after the end of the view. To avoid missing those;\n// an arbitrary delay is added for stopping their tracking after the view ends.\n//\n// Ideally, we would not stop and keep tracking events or metrics until the end of the session.\n// But this might have a small performance impact if there are many many views.\n// So let's have a fairly short delay improving the situation in most cases and avoid impacting performances too much.\nexport var KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    var activeViews = new Set();\n    var currentView = startNewView(\"initial_load\" /* ViewLoadingType.INITIAL_LOAD */, clocksOrigin(), initialViewOptions);\n    startViewLifeCycle();\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        var newlyCreatedView = newView(lifeCycle, domMutationObservable, configuration, location, loadingType, startClocks, viewOptions);\n        activeViews.add(newlyCreatedView);\n        newlyCreatedView.stopObservable.subscribe(function () {\n            activeViews.delete(newlyCreatedView);\n        });\n        return newlyCreatedView;\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(10 /* 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(9 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n            currentView.end({ sessionIsActive: false });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n                currentView.end();\n            }\n        });\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(function (_a) {\n            var oldLocation = _a.oldLocation, newLocation = _a.newLocation;\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */);\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n        },\n        startView: function (options, startClocks) {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, startClocks, options);\n        },\n        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            currentView.end();\n            activeViews.forEach(function (view) { return view.stop(); });\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 stopObservable = new Observable();\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 || undefined;\n        version = viewOptions.version || undefined;\n    }\n    var viewCreatedEvent = {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n    };\n    lifeCycle.notify(2 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, viewCreatedEvent);\n    lifeCycle.notify(3 /* LifeCycleEventType.VIEW_CREATED */, viewCreatedEvent);\n    // Update the view every time the measures are changing\n    var _a = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackCommonViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, setViewEnd = _b.setViewEnd, stopCommonViewMetricsTracking = _b.stop, stopINPTracking = _b.stopINPTracking, getCommonViewMetrics = _b.getCommonViewMetrics;\n    var _c = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewMetrics(lifeCycle, configuration, setLoadEvent, scheduleViewUpdate)\n        : { stop: noop, initialViewMetrics: {} }, stopInitialViewMetricsTracking = _c.stop, initialViewMetrics = _c.initialViewMetrics;\n    var _d = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), stopEventCountsTracking = _d.stop, eventCounts = _d.eventCounts;\n    // Session keep alive\n    var keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(4 /* LifeCycleEventType.VIEW_UPDATED */, {\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            commonViewMetrics: getCommonViewMetrics(),\n            initialViewMetrics: initialViewMetrics,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive: sessionIsActive,\n            eventCounts: eventCounts,\n        });\n    }\n    return {\n        name: name,\n        service: service,\n        version: version,\n        stopObservable: stopObservable,\n        end: function (options) {\n            var _this = this;\n            var _a, _b;\n            if (options === void 0) { options = {}; }\n            if (endClocks) {\n                // view already ended\n                return;\n            }\n            endClocks = (_a = options.endClocks) !== null && _a !== void 0 ? _a : clocksNow();\n            sessionIsActive = (_b = options.sessionIsActive) !== null && _b !== void 0 ? _b : true;\n            lifeCycle.notify(5 /* LifeCycleEventType.VIEW_ENDED */, { endClocks: endClocks });\n            lifeCycle.notify(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, { endClocks: endClocks });\n            clearInterval(keepAliveIntervalId);\n            setViewEnd(endClocks.relative);\n            stopCommonViewMetricsTracking();\n            triggerViewUpdate();\n            setTimeout(function () {\n                _this.stop();\n            }, KEEP_TRACKING_AFTER_VIEW_DELAY);\n        },\n        stop: function () {\n            stopInitialViewMetricsTracking();\n            stopEventCountsTracking();\n            stopINPTracking();\n            stopObservable.notify();\n        },\n        addTiming: function (name, time) {\n            if (endClocks) {\n                return;\n            }\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    var sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(\"Invalid timing name: \".concat(name, \", sanitized to: \").concat(sanitized));\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    var correspondingId = hash.substring(1);\n    // check if the correspondingId is empty because on Firefox an empty string passed to getElementById() prints a consol warning\n    return correspondingId !== '' && !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    var index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { trackEventCounts } from '../trackEventCounts';\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    var _a = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) { return event.view.id === viewId; },\n        onChange: onChange,\n    }), stop = _a.stop, eventCounts = _a.eventCounts;\n    return {\n        stop: stop,\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { isEmptyObject, mapValues, toServerDuration } from '@datadog/browser-core';\nimport { discardNegativeDuration } from '../discardNegativeDuration';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\n    var pageStates = pageStateHistory.findAll(view.startClocks.relative, view.duration);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            page_states: pageStates,\n            configuration: {\n                start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n            },\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* RumEventType.VIEW */,\n        view: {\n            action: {\n                count: view.eventCounts.actionCount,\n            },\n            frustration: {\n                count: view.eventCounts.frustrationCount,\n            },\n            cumulative_layout_shift: (_a = view.commonViewMetrics.cumulativeLayoutShift) === null || _a === void 0 ? void 0 : _a.value,\n            cumulative_layout_shift_time: toServerDuration((_b = view.commonViewMetrics.cumulativeLayoutShift) === null || _b === void 0 ? void 0 : _b.time),\n            cumulative_layout_shift_target_selector: (_c = view.commonViewMetrics.cumulativeLayoutShift) === null || _c === void 0 ? void 0 : _c.targetSelector,\n            first_byte: toServerDuration((_d = view.initialViewMetrics.navigationTimings) === null || _d === void 0 ? void 0 : _d.firstByte),\n            dom_complete: toServerDuration((_e = view.initialViewMetrics.navigationTimings) === null || _e === void 0 ? void 0 : _e.domComplete),\n            dom_content_loaded: toServerDuration((_f = view.initialViewMetrics.navigationTimings) === null || _f === void 0 ? void 0 : _f.domContentLoaded),\n            dom_interactive: toServerDuration((_g = view.initialViewMetrics.navigationTimings) === null || _g === void 0 ? void 0 : _g.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),\n            first_input_delay: toServerDuration((_h = view.initialViewMetrics.firstInput) === null || _h === void 0 ? void 0 : _h.delay),\n            first_input_time: toServerDuration((_j = view.initialViewMetrics.firstInput) === null || _j === void 0 ? void 0 : _j.time),\n            first_input_target_selector: (_k = view.initialViewMetrics.firstInput) === null || _k === void 0 ? void 0 : _k.targetSelector,\n            interaction_to_next_paint: toServerDuration((_l = view.commonViewMetrics.interactionToNextPaint) === null || _l === void 0 ? void 0 : _l.value),\n            interaction_to_next_paint_time: toServerDuration((_m = view.commonViewMetrics.interactionToNextPaint) === null || _m === void 0 ? void 0 : _m.time),\n            interaction_to_next_paint_target_selector: (_o = view.commonViewMetrics.interactionToNextPaint) === null || _o === void 0 ? void 0 : _o.targetSelector,\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration((_p = view.initialViewMetrics.largestContentfulPaint) === null || _p === void 0 ? void 0 : _p.value),\n            largest_contentful_paint_target_selector: (_q = view.initialViewMetrics.largestContentfulPaint) === null || _q === void 0 ? void 0 : _q.targetSelector,\n            load_event: toServerDuration((_r = view.initialViewMetrics.navigationTimings) === null || _r === void 0 ? void 0 : _r.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.commonViewMetrics.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n        },\n        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\n        display: view.commonViewMetrics.scroll\n            ? {\n                scroll: {\n                    max_depth: view.commonViewMetrics.scroll.maxDepth,\n                    max_depth_scroll_top: view.commonViewMetrics.scroll.maxDepthScrollTop,\n                    max_scroll_height: view.commonViewMetrics.scroll.maxScrollHeight,\n                    max_scroll_height_time: toServerDuration(view.commonViewMetrics.scroll.maxScrollHeightTime),\n                },\n            }\n            : undefined,\n        session: {\n            has_replay: replayStats ? true : undefined,\n            is_active: view.sessionIsActive ? undefined : false,\n        },\n        privacy: {\n            replay_level: configuration.defaultPrivacyLevel,\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\n//# sourceMappingURL=viewCollection.js.map","import { Observable, bridgeSupports, noop, performDraw, startSessionManager, } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle, trackingConsentState) {\n    var sessionManager = startSessionManager(configuration, RUM_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); }, trackingConsentState);\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(9 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(10 /* LifeCycleEventType.SESSION_RENEWED */);\n    });\n    sessionManager.sessionStateUpdateObservable.subscribe(function (_a) {\n        var previousState = _a.previousState, newState = _a.newState;\n        if (!previousState.forcedReplay && newState.forcedReplay) {\n            var sessionEntity = sessionManager.findSession();\n            if (sessionEntity) {\n                sessionEntity.isReplayForced = true;\n            }\n        }\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findSession(startTime);\n            if (!session || !isTypeTracked(session.trackingType)) {\n                return;\n            }\n            return {\n                id: session.id,\n                sessionReplay: session.trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */\n                    ? 1 /* SessionReplayState.SAMPLED */\n                    : session.isReplayForced\n                        ? 2 /* SessionReplayState.FORCED */\n                        : 0 /* SessionReplayState.OFF */,\n            };\n        },\n        expire: sessionManager.expire,\n        expireObservable: sessionManager.expireObservable,\n        setForcedReplay: function () { return sessionManager.updateSessionState({ forcedReplay: '1' }); },\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        sessionReplay: bridgeSupports(\"records\" /* BridgeCapability.RECORDS */) ? 1 /* SessionReplayState.SAMPLED */ : 0 /* SessionReplayState.OFF */,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n        expire: noop,\n        expireObservable: new Observable(),\n        setForcedReplay: noop,\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sessionSampleRate)) {\n        trackingType = \"0\" /* RumTrackingType.NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.sessionReplaySampleRate)) {\n        trackingType = \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    else {\n        trackingType = \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;\n    }\n    return {\n        trackingType: trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* RumTrackingType.NOT_TRACKED */ ||\n        trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||\n        trackingType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return (rumSessionType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */ ||\n        rumSessionType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { 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(2 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var viewUrl = location.href;\n        urlContextHistory.add(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    var locationChangeSubscription = locationChangeObservable.subscribe(function (_a) {\n        var newLocation = _a.newLocation;\n        var current = urlContextHistory.find();\n        if (current) {\n            var changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            url: url,\n            referrer: referrer,\n        };\n    }\n    return {\n        findUrl: function (startTime) { return urlContextHistory.find(startTime); },\n        stop: function () {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { addEventListener, DOM_EVENT, instrumentMethod, Observable, shallowClone } from '@datadog/browser-core';\nexport function createLocationChangeObservable(configuration, location) {\n    var currentLocation = shallowClone(location);\n    return new Observable(function (observable) {\n        var stopHistoryTracking = trackHistory(configuration, onLocationChange).stop;\n        var stopHashTracking = trackHash(configuration, onLocationChange).stop;\n        function onLocationChange() {\n            if (currentLocation.href === location.href) {\n                return;\n            }\n            var newLocation = shallowClone(location);\n            observable.notify({\n                newLocation: newLocation,\n                oldLocation: currentLocation,\n            });\n            currentLocation = newLocation;\n        }\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n}\nfunction trackHistory(configuration, onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethod(history, 'pushState', function (_a) {\n        var onPostCall = _a.onPostCall;\n        onPostCall(onHistoryChange);\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethod(history, 'replaceState', function (_a) {\n        var onPostCall = _a.onPostCall;\n        onPostCall(onHistoryChange);\n    }).stop;\n    var removeListener = addEventListener(configuration, window, DOM_EVENT.POP_STATE, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(configuration, onHashChange) {\n    return addEventListener(configuration, window, DOM_EVENT.HASH_CHANGE, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { SESSION_TIME_OUT_DELAY, ValueHistory } from '@datadog/browser-core';\nexport var FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(lifeCycle, customerDataTracker) {\n    var featureFlagContexts = new ValueHistory(FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(2 /* LifeCycleEventType.BEFORE_VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        customerDataTracker.resetCustomerData();\n    });\n    lifeCycle.subscribe(6 /* LifeCycleEventType.AFTER_VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n                customerDataTracker.updateCustomerData(currentContext);\n            }\n        },\n        stop: function () { return customerDataTracker.stop(); },\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { includes, performDraw, ONE_SECOND, addTelemetryDebug, setInterval, } from '@datadog/browser-core';\nexport var MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nvar currentPeriodMeasures;\nvar currentBatchMeasures;\nvar batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batchFlushObservable) {\n    var customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate);\n    if (!customerDataTelemetryEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    initCurrentBatchMeasures();\n    // We measure the data of every view updates even if there could only be one per batch due to the upsert\n    // It means that contexts bytes count sums can be higher than it really is\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */).getBytesCount());\n        updateMeasure(currentBatchMeasures.userContextBytes, customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */).getBytesCount());\n        updateMeasure(currentBatchMeasures.featureFlagBytes, includes([\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */], event.type)\n            ? customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */).getBytesCount()\n            : 0);\n    });\n    batchFlushObservable.subscribe(function (_a) {\n        var bytesCount = _a.bytesCount, messagesCount = _a.messagesCount;\n        // Don't measure batch that only contains telemetry events to avoid batch sending loop\n        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n        if (!batchHasRumEvent) {\n            return;\n        }\n        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);\n        mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes);\n        mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes);\n        mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes);\n        initCurrentBatchMeasures();\n    });\n    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    addTelemetryDebug('Customer data measures', currentPeriodMeasures);\n    initCurrentPeriodMeasures();\n}\nfunction createMeasure() {\n    return { min: Infinity, max: 0, sum: 0 };\n}\nfunction updateMeasure(measure, value) {\n    measure.sum += value;\n    measure.min = Math.min(measure.min, value);\n    measure.max = Math.max(measure.max, value);\n}\nfunction mergeMeasure(target, source) {\n    target.sum += source.sum;\n    target.min = Math.min(target.min, source.min);\n    target.max = Math.max(target.max, source.max);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\nfunction initCurrentBatchMeasures() {\n    batchHasRumEvent = false;\n    currentBatchMeasures = {\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { elapsed, ValueHistory, SESSION_TIME_OUT_DELAY, toServerDuration, addEventListeners, relativeNow, DOM_EVENT, } from '@datadog/browser-core';\n// Arbitrary value to cap number of element for memory consumption in the browser\nexport var MAX_PAGE_STATE_ENTRIES = 4000;\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport var MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500;\nexport var PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startPageStateHistory(configuration, maxPageStateEntriesSelectable) {\n    if (maxPageStateEntriesSelectable === void 0) { maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE; }\n    var pageStateEntryHistory = new ValueHistory(PAGE_STATE_CONTEXT_TIME_OUT_DELAY, MAX_PAGE_STATE_ENTRIES);\n    var currentPageState;\n    addPageState(getPageState(), relativeNow());\n    var stopEventListeners = addEventListeners(configuration, window, [\n        DOM_EVENT.PAGE_SHOW,\n        DOM_EVENT.FOCUS,\n        DOM_EVENT.BLUR,\n        DOM_EVENT.VISIBILITY_CHANGE,\n        DOM_EVENT.RESUME,\n        DOM_EVENT.FREEZE,\n        DOM_EVENT.PAGE_HIDE,\n    ], function (event) {\n        addPageState(computePageState(event), event.timeStamp);\n    }, { capture: true }).stop;\n    function addPageState(nextPageState, startTime) {\n        if (startTime === void 0) { startTime = relativeNow(); }\n        if (nextPageState === currentPageState) {\n            return;\n        }\n        currentPageState = nextPageState;\n        pageStateEntryHistory.closeActive(startTime);\n        pageStateEntryHistory.add({ state: currentPageState, startTime: startTime }, startTime);\n    }\n    var pageStateHistory = {\n        findAll: function (eventStartTime, duration) {\n            var pageStateEntries = pageStateEntryHistory.findAll(eventStartTime, duration);\n            if (pageStateEntries.length === 0) {\n                return;\n            }\n            var pageStateServerEntries = [];\n            // limit the number of entries to return\n            var limit = Math.max(0, pageStateEntries.length - maxPageStateEntriesSelectable);\n            // loop page state entries backward to return the selected ones in desc order\n            for (var index = pageStateEntries.length - 1; index >= limit; index--) {\n                var pageState = pageStateEntries[index];\n                // compute the start time relative to the event start time (ex: to be relative to the view start time)\n                var relativeStartTime = elapsed(eventStartTime, pageState.startTime);\n                pageStateServerEntries.push({\n                    state: pageState.state,\n                    start: toServerDuration(relativeStartTime),\n                });\n            }\n            return pageStateServerEntries;\n        },\n        wasInPageStateAt: function (state, startTime) {\n            return pageStateHistory.wasInPageStateDuringPeriod(state, startTime, 0);\n        },\n        wasInPageStateDuringPeriod: function (state, startTime, duration) {\n            return pageStateEntryHistory.findAll(startTime, duration).some(function (pageState) { return pageState.state === state; });\n        },\n        addPageState: addPageState,\n        stop: function () {\n            stopEventListeners();\n            pageStateEntryHistory.stop();\n        },\n    };\n    return pageStateHistory;\n}\nfunction computePageState(event) {\n    if (event.type === DOM_EVENT.FREEZE) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === 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 { combine, elapsed, generateUUID } from '@datadog/browser-core';\nexport function startVitalCollection(lifeCycle, pageStateHistory) {\n    var vitalStartsByName = new Map();\n    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        // Discard all the vitals that have not been stopped to avoid memory leaks\n        vitalStartsByName.clear();\n    });\n    function isValid(vital) {\n        return !pageStateHistory.wasInPageStateDuringPeriod(\"frozen\" /* PageState.FROZEN */, vital.startClocks.relative, vital.value);\n    }\n    return {\n        startDurationVital: function (vitalStart) {\n            vitalStartsByName.set(vitalStart.name, vitalStart);\n        },\n        stopDurationVital: function (vitalStop) {\n            var vitalStart = vitalStartsByName.get(vitalStop.name);\n            if (!vitalStart) {\n                return;\n            }\n            var vital = buildDurationVital(vitalStart, vitalStop);\n            vitalStartsByName.delete(vital.name);\n            if (isValid(vital)) {\n                lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processVital(vital, true));\n            }\n        },\n    };\n}\nfunction buildDurationVital(vitalStart, vitalStop) {\n    return {\n        name: vitalStart.name,\n        type: \"duration\" /* VitalType.DURATION */,\n        startClocks: vitalStart.startClocks,\n        value: elapsed(vitalStart.startClocks.timeStamp, vitalStop.stopClocks.timeStamp),\n        context: combine(vitalStart.context, vitalStop.context),\n    };\n}\nfunction processVital(vital, valueComputedBySdk) {\n    var _a;\n    var rawRumEvent = {\n        date: vital.startClocks.timeStamp,\n        vital: {\n            id: generateUUID(),\n            type: vital.type,\n            name: vital.name,\n            custom: (_a = {},\n                _a[vital.name] = vital.value,\n                _a),\n        },\n        type: \"vital\" /* RumEventType.VITAL */,\n    };\n    if (valueComputedBySdk) {\n        rawRumEvent._dd = {\n            vital: {\n                computed_value: true,\n            },\n        };\n    }\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: vital.startClocks.relative,\n        customerContext: vital.context,\n        domainContext: {},\n    };\n}\n//# sourceMappingURL=vitalCollection.js.map","import { setInterval, clearInterval, Observable, addEventListener, ONE_SECOND, findCommaSeparatedValue, DOM_EVENT, find, } from '@datadog/browser-core';\nexport function createCookieObservable(configuration, cookieName) {\n    var detectCookieChangeStrategy = window.cookieStore\n        ? listenToCookieStoreChange(configuration)\n        : watchCookieFallback;\n    return new Observable(function (observable) {\n        return detectCookieChangeStrategy(cookieName, function (event) { return observable.notify(event); });\n    });\n}\nfunction listenToCookieStoreChange(configuration) {\n    return function (cookieName, callback) {\n        var listener = addEventListener(configuration, window.cookieStore, DOM_EVENT.CHANGE, function (event) {\n            // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.\n            // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226\n            var changeEvent = find(event.changed, function (event) { return event.name === cookieName; }) ||\n                find(event.deleted, function (event) { return event.name === cookieName; });\n            if (changeEvent) {\n                callback(changeEvent.value);\n            }\n        });\n        return listener.stop;\n    };\n}\nexport var WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND;\nfunction watchCookieFallback(cookieName, callback) {\n    var previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n    var watchCookieIntervalId = setInterval(function () {\n        var cookieValue = findCommaSeparatedValue(document.cookie, cookieName);\n        if (cookieValue !== previousCookieValue) {\n            callback(cookieValue);\n        }\n    }, WATCH_COOKIE_INTERVAL_DELAY);\n    return function () {\n        clearInterval(watchCookieIntervalId);\n    };\n}\n//# sourceMappingURL=cookieObservable.js.map","import { getInitCookie } from '@datadog/browser-core';\nimport { createCookieObservable } from '../../browser/cookieObservable';\nexport var CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id';\nexport function startCiVisibilityContext(configuration, cookieObservable) {\n    var _a;\n    if (cookieObservable === void 0) { cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME); }\n    var testExecutionId = getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || ((_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId'));\n    var cookieObservableSubscription = cookieObservable.subscribe(function (value) {\n        testExecutionId = value;\n    });\n    return {\n        get: function () {\n            if (typeof testExecutionId === 'string') {\n                return {\n                    test_execution_id: testExecutionId,\n                };\n            }\n        },\n        stop: function () { return cookieObservableSubscription.unsubscribe(); },\n    };\n}\n//# sourceMappingURL=ciVisibilityContext.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, _a) {\n    var session = _a.session, viewContext = _a.viewContext, errorType = _a.errorType;\n    var sessionId = session ? session.id : 'no-session-id';\n    var parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(\"error-type=\".concat(errorType));\n    }\n    if (viewContext) {\n        parameters.push(\"seed=\".concat(viewContext.id));\n        parameters.push(\"from=\".concat(viewContext.startClocks.timeStamp));\n    }\n    var origin = getDatadogSiteUrl(configuration);\n    var path = \"/rum/replay/sessions/\".concat(sessionId);\n    return \"\".concat(origin).concat(path, \"?\").concat(parameters.join('&'));\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    var site = rumConfiguration.site;\n    var subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return \"https://\".concat(subdomain ? \"\".concat(subdomain, \".\") : '').concat(site);\n}\nfunction getSiteDefaultSubdomain(configuration) {\n    switch (configuration.site) {\n        case INTAKE_SITE_US1:\n        case INTAKE_SITE_EU1:\n            return 'app';\n        case INTAKE_SITE_STAGING:\n            return 'dd';\n        default:\n            return undefined;\n    }\n}\n//# sourceMappingURL=getSessionReplayUrl.js.map","export var MAX_STATS_HISTORY = 10;\nvar statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    var replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    if (statsPerView.keys) {\n        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 { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot, CENSORED_STRING_MARK, shouldMaskNode } from '@datadog/browser-rum-core';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var current = node;\n    while (current) {\n        if (!hasSerializedNode(current) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\nexport var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(quote, \")\");\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_) {\n        return url;\n    }\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    var processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nexport function censoredImageForSize(width, height) {\n    return \"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='\".concat(width, \"' height='\").concat(height, \"' style='background-color:silver'%3E%3C/svg%3E\");\n}\n//# sourceMappingURL=serializationUtils.js.map","export var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport var NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport var IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport var MouseInteractionType = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport var MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { startsWith } from '@datadog/browser-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK, STABLE_ATTRIBUTES, isLongDataUrl, sanitizeDataUrl, } from '@datadog/browser-rum-core';\nimport { censoredImageForSize } from './serializationUtils';\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' && (attributeName === 'src' || attributeName === 'srcset')) {\n            // generate image with similar dimension than the original to have the same rendering behaviour\n            var image = element;\n            if (image.naturalWidth > 0) {\n                return censoredImageForSize(image.naturalWidth, image.naturalHeight);\n            }\n            var _a = element.getBoundingClientRect(), width = _a.width, height = _a.height;\n            if (width > 0 || height > 0) {\n                return censoredImageForSize(width, height);\n            }\n            // if we can't get the image size, fallback to the censored image\n            return CENSORED_IMG_MARK;\n        }\n        // mask source URLs\n        if (tagName === 'SOURCE' && (attributeName === 'src' || attributeName === 'srcset')) {\n            return CENSORED_IMG_MARK;\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && startsWith(attributeName, 'data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n        // mask iframe srcdoc\n        if (tagName === 'IFRAME' && attributeName === 'srcdoc') {\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (isLongDataUrl(attributeValue)) {\n        return sanitizeDataUrl(attributeValue);\n    }\n    return attributeValue;\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { isSafari } from '@datadog/browser-core';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    var _a;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName, options.configuration);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        var formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        var cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    var inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            delete safeAttrs.checked;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        var mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element only for full snapshot\n     */\n    var scrollTop;\n    var scrollLeft;\n    var serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\nexport function getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    var rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    var styleSheetCssText = Array.from(rules, isSafari() ? getCssRuleStringForSafari : getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleStringForSafari(rule) {\n    // Safari does not escape attribute selectors containing : properly\n    // https://bugs.webkit.org/show_bug.cgi?id=184604\n    if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n        // This regex replaces [foo:bar] by [foo\\\\:bar]\n        var escapeColon = /(\\[[\\w-]+[^\\\\])(:[^\\]]+\\])/g;\n        return rule.cssText.replace(escapeColon, '$1\\\\$2');\n    }\n    return getCssRuleString(rule);\n}\nfunction getCssRuleString(rule) {\n    // If it's an @import rule, try to inline sub-rules recursively with `getCssRulesString`. This\n    // operation can fail if the imported stylesheet is protected by CORS, in which case we fallback\n    // to the @import rule CSS text.\n    return (isCSSImportRule(rule) && getCssRulesString(rule.styleSheet)) || rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isNodeShadowRoot, hasChildNodes, forEachChildNodes, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, } from '@datadog/browser-rum-core';\nimport { assign } from '@datadog/browser-core';\nimport { NodeType } from '../../../types';\nimport { getSerializedNodeId, getValidTagName, setSerializedNodeId } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\nexport function serializeNodeWithId(node, options) {\n    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nvar _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    forEachChildNodes(node, function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: serializeChildNodes(element, options),\n        isShadowRoot: isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nfunction serializeElementNode(element, options) {\n    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: NodeType.Element,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    var childNodes = [];\n    if (hasChildNodes(element) &&\n        // Do not serialize style children as the css rules are already in the _cssText attribute\n        tagName !== 'style') {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: textContent,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { serializeNodeWithId } from './serializeNode';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: configuration,\n    });\n}\n//# sourceMappingURL=serializeDocument.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nvar TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visualViewport = window.visualViewport;\n    var normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport var getVisualViewport = function (visualViewport) { return ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n}); };\n//# sourceMappingURL=viewports.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { addEventListeners, addTelemetryDebug, DOM_EVENT, throttle } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function trackMove(configuration, moveCb) {\n    var _a = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            moveCb(assembleIncrementalSnapshot(isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove, { positions: [position] }));\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updatePosition = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(configuration, document, [DOM_EVENT.MOUSE_MOVE, DOM_EVENT.TOUCH_MOVE], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\nexport function tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\n        return undefined;\n    }\n    return { x: x, y: y };\n}\n//# sourceMappingURL=trackMove.js.map","var _a;\nimport { assign, addEventListeners, DOM_EVENT } from '@datadog/browser-core';\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './trackMove';\nvar eventTypeToMouseInteraction = (_a = {},\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    _a[DOM_EVENT.POINTER_UP] = MouseInteractionType.MouseUp,\n    _a[DOM_EVENT.MOUSE_DOWN] = MouseInteractionType.MouseDown,\n    _a[DOM_EVENT.CLICK] = MouseInteractionType.Click,\n    _a[DOM_EVENT.CONTEXT_MENU] = MouseInteractionType.ContextMenu,\n    _a[DOM_EVENT.DBL_CLICK] = MouseInteractionType.DblClick,\n    _a[DOM_EVENT.FOCUS] = MouseInteractionType.Focus,\n    _a[DOM_EVENT.BLUR] = MouseInteractionType.Blur,\n    _a[DOM_EVENT.TOUCH_START] = MouseInteractionType.TouchStart,\n    _a[DOM_EVENT.TOUCH_END] = MouseInteractionType.TouchEnd,\n    _a);\nexport function trackMouseInteraction(configuration, mouseInteractionCb, recordIds) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: recordIds.getIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\n        mouseInteractionCb(record);\n    };\n    return addEventListeners(configuration, document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMouseInteraction.js.map","import { DOM_EVENT, throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY, getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nexport function trackScroll(configuration, scrollCb, elementsScrollPositions, target) {\n    if (target === void 0) { target = document; }\n    var _a = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        scrollCb(assembleIncrementalSnapshot(IncrementalSource.Scroll, {\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD), updatePosition = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListener(configuration, target, DOM_EVENT.SCROLL, updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackScroll.js.map","import { throttle, DOM_EVENT, addEventListeners, timeStampNow, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { IncrementalSource, RecordType } from '../../../types';\nimport { getVisualViewport } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function trackViewportResize(configuration, viewportResizeCb) {\n    var viewportResizeSubscription = initViewportObservable(configuration).subscribe(function (data) {\n        viewportResizeCb(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: function () {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function tackVisualViewportResize(configuration, visualViewportResizeCb) {\n    var visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    var _a = throttle(function () {\n        visualViewportResizeCb({\n            data: getVisualViewport(visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp: timeStampNow(),\n        });\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(configuration, visualViewport, [DOM_EVENT.RESIZE, DOM_EVENT.SCROLL], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return {\n        stop: function () {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackViewportResize.js.map","import { DOM_EVENT, addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackMediaInteraction(configuration, mediaInteractionCb) {\n    return addEventListeners(configuration, document, [DOM_EVENT.PLAY, DOM_EVENT.PAUSE], function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, {\n            id: getSerializedNodeId(target),\n            type: event.type === DOM_EVENT.PLAY ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        }));\n    }, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMediaInteraction.js.map","import { instrumentMethod } from '@datadog/browser-core';\nimport { IncrementalSource } from '../../../types';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackStyleSheet(styleSheetCb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethod(CSSStyleSheet.prototype, 'insertRule', function (_a) {\n            var styleSheet = _a.target, _b = _a.parameters, rule = _b[0], index = _b[1];\n            checkStyleSheetAndCallback(styleSheet, function (id) {\n                return styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                    id: id,\n                    adds: [{ rule: rule, index: index }],\n                }));\n            });\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', function (_a) {\n            var styleSheet = _a.target, index = _a.parameters[0];\n            checkStyleSheetAndCallback(styleSheet, function (id) {\n                return styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                    id: id,\n                    removes: [{ index: index }],\n                }));\n            });\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethod(cls.prototype, 'insertRule', function (_a) {\n            var styleSheet = _a.target, _b = _a.parameters, rule = _b[0], index = _b[1];\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, function (id) {\n                var path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index || 0);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id: id,\n                        adds: [{ rule: rule, index: path }],\n                    }));\n                }\n            });\n        }), instrumentMethod(cls.prototype, 'deleteRule', function (_a) {\n            var styleSheet = _a.target, index = _a.parameters[0];\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, function (id) {\n                var path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id: id,\n                        removes: [{ index: path }],\n                    }));\n                }\n            });\n        }));\n    }\n    return {\n        stop: function () {\n            instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        },\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=trackStyleSheet.js.map","import { DOM_EVENT, addEventListeners, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackFocus(configuration, focusCb) {\n    return addEventListeners(configuration, window, [DOM_EVENT.FOCUS, DOM_EVENT.BLUR], function () {\n        focusCb({\n            data: { has_focus: document.hasFocus() },\n            type: RecordType.Focus,\n            timestamp: timeStampNow(),\n        });\n    });\n}\n//# sourceMappingURL=trackFocus.js.map","import { RecordType } from '../../../types';\nexport function trackFrustration(lifeCycle, frustrationCb, recordIds) {\n    var frustrationSubscription = lifeCycle.subscribe(12 /* 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    });\n    return {\n        stop: function () {\n            frustrationSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFrustration.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackViewEnd(lifeCycle, viewEndCb) {\n    var viewEndSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, function () {\n        viewEndCb({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    });\n    return {\n        stop: function () {\n            viewEndSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackViewEnd.js.map","import { instrumentSetter, assign, DOM_EVENT, addEventListeners, forEach, noop } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel, shouldMaskNode, cssEscape } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackInput(configuration, inputCb, target) {\n    if (target === void 0) { target = document; }\n    var defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    var lastInputStateMap = new WeakMap();\n    var isShadowRoot = target !== document;\n    var stopEventListeners = addEventListeners(configuration, target, \n    // The 'input' event bubbles across shadow roots, so we don't have to listen for it on shadow\n    // roots since it will be handled by the event listener that we did add to the document. Only\n    // the 'change' event is blocked and needs to be handled on shadow roots.\n    isShadowRoot ? [DOM_EVENT.CHANGE] : [DOM_EVENT.INPUT, DOM_EVENT.CHANGE], function (event) {\n        var target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n    var stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        var instrumentationStoppers_1 = [\n            instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n            instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n        ];\n        stopPropertySetterInstrumentation = function () {\n            instrumentationStoppers_1.forEach(function (stopper) { return stopper.stop(); });\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return {\n        stop: function () {\n            stopPropertySetterInstrumentation();\n            stopEventListeners();\n        },\n    };\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(cssEscape(name), \"\\\"]\")), function (el) {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        var lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            inputCb(assembleIncrementalSnapshot(IncrementalSource.Input, assign({\n                id: getSerializedNodeId(target),\n            }, inputState)));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.js.map","import { noop, monitor, throttle } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar MUTATION_PROCESS_MAX_DELAY = 100;\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport var MUTATION_PROCESS_MIN_DELAY = 16;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    var _a = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n        leading: false,\n    }), throttledFlush = _a.throttled, cancelThrottle = _a.cancel;\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n            cancelThrottle();\n        },\n    };\n}\n/**\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 { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\nimport { assembleIncrementalSnapshot } from '../assembly';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function trackMutation(mutationCallback, configuration, shadowRootsController, target) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController) {\n    var nodePrivacyLevelCache = new Map();\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (removedNode) {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    var filteredMutations = mutations.filter(function (mutation) {\n        return mutation.target.isConnected &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !==\n                NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController, nodePrivacyLevelCache), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), configuration, nodePrivacyLevelCache);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration, nodePrivacyLevelCache);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback(assembleIncrementalSnapshot(IncrementalSource.Mutation, { adds: adds, removes: removes, texts: texts, attributes: attributes }));\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController, nodePrivacyLevelCache) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    var sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    var removedNodeMutations = [];\n    removedNodes.forEach(function (parent, node) {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, configuration, nodePrivacyLevelCache) {\n    var _a;\n    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (mutation) {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, configuration, nodePrivacyLevelCache) {\n    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes === 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, nodePrivacyLevelCache);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        var emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort(function (a, b) {\n        var position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    forEachChildNodes(removedNode, function (childNode) { return traverseRemovedShadowDom(childNode, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=trackMutation.js.map","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport var initShadowRootsController = function (configuration, callback, elementsScrollPositions) {\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            var mutationTracker = trackMutation(callback, configuration, shadowRootsController, shadowRoot);\n            // The change event does not bubble up across the shadow root, we have to listen on the shadow root\n            var inputTracker = trackInput(configuration, callback, shadowRoot);\n            // The scroll event does not bubble up across the shadow root, we have to listen on the shadow root\n            var scrollTracker = trackScroll(configuration, callback, elementsScrollPositions, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: function () { return mutationTracker.flush(); },\n                stop: function () {\n                    mutationTracker.stop();\n                    inputTracker.stop();\n                    scrollTracker.stop();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { sendToExtension } from '@datadog/browser-core';\nimport * as replayStats from '../replayStats';\nimport { trackFocus, trackFrustration, trackInput, trackMediaInteraction, trackMouseInteraction, trackMove, trackMutation, trackScroll, trackStyleSheet, trackViewEnd, trackViewportResize, } from './trackers';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nimport { startFullSnapshots } from './startFullSnapshots';\nimport { initRecordIds } from './recordIds';\nexport function record(options) {\n    var emit = options.emit, configuration = options.configuration, lifeCycle = options.lifeCycle;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var emitAndComputeStats = function (record) {\n        emit(record);\n        sendToExtension('record', { record: record });\n        var view = options.viewContexts.findView();\n        replayStats.addRecord(view.id);\n    };\n    var elementsScrollPositions = createElementsScrollPositions();\n    var shadowRootsController = initShadowRootsController(configuration, emitAndComputeStats, elementsScrollPositions);\n    var stopFullSnapshots = startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, function (records) { return records.forEach(function (record) { return emitAndComputeStats(record); }); }).stop;\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    var recordIds = initRecordIds();\n    var mutationTracker = trackMutation(emitAndComputeStats, configuration, shadowRootsController, document);\n    var trackers = [\n        mutationTracker,\n        trackMove(configuration, emitAndComputeStats),\n        trackMouseInteraction(configuration, emitAndComputeStats, recordIds),\n        trackScroll(configuration, emitAndComputeStats, elementsScrollPositions, document),\n        trackViewportResize(configuration, emitAndComputeStats),\n        trackInput(configuration, emitAndComputeStats),\n        trackMediaInteraction(configuration, emitAndComputeStats),\n        trackStyleSheet(emitAndComputeStats),\n        trackFocus(configuration, emitAndComputeStats),\n        trackViewportResize(configuration, emitAndComputeStats),\n        trackFrustration(lifeCycle, emitAndComputeStats, recordIds),\n        trackViewEnd(lifeCycle, function (viewEndRecord) {\n            flushMutations();\n            emitAndComputeStats(viewEndRecord);\n        }),\n    ];\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            trackers.forEach(function (tracker) { return tracker.stop(); });\n            stopFullSnapshots();\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { getScrollX, getScrollY, getViewportDimension } from '@datadog/browser-rum-core';\nimport { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { serializeDocument } from './serialization';\nimport { getVisualViewport } from './viewports';\nexport function startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, fullSnapshotCallback) {\n    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        var records = [\n            {\n                data: {\n                    height: height,\n                    href: window.location.href,\n                    width: width,\n                },\n                type: RecordType.Meta,\n                timestamp: timestamp,\n            },\n            {\n                data: {\n                    has_focus: document.hasFocus(),\n                },\n                type: RecordType.Focus,\n                timestamp: timestamp,\n            },\n            {\n                data: {\n                    node: serializeDocument(document, configuration, serializationContext),\n                    initialOffset: {\n                        left: getScrollX(),\n                        top: getScrollY(),\n                    },\n                },\n                type: RecordType.FullSnapshot,\n                timestamp: timestamp,\n            },\n        ];\n        if (window.visualViewport) {\n            records.push({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n        return records;\n    };\n    fullSnapshotCallback(takeFullSnapshot());\n    var unsubscribe = lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        flushMutations();\n        fullSnapshotCallback(takeFullSnapshot(view.startClocks.timeStamp, {\n            shadowRootsController: shadowRootsController,\n            status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n        }));\n    }).unsubscribe;\n    return {\n        stop: unsubscribe,\n    };\n}\n//# sourceMappingURL=startFullSnapshots.js.map","export function initRecordIds() {\n    var recordIds = new WeakMap();\n    var nextId = 1;\n    return {\n        getIdForEvent: function (event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { assign } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar Segment = /** @class */ (function () {\n    function Segment(encoder, context, creationReason) {\n        this.encoder = encoder;\n        this.encodedBytesCount = 0;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: Infinity,\n            end: -Infinity,\n            creation_reason: creationReason,\n            records_count: 0,\n            has_full_snapshot: false,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n            source: 'browser',\n        }, context);\n        replayStats.addSegment(viewId);\n    }\n    Segment.prototype.addRecord = function (record, callback) {\n        var _this = this;\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        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        var prefix = this.encoder.isEmpty ? '{\"records\":[' : ',';\n        this.encoder.write(prefix + JSON.stringify(record), function (additionalEncodedBytesCount) {\n            _this.encodedBytesCount += additionalEncodedBytesCount;\n            callback(_this.encodedBytesCount);\n        });\n    };\n    Segment.prototype.flush = function (callback) {\n        var _this = this;\n        if (this.encoder.isEmpty) {\n            throw new Error('Empty segment flushed');\n        }\n        this.encoder.write(\"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"));\n        this.encoder.finish(function (encoderResult) {\n            replayStats.addWroteData(_this.metadata.view.id, encoderResult.rawBytesCount);\n            callback(_this.metadata, encoderResult);\n        });\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, configuration, sessionManager, viewContexts, httpRequest, encoder) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(configuration.applicationId, sessionManager, viewContexts); }, httpRequest, encoder);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, encoder) {\n    var state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribePageExited = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n        flushSegment(pageExitEvent.reason);\n    }).unsubscribe;\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush(function (metadata, encoderResult) {\n                var payload = buildReplayPayload(encoderResult.output, metadata, encoderResult.rawBytesCount);\n                if (isPageExitReason(flushReason)) {\n                    httpRequest.sendOnExit(payload);\n                }\n                else {\n                    httpRequest.send(payload);\n                }\n            });\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* SegmentCollectionStatus.Stopped */,\n            };\n        }\n    }\n    return {\n        addRecord: function (record) {\n            if (state.status === 2 /* SegmentCollectionStatus.Stopped */) {\n                return;\n            }\n            if (state.status === 0 /* SegmentCollectionStatus.WaitingForInitialRecord */) {\n                var context = getSegmentContext();\n                if (!context) {\n                    return;\n                }\n                state = {\n                    status: 1 /* SegmentCollectionStatus.SegmentPending */,\n                    segment: new Segment(encoder, context, state.nextSegmentCreationReason),\n                    expirationTimeoutId: setTimeout(function () {\n                        flushSegment('segment_duration_limit');\n                    }, SEGMENT_DURATION_LIMIT),\n                };\n            }\n            state.segment.addRecord(record, function (encodedBytesCount) {\n                if (encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        stop: function () {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, 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","/**\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.sessionReplay === 0 /* SessionReplayState.OFF */) {\n        // possibilities\n        // - replay sampled out\n        return 'incorrect-session-plan';\n    }\n    if (!isRecordingStarted) {\n        return 'replay-not-started';\n    }\n}\n//# sourceMappingURL=getSessionReplayLink.js.map","import { addEventListener, addTelemetryDebug, assign, concatBuffers } from '@datadog/browser-core';\nexport function createDeflateEncoder(configuration, worker, streamId) {\n    var rawBytesCount = 0;\n    var compressedData = [];\n    var compressedDataTrailer;\n    var nextWriteActionId = 0;\n    var pendingWriteActions = [];\n    var removeMessageListener = addEventListener(configuration, worker, 'message', function (_a) {\n        var workerResponse = _a.data;\n        if (workerResponse.type !== 'wrote' || workerResponse.streamId !== streamId) {\n            return;\n        }\n        rawBytesCount += workerResponse.additionalBytesCount;\n        compressedData.push(workerResponse.result);\n        compressedDataTrailer = workerResponse.trailer;\n        var nextPendingAction = pendingWriteActions.shift();\n        if (nextPendingAction && nextPendingAction.id === workerResponse.id) {\n            if (nextPendingAction.writeCallback) {\n                nextPendingAction.writeCallback(workerResponse.result.byteLength);\n            }\n            else if (nextPendingAction.finishCallback) {\n                nextPendingAction.finishCallback();\n            }\n        }\n        else {\n            removeMessageListener();\n            addTelemetryDebug('Worker responses received out of order.');\n        }\n    }).stop;\n    function consumeResult() {\n        var output = compressedData.length === 0 ? new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer));\n        var result = {\n            rawBytesCount: rawBytesCount,\n            output: output,\n            outputBytesCount: output.byteLength,\n            encoding: 'deflate',\n        };\n        rawBytesCount = 0;\n        compressedData = [];\n        return result;\n    }\n    function sendResetIfNeeded() {\n        if (nextWriteActionId > 0) {\n            worker.postMessage({\n                action: 'reset',\n                streamId: streamId,\n            });\n            nextWriteActionId = 0;\n        }\n    }\n    return {\n        isAsync: true,\n        get isEmpty() {\n            return nextWriteActionId === 0;\n        },\n        write: function (data, callback) {\n            worker.postMessage({\n                action: 'write',\n                id: nextWriteActionId,\n                data: data,\n                streamId: streamId,\n            });\n            pendingWriteActions.push({\n                id: nextWriteActionId,\n                writeCallback: callback,\n                data: data,\n            });\n            nextWriteActionId += 1;\n        },\n        finish: function (callback) {\n            sendResetIfNeeded();\n            if (!pendingWriteActions.length) {\n                callback(consumeResult());\n            }\n            else {\n                // Make sure we do not call any write callback\n                pendingWriteActions.forEach(function (pendingWriteAction) {\n                    delete pendingWriteAction.writeCallback;\n                });\n                // Wait for the last action to finish before calling the finish callback\n                pendingWriteActions[pendingWriteActions.length - 1].finishCallback = function () { return callback(consumeResult()); };\n            }\n        },\n        finishSync: function () {\n            sendResetIfNeeded();\n            var pendingData = pendingWriteActions\n                .map(function (pendingWriteAction) {\n                // Make sure we do not call any write or finish callback\n                delete pendingWriteAction.writeCallback;\n                delete pendingWriteAction.finishCallback;\n                return pendingWriteAction.data;\n            })\n                .join('');\n            return assign(consumeResult(), {\n                pendingData: pendingData,\n            });\n        },\n        estimateEncodedBytesCount: function (data) {\n            // This is a rough estimation of the data size once it'll be encoded by deflate. We observed\n            // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but\n            // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce\n            // requests of the expected size.\n            return data.length / 8;\n        },\n        stop: function () {\n            removeMessageListener();\n        },\n    };\n}\n//# sourceMappingURL=deflateEncoder.js.map","import { addTelemetryError, display, includes, addEventListener, setTimeout, ONE_SECOND, DOCS_ORIGIN, } from '@datadog/browser-core';\nexport var INITIALIZATION_TIME_OUT_DELAY = 10 * ONE_SECOND;\nfunction createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"!function(){\\\"use strict\\\";function t(t){for(var e=t.reduce((function(t,e){return t+e.length}),0),a=new Uint8Array(e),n=0,r=0,i=t;r<i.length;r++){var s=i[r];a.set(s,n),n+=s.length}return a}function e(t){for(var e=t.length;--e>=0;)t[e]=0}var a=256,n=286,r=30,i=15,s=new Uint8Array([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]),_=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]),o=new Array(576);e(o);var d=new Array(60);e(d);var u=new Array(512);e(u);var f=new Array(256);e(f);var c=new Array(29);e(c);var p,g,w,v=new Array(r);function b(t,e,a,n,r){this.static_tree=t,this.extra_bits=e,this.extra_base=a,this.elems=n,this.max_length=r,this.has_stree=t&&t.length}function m(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}e(v);var y=function(t){return t<256?u[t]:u[256+(t>>>7)]},k=function(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},z=function(t,e,a){t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,k(t,t.bi_buf),t.bi_buf=e>>16-t.bi_valid,t.bi_valid+=a-16):(t.bi_buf|=e<<t.bi_valid&65535,t.bi_valid+=a)},x=function(t,e,a){z(t,a[2*e],a[2*e+1])},A=function(t,e){var a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},E=function(t,e,a){var n,r,s=new Array(16),_=0;for(n=1;n<=i;n++)s[n]=_=_+a[n-1]<<1;for(r=0;r<=e;r++){var h=t[2*r+1];0!==h&&(t[2*r]=A(s[h]++,h))}},Z=function(t){var e;for(e=0;e<n;e++)t.dyn_ltree[2*e]=0;for(e=0;e<r;e++)t.dyn_dtree[2*e]=0;for(e=0;e<19;e++)t.bl_tree[2*e]=0;t.dyn_ltree[512]=1,t.opt_len=t.static_len=0,t.last_lit=t.matches=0},U=function(t){t.bi_valid>8?k(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},S=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]},R=function(t,e,a){for(var n=t.heap[a],r=a<<1;r<=t.heap_len&&(r<t.heap_len&&S(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!S(e,n,t.heap[r],t.depth));)t.heap[a]=t.heap[r],a=r,r<<=1;t.heap[a]=n},L=function(t,e,n){var r,i,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],i=t.pending_buf[t.l_buf+o],o++,0===r?x(t,i,e):(h=f[i],x(t,h+a+1,e),0!==(l=s[h])&&(i-=c[h],z(t,i,l)),r--,h=y(r),x(t,h,n),0!==(l=_[h])&&(r-=v[h],z(t,r,l)))}while(o<t.last_lit);x(t,256,e)},F=function(t,e){var a,n,r,s=e.dyn_tree,_=e.stat_desc.static_tree,h=e.stat_desc.has_stree,l=e.stat_desc.elems,o=-1;for(t.heap_len=0,t.heap_max=573,a=0;a<l;a++)0!==s[2*a]?(t.heap[++t.heap_len]=o=a,t.depth[a]=0):s[2*a+1]=0;for(;t.heap_len<2;)s[2*(r=t.heap[++t.heap_len]=o<2?++o:0)]=1,t.depth[r]=0,t.opt_len--,h&&(t.static_len-=_[2*r+1]);for(e.max_code=o,a=t.heap_len>>1;a>=1;a--)R(t,s,a);r=l;do{a=t.heap[1],t.heap[1]=t.heap[t.heap_len--],R(t,s,1),n=t.heap[1],t.heap[--t.heap_max]=a,t.heap[--t.heap_max]=n,s[2*r]=s[2*a]+s[2*n],t.depth[r]=(t.depth[a]>=t.depth[n]?t.depth[a]:t.depth[n])+1,s[2*a+1]=s[2*n+1]=r,t.heap[1]=r++,R(t,s,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var a,n,r,s,_,h,l=e.dyn_tree,o=e.max_code,d=e.stat_desc.static_tree,u=e.stat_desc.has_stree,f=e.stat_desc.extra_bits,c=e.stat_desc.extra_base,p=e.stat_desc.max_length,g=0;for(s=0;s<=i;s++)t.bl_count[s]=0;for(l[2*t.heap[t.heap_max]+1]=0,a=t.heap_max+1;a<573;a++)(s=l[2*l[2*(n=t.heap[a])+1]+1]+1)>p&&(s=p,g++),l[2*n+1]=s,n>o||(t.bl_count[s]++,_=0,n>=c&&(_=f[n-c]),h=l[2*n],t.opt_len+=h*(s+_),u&&(t.static_len+=h*(d[2*n+1]+_)));if(0!==g){do{for(s=p-1;0===t.bl_count[s];)s--;t.bl_count[s]--,t.bl_count[s+1]+=2,t.bl_count[p]--,g-=2}while(g>0);for(s=p;0!==s;s--)for(n=t.bl_count[s];0!==n;)(r=t.heap[--a])>o||(l[2*r+1]!==s&&(t.opt_len+=(s-l[2*r+1])*l[2*r],l[2*r+1]=s),n--)}}(t,e),E(s,o,t.bl_count)},T=function(t,e,a){var n,r,i=-1,s=e[1],_=0,h=7,l=4;for(0===s&&(h=138,l=3),e[2*(a+1)+1]=65535,n=0;n<=a;n++)r=s,s=e[2*(n+1)+1],++_<h&&r===s||(_<l?t.bl_tree[2*r]+=_:0!==r?(r!==i&&t.bl_tree[2*r]++,t.bl_tree[32]++):_<=10?t.bl_tree[34]++:t.bl_tree[36]++,_=0,i=r,0===s?(h=138,l=3):r===s?(h=6,l=3):(h=7,l=4))},I=function(t,e,a){var n,r,i=-1,s=e[1],_=0,h=7,l=4;for(0===s&&(h=138,l=3),n=0;n<=a;n++)if(r=s,s=e[2*(n+1)+1],!(++_<h&&r===s)){if(_<l)do{x(t,r,t.bl_tree)}while(0!=--_);else 0!==r?(r!==i&&(x(t,r,t.bl_tree),_--),x(t,16,t.bl_tree),z(t,_-3,2)):_<=10?(x(t,17,t.bl_tree),z(t,_-3,3)):(x(t,18,t.bl_tree),z(t,_-11,7));_=0,i=r,0===s?(h=138,l=3):r===s?(h=6,l=3):(h=7,l=4)}},N=!1,O=function(t,e,a,n){z(t,0+(n?1:0),3),function(t,e,a,n){U(t),n&&(k(t,a),k(t,~a)),t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a}(t,e,a,!0)},D=function(t,e,n,r){var i,s,_=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=function(t){var e,n=4093624447;for(e=0;e<=31;e++,n>>>=1)if(1&n&&0!==t.dyn_ltree[2*e])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(e=32;e<a;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0}(t)),F(t,t.l_desc),F(t,t.d_desc),_=function(t){var e;for(T(t,t.dyn_ltree,t.l_desc.max_code),T(t,t.dyn_dtree,t.d_desc.max_code),F(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!==e?O(t,e,n,r):4===t.strategy||s===i?(z(t,2+(r?1:0),3),L(t,o,d)):(z(t,4+(r?1:0),3),function(t,e,a,n){var r;for(z(t,e-257,5),z(t,a-1,5),z(t,n-4,4),r=0;r<n;r++)z(t,t.bl_tree[2*l[r]+1],3);I(t,t.dyn_ltree,e-1),I(t,t.dyn_dtree,a-1)}(t,t.l_desc.max_code+1,t.d_desc.max_code+1,_+1),L(t,t.dyn_ltree,t.dyn_dtree)),Z(t),r&&U(t)},B={_tr_init:function(t){N||(!function(){var t,e,a,l,m,y=new Array(16);for(a=0,l=0;l<28;l++)for(c[l]=a,t=0;t<1<<s[l];t++)f[a++]=l;for(f[a-1]=l,m=0,l=0;l<16;l++)for(v[l]=m,t=0;t<1<<_[l];t++)u[m++]=l;for(m>>=7;l<r;l++)for(v[l]=m<<7,t=0;t<1<<_[l]-7;t++)u[256+m++]=l;for(e=0;e<=i;e++)y[e]=0;for(t=0;t<=143;)o[2*t+1]=8,t++,y[8]++;for(;t<=255;)o[2*t+1]=9,t++,y[9]++;for(;t<=279;)o[2*t+1]=7,t++,y[7]++;for(;t<=287;)o[2*t+1]=8,t++,y[8]++;for(E(o,287,y),t=0;t<r;t++)d[2*t+1]=5,d[2*t]=A(t,5);p=new b(o,s,257,n,i),g=new b(d,_,0,r,i),w=new b(new Array(0),h,0,19,7)}(),N=!0),t.l_desc=new m(t.dyn_ltree,p),t.d_desc=new m(t.dyn_dtree,g),t.bl_desc=new m(t.bl_tree,w),t.bi_buf=0,t.bi_valid=0,Z(t)},_tr_stored_block:O,_tr_flush_block:D,_tr_tally:function(t,e,n){return t.pending_buf[t.d_buf+2*t.last_lit]=e>>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&e,t.pending_buf[t.l_buf+t.last_lit]=255&n,t.last_lit++,0===e?t.dyn_ltree[2*n]++:(t.matches++,e--,t.dyn_ltree[2*(f[n]+a+1)]++,t.dyn_dtree[2*y(e)]++),t.last_lit===t.lit_bufsize-1},_tr_align:function(t){z(t,2,3),x(t,256,o),function(t){16===t.bi_valid?(k(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)}(t)}},C=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},H=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}()),M=function(t,e,a,n){var r=H,i=n+a;t^=-1;for(var s=n;s<i;s++)t=t>>>8^r[255&(t^e[s])];return-1^t},Y={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\\\"},K={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8},P=B._tr_init,j=B._tr_stored_block,G=B._tr_flush_block,X=B._tr_tally,W=B._tr_align,q=K.Z_NO_FLUSH,J=K.Z_PARTIAL_FLUSH,Q=K.Z_FULL_FLUSH,V=K.Z_FINISH,$=K.Z_BLOCK,tt=K.Z_OK,et=K.Z_STREAM_END,at=K.Z_STREAM_ERROR,nt=K.Z_DATA_ERROR,rt=K.Z_BUF_ERROR,it=K.Z_DEFAULT_COMPRESSION,st=K.Z_FILTERED,_t=K.Z_HUFFMAN_ONLY,ht=K.Z_RLE,lt=K.Z_FIXED,ot=K.Z_DEFAULT_STRATEGY,dt=K.Z_UNKNOWN,ut=K.Z_DEFLATED,ft=258,ct=262,pt=103,gt=113,wt=666,vt=function(t,e){return t.msg=Y[e],e},bt=function(t){return(t<<1)-(t>4?9:0)},mt=function(t){for(var e=t.length;--e>=0;)t[e]=0},yt=function(t,e,a){return(e<<t.hash_shift^a)&t.hash_mask},kt=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))},zt=function(t,e){G(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,kt(t.strm)},xt=function(t,e){t.pending_buf[t.pending++]=e},At=function(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},Et=function(t,e){var a,n,r=t.max_chain_length,i=t.strstart,s=t.prev_length,_=t.nice_match,h=t.strstart>t.w_size-ct?t.strstart-(t.w_size-ct):0,l=t.window,o=t.w_mask,d=t.prev,u=t.strstart+ft,f=l[i+s-1],c=l[i+s];t.prev_length>=t.good_match&&(r>>=2),_>t.lookahead&&(_=t.lookahead);do{if(l[(a=e)+s]===c&&l[a+s-1]===f&&l[a]===l[i]&&l[++a]===l[i+1]){i+=2,a++;do{}while(l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&i<u);if(n=ft-(u-i),i=u-ft,n>s){if(t.match_start=e,s=n,n>=_)break;f=l[i+s-1],c=l[i+s]}}}while((e=d[e&o])>h&&0!=--r);return s<=t.lookahead?s:t.lookahead},Zt=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-ct)){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,_=t.window,h=t.strstart+t.lookahead,l=r,o=void 0,(o=s.avail_in)>l&&(o=l),a=0===o?0:(s.avail_in-=o,_.set(s.input.subarray(s.next_in,s.next_in+o),h),1===s.state.wrap?s.adler=C(s.adler,_,o,h):2===s.state.wrap&&(s.adler=M(s.adler,_,o,h)),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=yt(t,t.ins_h,t.window[i+1]);t.insert&&(t.ins_h=yt(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<ct&&0!==t.strm.avail_in)},Ut=function(t,e){for(var a,n;;){if(t.lookahead<ct){if(Zt(t),t.lookahead<ct&&e===q)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=yt(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-ct&&(t.match_length=Et(t,a)),t.match_length>=3)if(n=X(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=yt(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=yt(t,t.ins_h,t.window[t.strstart+1]);else n=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(n&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2},St=function(t,e){for(var a,n,r;;){if(t.lookahead<ct){if(Zt(t),t.lookahead<ct&&e===q)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=yt(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-ct&&(t.match_length=Et(t,a),t.match_length<=5&&(t.strategy===st||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=X(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=yt(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&&(zt(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if((n=X(t,0,t.window[t.strstart-1]))&&zt(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=X(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2};function Rt(t,e,a,n,r){this.good_length=t,this.max_lazy=e,this.nice_length=a,this.max_chain=n,this.func=r}var Lt=[new Rt(0,0,0,0,(function(t,e){var a=65535;for(a>t.pending_buf_size-5&&(a=t.pending_buf_size-5);;){if(t.lookahead<=1){if(Zt(t),0===t.lookahead&&e===q)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,zt(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-ct&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(zt(t,!1),t.strm.avail_out),1)})),new Rt(4,4,8,4,Ut),new Rt(4,5,16,8,Ut),new Rt(4,6,32,32,Ut),new Rt(4,4,16,16,St),new Rt(8,16,32,32,St),new Rt(8,16,128,128,St),new Rt(8,32,128,256,St),new Rt(32,128,258,1024,St),new Rt(32,258,258,4096,St)];function Ft(){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=ut,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),mt(this.dyn_ltree),mt(this.dyn_dtree),mt(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),mt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),mt(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 Tt=function(t){if(!t||!t.state)return vt(t,at);t.total_in=t.total_out=0,t.data_type=dt;var e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:gt,t.adler=2===e.wrap?0:1,e.last_flush=q,P(e),tt},It=function(t){var e,a=Tt(t);return a===tt&&((e=t.state).window_size=2*e.w_size,mt(e.head),e.max_lazy_match=Lt[e.level].max_lazy,e.good_match=Lt[e.level].good_length,e.nice_match=Lt[e.level].nice_length,e.max_chain_length=Lt[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},Nt=function(t,e,a,n,r,i){if(!t)return at;var s=1;if(e===it&&(e=6),n<0?(s=0,n=-n):n>15&&(s=2,n-=16),r<1||r>9||a!==ut||n<8||n>15||e<0||e>9||i<0||i>lt)return vt(t,at);8===n&&(n=9);var _=new Ft;return t.state=_,_.strm=t,_.wrap=s,_.gzhead=null,_.w_bits=n,_.w_size=1<<_.w_bits,_.w_mask=_.w_size-1,_.hash_bits=r+7,_.hash_size=1<<_.hash_bits,_.hash_mask=_.hash_size-1,_.hash_shift=~~((_.hash_bits+3-1)/3),_.window=new Uint8Array(2*_.w_size),_.head=new Uint16Array(_.hash_size),_.prev=new Uint16Array(_.w_size),_.lit_bufsize=1<<r+6,_.pending_buf_size=4*_.lit_bufsize,_.pending_buf=new Uint8Array(_.pending_buf_size),_.d_buf=1*_.lit_bufsize,_.l_buf=3*_.lit_bufsize,_.level=e,_.strategy=i,_.method=a,It(t)},Ot={deflateInit:function(t,e){return Nt(t,e,ut,15,8,ot)},deflateInit2:Nt,deflateReset:It,deflateResetKeep:Tt,deflateSetHeader:function(t,e){return t&&t.state?2!==t.state.wrap?at:(t.state.gzhead=e,tt):at},deflate:function(t,e){var a,n;if(!t||!t.state||e>$||e<0)return t?vt(t,at):at;var r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===wt&&e!==V)return vt(t,0===t.avail_out?rt:at);r.strm=t;var i=r.last_flush;if(r.last_flush=e,42===r.status)if(2===r.wrap)t.adler=0,xt(r,31),xt(r,139),xt(r,8),r.gzhead?(xt(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)),xt(r,255&r.gzhead.time),xt(r,r.gzhead.time>>8&255),xt(r,r.gzhead.time>>16&255),xt(r,r.gzhead.time>>24&255),xt(r,9===r.level?2:r.strategy>=_t||r.level<2?4:0),xt(r,255&r.gzhead.os),r.gzhead.extra&&r.gzhead.extra.length&&(xt(r,255&r.gzhead.extra.length),xt(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(t.adler=M(t.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=69):(xt(r,0),xt(r,0),xt(r,0),xt(r,0),xt(r,0),xt(r,9===r.level?2:r.strategy>=_t||r.level<2?4:0),xt(r,3),r.status=gt);else{var s=ut+(r.w_bits-8<<4)<<8;s|=(r.strategy>=_t||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=gt,At(r,s),0!==r.strstart&&(At(r,t.adler>>>16),At(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=M(t.adler,r.pending_buf,r.pending-a,a)),kt(t),a=r.pending,r.pending!==r.pending_buf_size));)xt(r,255&r.gzhead.extra[r.gzindex]),r.gzindex++;r.gzhead.hcrc&&r.pending>a&&(t.adler=M(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=M(t.adler,r.pending_buf,r.pending-a,a)),kt(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,xt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=M(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=M(t.adler,r.pending_buf,r.pending-a,a)),kt(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,xt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.status=pt)}else r.status=pt;if(r.status===pt&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&kt(t),r.pending+2<=r.pending_buf_size&&(xt(r,255&t.adler),xt(r,t.adler>>8&255),t.adler=0,r.status=gt)):r.status=gt),0!==r.pending){if(kt(t),0===t.avail_out)return r.last_flush=-1,tt}else if(0===t.avail_in&&bt(e)<=bt(i)&&e!==V)return vt(t,rt);if(r.status===wt&&0!==t.avail_in)return vt(t,rt);if(0!==t.avail_in||0!==r.lookahead||e!==q&&r.status!==wt){var _=r.strategy===_t?function(t,e){for(var a;;){if(0===t.lookahead&&(Zt(t),0===t.lookahead)){if(e===q)return 1;break}if(t.match_length=0,a=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2}(r,e):r.strategy===ht?function(t,e){for(var a,n,r,i,s=t.window;;){if(t.lookahead<=ft){if(Zt(t),t.lookahead<=ft&&e===q)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+ft;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=ft-(i-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=X(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2}(r,e):Lt[r.level].func(r,e);if(3!==_&&4!==_||(r.status=wt),1===_||3===_)return 0===t.avail_out&&(r.last_flush=-1),tt;if(2===_&&(e===J?W(r):e!==$&&(j(r,0,0,!1),e===Q&&(mt(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),kt(t),0===t.avail_out))return r.last_flush=-1,tt}return e!==V?tt:r.wrap<=0?et:(2===r.wrap?(xt(r,255&t.adler),xt(r,t.adler>>8&255),xt(r,t.adler>>16&255),xt(r,t.adler>>24&255),xt(r,255&t.total_in),xt(r,t.total_in>>8&255),xt(r,t.total_in>>16&255),xt(r,t.total_in>>24&255)):(At(r,t.adler>>>16),At(r,65535&t.adler)),kt(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?tt:et)},deflateEnd:function(t){if(!t||!t.state)return at;var e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==pt&&e!==gt&&e!==wt?vt(t,at):(t.state=null,e===gt?vt(t,nt):tt)},deflateSetDictionary:function(t,e){var a=e.length;if(!t||!t.state)return at;var n=t.state,r=n.wrap;if(2===r||1===r&&42!==n.status||n.lookahead)return at;if(1===r&&(t.adler=C(t.adler,e,a,0)),n.wrap=0,a>=n.w_size){0===r&&(mt(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,_=t.next_in,h=t.input;for(t.avail_in=a,t.next_in=0,t.input=e,Zt(n);n.lookahead>=3;){var l=n.strstart,o=n.lookahead-2;do{n.ins_h=yt(n,n.ins_h,n.window[l+3-1]),n.prev[l&n.w_mask]=n.head[n.ins_h],n.head[n.ins_h]=l,l++}while(--o);n.strstart=l,n.lookahead=2,Zt(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=_,t.input=h,t.avail_in=s,n.wrap=r,tt},deflateInfo:\\\"pako deflate (from Nodeca project)\\\"};for(var Dt=new Uint8Array(256),Bt=0;Bt<256;Bt++)Dt[Bt]=Bt>=252?6:Bt>=248?5:Bt>=240?4:Bt>=224?3:Bt>=192?2:1;Dt[254]=Dt[254]=1;var Ct=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},Ht=Object.prototype.toString,Mt=K.Z_NO_FLUSH,Yt=K.Z_SYNC_FLUSH,Kt=K.Z_FULL_FLUSH,Pt=K.Z_FINISH,jt=K.Z_OK,Gt=K.Z_STREAM_END,Xt=K.Z_DEFAULT_COMPRESSION,Wt=K.Z_DEFAULT_STRATEGY,qt=K.Z_DEFLATED;function Jt(){this.options={level:Xt,method:qt,chunkSize:16384,windowBits:15,memLevel:8,strategy:Wt};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 Ct,this.strm.avail_out=0;var e=Ot.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(e!==jt)throw new Error(Y[e]);if(t.header&&Ot.deflateSetHeader(this.strm,t.header),t.dictionary){var a;if(a=\\\"[object ArrayBuffer]\\\"===Ht.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,(e=Ot.deflateSetDictionary(this.strm,a))!==jt)throw new Error(Y[e]);this._dict_set=!0}}function Qt(t,e,a){try{t.postMessage({type:\\\"errored\\\",error:e,streamId:a})}catch(n){t.postMessage({type:\\\"errored\\\",error:String(e),streamId:a})}}function Vt(t){var e=t.strm.adler;return new Uint8Array([3,0,e>>>24&255,e>>>16&255,e>>>8&255,255&e])}Jt.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?Pt:Mt,\\\"[object ArrayBuffer]\\\"===Ht.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===Yt||n===Kt)&&r.avail_out<=6)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else{if((a=Ot.deflate(r,n))===Gt)return r.next_out>0&&this.onData(r.output.subarray(0,r.next_out)),a=Ot.deflateEnd(this.strm),this.onEnd(a),this.ended=!0,a===jt;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},Jt.prototype.onData=function(t){this.chunks.push(t)},Jt.prototype.onEnd=function(t){t===jt&&(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,_=t.length;i<_;i++){var h=t[i];r.set(h,s),s+=h.length}return r}(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg},function(e){void 0===e&&(e=self);try{var a=new Map;e.addEventListener(\\\"message\\\",(function(n){try{var r=function(e,a){switch(a.action){case\\\"init\\\":return{type:\\\"initialized\\\",version:\\\"5.22.0\\\"};case\\\"write\\\":var n=e.get(a.streamId);n||(n=new Jt,e.set(a.streamId,n));var r=n.chunks.length,i=function(t){if(\\\"function\\\"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);var e,a,n,r,i,s=t.length,_=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++),_+=a<128?1:a<2048?2:a<65536?3:4;for(e=new Uint8Array(_),i=0,r=0;i<_;r++)55296==(64512&(a=t.charCodeAt(r)))&&r+1<s&&56320==(64512&(n=t.charCodeAt(r+1)))&&(a=65536+(a-55296<<10)+(n-56320),r++),a<128?e[i++]=a:a<2048?(e[i++]=192|a>>>6,e[i++]=128|63&a):a<65536?(e[i++]=224|a>>>12,e[i++]=128|a>>>6&63,e[i++]=128|63&a):(e[i++]=240|a>>>18,e[i++]=128|a>>>12&63,e[i++]=128|a>>>6&63,e[i++]=128|63&a);return e}(a.data);return n.push(i,K.Z_SYNC_FLUSH),{type:\\\"wrote\\\",id:a.id,streamId:a.streamId,result:t(n.chunks.slice(r)),trailer:Vt(n),additionalBytesCount:i.length};case\\\"reset\\\":e.delete(a.streamId)}}(a,n.data);r&&e.postMessage(r)}catch(t){Qt(e,t,n.data&&\\\"streamId\\\"in n.data?n.data.streamId:void 0)}}))}catch(t){Qt(e,t)}}()}();\"])));\n}\nvar state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(configuration, source, onInitializationFailure, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    if (state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n        doStartDeflateWorker(configuration, source, createDeflateWorkerImpl);\n    }\n    switch (state.status) {\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.initializationFailureCallbacks.push(onInitializationFailure);\n            return state.worker;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            return state.worker;\n    }\n}\nexport function resetDeflateWorkerState() {\n    if (state.status === 3 /* DeflateWorkerStatus.Initialized */ || state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.stop();\n    }\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\n}\nexport function getDeflateWorkerStatus() {\n    return state.status;\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(configuration, source, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker = createDeflateWorkerImpl(configuration);\n        var removeErrorListener_1 = addEventListener(configuration, worker, 'error', function (error) {\n            onError(configuration, source, error);\n        }).stop;\n        var removeMessageListener_1 = addEventListener(configuration, worker, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(configuration, source, data.error, data.streamId);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(data.version);\n            }\n        }).stop;\n        worker.postMessage({ action: 'init' });\n        setTimeout(function () { return onTimeout(source); }, INITIALIZATION_TIME_OUT_DELAY);\n        var stop_1 = function () {\n            removeErrorListener_1();\n            removeMessageListener_1();\n        };\n        state = { status: 1 /* DeflateWorkerStatus.Loading */, worker: worker, stop: stop_1, initializationFailureCallbacks: [] };\n    }\n    catch (error) {\n        onError(configuration, source, error);\n    }\n}\nfunction onTimeout(source) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error(\"\".concat(source, \" failed to start: a timeout occurred while initializing the Worker\"));\n        state.initializationFailureCallbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n}\nfunction onInitialized(version) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: state.worker, stop: state.stop, version: version };\n    }\n}\nfunction onError(configuration, source, error, streamId) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */ || state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        display.error(\"\".concat(source, \" failed to start: an error occurred while creating the Worker:\"), error);\n        if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n            var baseMessage = void 0;\n            if (configuration.workerUrl) {\n                baseMessage = \"Please make sure the Worker URL \".concat(configuration.workerUrl, \" is correct and CSP is correctly configured.\");\n            }\n            else {\n                baseMessage = 'Please make sure CSP is correctly configured.';\n            }\n            display.error(\"\".concat(baseMessage, \" See documentation at \").concat(DOCS_ORIGIN, \"/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay\"));\n        }\n        else {\n            addTelemetryError(error);\n        }\n        if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n            state.initializationFailureCallbacks.forEach(function (callback) { return callback(); });\n        }\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error, {\n            worker_version: state.status === 3 /* DeflateWorkerStatus.Initialized */ && state.version,\n            stream_id: streamId,\n        });\n    }\n}\nfunction isMessageCspRelated(message) {\n    return (includes(message, 'Content Security Policy') ||\n        // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n        includes(message, \"requires 'TrustedScriptURL'\"));\n}\n//# sourceMappingURL=deflateWorker.js.map","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { startRecording } from '../boot/startRecording';\nimport { makeRecorderApi } from '../boot/recorderApi';\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi, { startDeflateWorker: startDeflateWorker, createDeflateEncoder: createDeflateEncoder });\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { canUseEventBridge, noop, runOnReadyState, PageExitReason, bridgeSupports, } from '@datadog/browser-core';\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { createDeflateEncoder, startDeflateWorker, getDeflateWorkerStatus, } from '../domain/deflate';\nimport { isBrowserSupported } from './isBrowserSupported';\nexport function makeRecorderApi(startRecordingImpl, createDeflateWorkerImpl) {\n    if ((canUseEventBridge() && !bridgeSupports(\"records\" /* BridgeCapability.RECORDS */)) || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n            getSessionReplayLink: function () { return undefined; },\n        };\n    }\n    var state = {\n        status: 1 /* RecorderStatus.IntentToStart */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* RecorderStatus.IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* RecorderStatus.Stopped */ };\n    };\n    var getSessionReplayLinkStrategy = noop;\n    return {\n        start: function (options) { return startStrategy(options); },\n        stop: function () { return stopStrategy(); },\n        getSessionReplayLink: function () { return getSessionReplayLinkStrategy(); },\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts, worker) {\n            if (configuration.startSessionReplayRecordingManually) {\n                state = { status: 0 /* RecorderStatus.Stopped */ };\n            }\n            lifeCycle.subscribe(9 /* 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            // Stop the recorder on page unload to avoid sending records after the page is ended.\n            lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n                if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n                    stopStrategy();\n                }\n            });\n            lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n                if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            var cachedDeflateEncoder;\n            function getOrCreateDeflateEncoder() {\n                if (!cachedDeflateEncoder) {\n                    if (!worker) {\n                        worker = startDeflateWorker(configuration, 'Datadog Session Replay', function () {\n                            stopStrategy();\n                        }, createDeflateWorkerImpl);\n                    }\n                    if (worker) {\n                        cachedDeflateEncoder = createDeflateEncoder(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */);\n                    }\n                }\n                return cachedDeflateEncoder;\n            }\n            startStrategy = function (options) {\n                var session = sessionManager.findTrackedSession();\n                if (!session || (session.sessionReplay === 0 /* SessionReplayState.OFF */ && !(options === null || options === void 0 ? void 0 : options.force))) {\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(configuration, 'interactive', function () {\n                    if (state.status !== 2 /* RecorderStatus.Starting */) {\n                        return;\n                    }\n                    var deflateEncoder = getOrCreateDeflateEncoder();\n                    if (!deflateEncoder) {\n                        state = {\n                            status: 0 /* RecorderStatus.Stopped */,\n                        };\n                        return;\n                    }\n                    var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, deflateEncoder).stop;\n                    state = {\n                        status: 3 /* RecorderStatus.Started */,\n                        stopRecording: stopRecording,\n                    };\n                });\n                if ((options === null || options === void 0 ? void 0 : options.force) && session.sessionReplay === 0 /* SessionReplayState.OFF */) {\n                    sessionManager.setForcedReplay();\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            getSessionReplayLinkStrategy = function () {\n                return getSessionReplayLink(configuration, sessionManager, viewContexts, state.status !== 0 /* RecorderStatus.Stopped */);\n            };\n            if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () {\n            // The worker is started optimistically, meaning we could have started to record but its\n            // initialization fails a bit later. This could happen when:\n            // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n            // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n            // * the browser fails to load the worker in case the workerUrl is used\n            // * an unexpected error occurs in the Worker before initialization, ex:\n            //   * a runtime exception collected by monitor()\n            //   * a syntax error notified by the browser via an error event\n            // * the worker is unresponsive for some reason and timeouts\n            //\n            // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n            // an important part of the Datadog App:\n            // * If we have a false positive (we set has_replay: true even if no replay data is present),\n            // we might display broken links to the Session Replay player.\n            // * If we have a false negative (we don't set has_replay: true even if replay data is\n            // available), it is less noticeable because no link will be displayed.\n            //\n            // Thus, it is better to have false negative, so let's make sure the worker is correctly\n            // initialized before advertizing that we are recording.\n            //\n            // In the future, when the compression worker will also be used for RUM data, this will be\n            // less important since no RUM event will be sent when the worker fails to initialize.\n            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ && state.status === 3 /* RecorderStatus.Started */;\n        },\n        getReplayStats: function (viewId) {\n            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ ? getReplayStatsImpl(viewId) : undefined;\n        },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { createHttpRequest, addTelemetryDebug, canUseEventBridge } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { startRecordBridge } from '../domain/startRecordBridge';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, encoder, httpRequest) {\n    var cleanupTasks = [];\n    var reportError = function (error) {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var replayRequest = httpRequest ||\n        createHttpRequest(configuration, configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var addRecord;\n    if (!canUseEventBridge()) {\n        var segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewContexts, replayRequest, encoder);\n        addRecord = segmentCollection.addRecord;\n        cleanupTasks.push(segmentCollection.stop);\n    }\n    else {\n        ;\n        (addRecord = startRecordBridge(viewContexts).addRecord);\n    }\n    var stopRecording = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n    }).stop;\n    cleanupTasks.push(stopRecording);\n    return {\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRecordBridge(viewContexts) {\n    var bridge = getEventBridge();\n    return {\n        addRecord: function (record) {\n            // Get the current active view, not at the time of the record, aligning with the segment logic.\n            // This approach could potentially associate the record to an incorrect view, in case the record date is in the past (e.g. frustration records).\n            // However the risk is minimal. We could address the issue when potential negative impact are identified.\n            var view = viewContexts.findView();\n            bridge.send('record', record, view.id);\n        },\n    };\n}\n//# sourceMappingURL=startRecordBridge.js.map","import { addTelemetryUsage, timeStampToClocks, isExperimentalFeatureEnabled, ExperimentalFeature, assign, createContextManager, deepClone, makePublicApi, monitor, clocksNow, callMonitored, createHandlingStack, checkUser, sanitizeUser, sanitize, createIdentityEncoder, createCustomerDataTrackerManager, storeContextManager, displayAlreadyInitializedError, createTrackingConsentState, } from '@datadog/browser-core';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nimport { createPreStartStrategy } from './preStartRum';\nvar RUM_STORAGE_KEY = 'rum';\nexport function makeRumPublicApi(startRumImpl, recorderApi, options) {\n    if (options === void 0) { options = {}; }\n    var customerDataTrackerManager = createCustomerDataTrackerManager(0 /* CustomerDataCompressionStatus.Unknown */);\n    var globalContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */));\n    var userContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */));\n    var trackingConsentState = createTrackingConsentState();\n    function getCommonContext() {\n        return buildCommonContext(globalContextManager, userContextManager, recorderApi);\n    }\n    var strategy = createPreStartStrategy(options, getCommonContext, trackingConsentState, function (configuration, deflateWorker, initialViewOptions) {\n        if (isExperimentalFeatureEnabled(ExperimentalFeature.CUSTOM_VITALS)) {\n            /**\n             * Start a custom duration vital\n             * stored in @vital.custom.<name>\n             *\n             * @param name name of the custom vital\n             * @param options.context custom context attached to the vital\n             * @param options.startTime epoch timestamp of the start of the custom vital (if not set, will use current time)\n             */\n            ;\n            rumPublicApi.startDurationVital = monitor(function (name, options) {\n                strategy.startDurationVital({\n                    name: sanitize(name),\n                    startClocks: (options === null || options === void 0 ? void 0 : options.startTime) ? timeStampToClocks(options.startTime) : clocksNow(),\n                    context: sanitize(options === null || options === void 0 ? void 0 : options.context),\n                });\n                addTelemetryUsage({ feature: 'start-duration-vital' });\n            });\n            rumPublicApi.stopDurationVital = monitor(function (name, options) {\n                strategy.stopDurationVital({\n                    name: sanitize(name),\n                    stopClocks: (options === null || options === void 0 ? void 0 : options.stopTime) ? timeStampToClocks(options.stopTime) : clocksNow(),\n                    context: sanitize(options === null || options === void 0 ? void 0 : options.context),\n                });\n            });\n        }\n        if (configuration.storeContextsAcrossPages) {\n            storeContextManager(configuration, globalContextManager, RUM_STORAGE_KEY, 2 /* CustomerDataType.GlobalContext */);\n            storeContextManager(configuration, userContextManager, RUM_STORAGE_KEY, 1 /* CustomerDataType.User */);\n        }\n        customerDataTrackerManager.setCompressionStatus(deflateWorker ? 1 /* CustomerDataCompressionStatus.Enabled */ : 2 /* CustomerDataCompressionStatus.Disabled */);\n        var startRumResult = startRumImpl(configuration, recorderApi, customerDataTrackerManager, getCommonContext, initialViewOptions, deflateWorker && options.createDeflateEncoder\n            ? function (streamId) { return options.createDeflateEncoder(configuration, deflateWorker, streamId); }\n            : createIdentityEncoder, trackingConsentState);\n        recorderApi.onRumStart(startRumResult.lifeCycle, configuration, startRumResult.session, startRumResult.viewContexts, deflateWorker);\n        strategy = createPostStartStrategy(strategy, startRumResult);\n        return startRumResult;\n    });\n    var startView = monitor(function (options) {\n        var sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        strategy.startView(sanitizedOptions);\n        addTelemetryUsage({ feature: 'start-view' });\n    });\n    var rumPublicApi = makePublicApi({\n        init: monitor(function (initConfiguration) { return strategy.init(initConfiguration, rumPublicApi); }),\n        setTrackingConsent: monitor(function (trackingConsent) {\n            trackingConsentState.update(trackingConsent);\n            addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent });\n        }),\n        setGlobalContext: monitor(function (context) {\n            globalContextManager.setContext(context);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        getGlobalContext: monitor(function () { return globalContextManager.getContext(); }),\n        setGlobalContextProperty: monitor(function (key, value) {\n            globalContextManager.setContextProperty(key, value);\n            addTelemetryUsage({ feature: 'set-global-context' });\n        }),\n        removeGlobalContextProperty: monitor(function (key) { return globalContextManager.removeContextProperty(key); }),\n        clearGlobalContext: monitor(function () { return globalContextManager.clearContext(); }),\n        getInternalContext: monitor(function (startTime) { return strategy.getInternalContext(startTime); }),\n        getInitConfiguration: monitor(function () { return deepClone(strategy.initConfiguration); }),\n        addAction: function (name, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                strategy.addAction({\n                    name: sanitize(name),\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                    type: \"custom\" /* ActionType.CUSTOM */,\n                    handlingStack: handlingStack,\n                });\n                addTelemetryUsage({ feature: 'add-action' });\n            });\n        },\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                strategy.addError({\n                    error: error, // Do not sanitize error here, it is needed unserialized by computeRawError()\n                    handlingStack: handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n                addTelemetryUsage({ feature: 'add-error' });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            // TODO: next major decide to drop relative time support or update its behaviour\n            strategy.addTiming(sanitize(name), time);\n        }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        getUser: monitor(function () { return userContextManager.getContext(); }),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n            addTelemetryUsage({ feature: 'set-user' });\n        }),\n        removeUserProperty: monitor(function (key) { return userContextManager.removeContextProperty(key); }),\n        clearUser: monitor(function () { return userContextManager.clearContext(); }),\n        startView: startView,\n        stopSession: monitor(function () {\n            strategy.stopSession();\n            addTelemetryUsage({ feature: 'stop-session' });\n        }),\n        addFeatureFlagEvaluation: monitor(function (key, value) {\n            strategy.addFeatureFlagEvaluation(sanitize(key), sanitize(value));\n            addTelemetryUsage({ feature: 'add-feature-flag-evaluation' });\n        }),\n        getSessionReplayLink: monitor(function () { return recorderApi.getSessionReplayLink(); }),\n        startSessionReplayRecording: monitor(function (options) {\n            recorderApi.start(options);\n            addTelemetryUsage({ feature: 'start-session-replay-recording', force: options === null || options === void 0 ? void 0 : options.force });\n        }),\n        stopSessionReplayRecording: monitor(function () { return recorderApi.stop(); }),\n    });\n    return rumPublicApi;\n}\nfunction createPostStartStrategy(preStartStrategy, startRumResult) {\n    return assign({\n        init: function (initConfiguration) {\n            displayAlreadyInitializedError('DD_RUM', initConfiguration);\n        },\n        initConfiguration: preStartStrategy.initConfiguration,\n    }, startRumResult);\n}\n//# sourceMappingURL=rumPublicApi.js.map","export function buildCommonContext(globalContextManager, userContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.js.map","import { sendToExtension, createPageExitObservable, startTelemetry, canUseEventBridge, getEventBridge, addTelemetryDebug, drainPreStartTelemetry, } 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/action/actionCollection';\nimport { startErrorCollection } from '../domain/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/resource/resourceCollection';\nimport { startViewCollection } from '../domain/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { startDisplayContext } from '../domain/contexts/displayContext';\nimport { startVitalCollection } from '../domain/vital/vitalCollection';\nimport { startCiVisibilityContext } from '../domain/contexts/ciVisibilityContext';\nexport function startRum(configuration, recorderApi, customerDataTrackerManager, getCommonContext, initialViewOptions, createEncoder, \n// `startRum` and its subcomponents assume tracking consent is granted initially and starts\n// collecting logs unconditionally. As such, `startRum` should be called with a\n// `trackingConsentState` set to \"granted\".\ntrackingConsentState) {\n    var cleanupTasks = [];\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(13 /* 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(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle, customerDataTrackerManager.getOrCreateTracker(0 /* CustomerDataType.FeatureFlag */));\n    var pageExitObservable = createPageExitObservable(configuration);\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) {\n        lifeCycle.notify(11 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    cleanupTasks.push(function () { return pageExitSubscription.unsubscribe(); });\n    var session = !canUseEventBridge()\n        ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n        : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        var batch_1 = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable, createEncoder);\n        cleanupTasks.push(function () { return batch_1.stop(); });\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batch_1.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(configuration, location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, domMutationObservable, getCommonContext, reportError), viewContexts = _a.viewContexts, pageStateHistory = _a.pageStateHistory, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction, stopRumEventCollection = _a.stop;\n    cleanupTasks.push(stopRumEventCollection);\n    drainPreStartTelemetry();\n    startLongTaskCollection(lifeCycle, configuration);\n    startResourceCollection(lifeCycle, configuration, pageStateHistory);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView, stopViewCollection = _b.stop;\n    cleanupTasks.push(stopViewCollection);\n    var addError = startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    var stopPerformanceCollection = startPerformanceCollection(lifeCycle, configuration).stop;\n    cleanupTasks.push(stopPerformanceCollection);\n    var vitalCollection = startVitalCollection(lifeCycle, pageStateHistory);\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        startDurationVital: vitalCollection.startDurationVital,\n        stopDurationVital: vitalCollection.stopDurationVital,\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\nfunction startRumTelemetry(configuration) {\n    var telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, domMutationObservable, getCommonContext, reportError) {\n    var viewContexts = startViewContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var pageStateHistory = startPageStateHistory(configuration);\n    var _a = startActionCollection(lifeCycle, domMutationObservable, configuration, pageStateHistory), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    var displayContext = startDisplayContext(configuration);\n    var ciVisibilityContext = startCiVisibilityContext(configuration);\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, displayContext, ciVisibilityContext, getCommonContext, reportError);\n    return {\n        viewContexts: viewContexts,\n        pageStateHistory: pageStateHistory,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            ciVisibilityContext.stop();\n            displayContext.stop();\n            pageStateHistory.stop();\n            urlContexts.stop();\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(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { combine, isTelemetryReplicationAllowed, startBatchWithReplica, } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable, sessionExpireObservable, createEncoder) {\n    var replica = configuration.replica;\n    var batch = startBatchWithReplica(configuration, {\n        endpoint: configuration.rumEndpointBuilder,\n        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),\n    }, replica && {\n        endpoint: replica.rumEndpointBuilder,\n        transformMessage: function (message) { return combine(message, { application: { id: replica.applicationId } }); },\n        encoder: createEncoder(3 /* DeflateEncoderStreamId.RUM_REPLICA */),\n    }, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        if (serverRumEvent.type === \"view\" /* RumEventType.VIEW */) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    telemetryEventObservable.subscribe(function (event) { return batch.add(event, isTelemetryReplicationAllowed(configuration)); });\n    return batch;\n}\n//# sourceMappingURL=startRumBatch.js.map","import { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nexport function startDisplayContext(configuration) {\n    var viewport = getViewportDimension();\n    var unsubscribeViewport = initViewportObservable(configuration).subscribe(function (viewportDimension) {\n        viewport = viewportDimension;\n    }).unsubscribe;\n    return {\n        get: function () { return ({ viewport: viewport }); },\n        stop: unsubscribeViewport,\n    };\n}\n//# sourceMappingURL=displayContext.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceCollection';\nexport function startLongTaskCollection(lifeCycle, configuration) {\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 !== RumPerformanceEntryType.LONG_TASK) {\n                break;\n            }\n            if (!configuration.trackLongTasks) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry },\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"],"names":["isMatchOption","item","itemType","RegExp","matchList","list","value","useStartsWith","some","test","e","display","error","clearTracingIfNeeded","context","status","isAborted","traceId","undefined","spanId","traceSampled","injectHeadersIfTracingAllowed","configuration","sessionManager","inject","getCrypto","findTrackedSession","propagatorTypes","tracingHeaders","tracingOption","allowedTracingUrls","match","url","traceSampleRate","traceContextInjection","ALL","TraceIdentifier","forEach","propagatorType","toDecimalString","traceparent","concat","toPaddedHexadecimalString","b3","window","crypto","msCrypto","this","buffer","Uint8Array","getRandomValues","prototype","toString","radix","high","readInt32","low","str","mod","Math","floor","Array","length","join","offset","DEFAULT_PROPAGATOR_TYPES","validateAndBuildRumConfiguration","initConfiguration","_a","_b","applicationId","sessionReplaySampleRate","excludedActivityUrls","isArray","service","tracingOptions_1","option","expectedItem","push","warn","validateAndBuildTracingOptions","baseConfiguration","version","actionNameAttribute","startSessionReplayRecordingManually","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackLongTasks","subdomain","defaultPrivacyLevel","MASK","enablePrivacyForActionName","customerDataTelemetrySampleRate","plugins","PLUGINS","getSelectedTracingPropagators","usedTracingPropagators","Set","add","REMOTE_CONFIGURATION_URL","fetchAndApplyRemoteConfiguration","callback","xhr","XMLHttpRequest","addEventListener","JSON","parse","responseText","displayRemoteConfigurationFetchingError","open","encodeURIComponent","remoteConfigurationId","send","fetchRemoteConfiguration","remoteInitConfiguration","applyRemoteConfiguration","createPreStartStrategy","getCommonContext","trackingConsentState","doStartRum","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","ignoreInitIfSyntheticsWillInjectRum","startDeflateWorker","bufferApiCalls","trackingConsentStateSubscription","observable","subscribe","tryStartRum","isGranted","initialViewOptions","unsubscribe","remove","options","startRumResult","drain","doInit","eventBridgeAvailable","clientToken","sessionSampleRate","getPrivacyLevel","overrideInitConfigurationForBridge","baseSerializedConfiguration","session_replay_sample_rate","start_session_replay_recording_manually","trace_sample_rate","trace_context_injection","action_name_attribute","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","enable_privacy_for_action_name","use_excluded_activity_urls","use_worker_url","compress_intake_requests","track_views_manually","track_user_interactions","track_resources","track_long_task","map","plugin","name","getConfigurationTelemetry","call","serializeRumConfiguration","displayAlreadyInitializedError","sessionStoreStrategyType","tryToInit","trackingConsent","init","publicApi","enableExperimentalFeatures","methodName","parameter","_i","plugins_1","method","callPluginsMethod","REMOTE_CONFIGURATION","getInternalContext","stopSession","addTiming","time","startView","startClocks","addAction","action","commonContext","addError","providedError","addFeatureFlagEvaluation","key","startDurationVital","vitalStart","stopDurationVital","getMutationObserverConstructor","constructor","browserWindow","Zone","getZoneJsOriginalValue","MutationObserver","patchedInstance","originalInstance","runOnReadyState","expectedReadyState","document","readyState","eventName","LOAD","DOM_CONTENT_LOADED","once","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","path","exec","areInOrder","numbers","arguments","i","computePerformanceResourceDetails","entry","isValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","responseEnd","first_byte","connect","ssl","dns","redirect","TOLERANT_RESOURCE_TIMINGS","areCommonTimingsInOrder","areRedirectionTimingsInOrder","hasRedirection","origin","start","end","duration","computeSize","encodedBodySize","decodedBodySize","size","encoded_body_size","decoded_body_size","transfer_size","transferSize","isAllowedRequestUrl","isIntakeUrl","DATA_URL_REGEX","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","isLongDataUrl","substring","sanitizeDataUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","Boolean","shadowRoot","isNodeShadowRoot","host","DOCUMENT_FRAGMENT_NODE","forEachChildNodes","child","firstChild","nextSibling","getParentNode","parentNode","RumPerformanceEntryType","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","data","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","body","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","Number","COMMENT_NODE","isCommentNode","supportPerformanceObject","performance","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","includes","startPerformanceCollection","lifeCycle","cleanupTasks","timing","forcedAttributes","RESOURCE","toJSON","NAVIGATION","getEntriesByType","navigationEntry","relativePerformanceTiming","computeRelativePerformanceTiming","renderBlockingStatus","location","href","retrieveInitialDocumentResourceTiming","handleRumPerformanceEntries","performanceEntries_1","getEntries","handlePerformanceEntryList_1","monitor","entries","mainEntries","LONG_TASK","PAINT","experimentalEntries","LARGEST_CONTENTFUL_PAINT","FIRST_INPUT","LAYOUT_SHIFT","EVENT","type","observer","observe","buffered","durationThreshold","disconnect","apply","mainObserver_1","entryTypes","removePerformanceListener","clearResourceTimings","stop","sendFakeTiming","retrieveNavigationTiming","stopFirstInputTiming","startTimeStamp","timingSent","removeEventListeners","CLICK","MOUSE_DOWN","KEY_DOWN","TOUCH_START","POINTER_DOWN","evt","cancelable","processingStart","processingEnd","timeStamp","sendTimingIfPointerIsNotCancelled","sendTiming","passive","capture","POINTER_UP","POINTER_CANCEL","event","delay","retrieveFirstInputTiming","task","result","numberKey","timingElement","rumAllowedPerformanceEntries","filter","loadEventEnd","isIncompleteNavigation","isForbiddenResource","notify","limitModification","object","modifiableFieldPaths","modifier","clone","fieldPath","fieldType","newValue","current","split","field","isValidObjectContaining","get","newType","set","sanitize","fields","isValidObject","Object","hasOwnProperty","modifiableFieldPathsByEvent","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","ROOT_MODIFIABLE_FIELD_PATHS","startRumAssembly","viewContexts","urlContexts","actionContexts","displayContext","ciVisibilityContext","reportError","WRITABLE_RESOURCE_GRAPHQL","eventRateLimiters","createEventRateLimiter","eventRateLimiterThreshold","syntheticsContext","testId","resultId","test_id","result_id","injected","getSyntheticsContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","actionId","findActionId","rumContext","_dd","format_version","drift","session_sample_rate","browser_sdk_version","application","id","date","source","view","referrer","indexOf","synthetics","ci_test","connectivity","serverRumEvent","has_replay","hasReplay","sampled_for_replay","sessionReplay","user","usr","beforeSend","rateLimitReached","isLimitReached","shouldSend","LifeCycle","VIEW_CONTEXT_TIME_OUT_DELAY","nextRequestIndex","startRequestCollection","tracer","traceFetch","input","Request","headers","keys","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","subscription","rawContext","state","requestIndex","getNextRequestIndex","handlingStack","trackXhr","clonedResponse","response","readBytesFromStream","bytesLimit","POSITIVE_INFINITY","collectStreamBody","waitForResponseToComplete","responseType","trackFetch","discardNegativeDuration","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","subscriptions","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","instrumentMethod","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","cssEscape","CSS","escape","replace","ch","asCodePoint","slice","charCodeAt","elementMatches","element","selector","matches","msMatchesSelector","getParentElement","parentElement","WeakSet","initialValues","_this","WeakMap","delete","has","NodePrivacyLevel","IGNORE","HIDDEN","ALLOW","MASK_USER_INPUT","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_PREFIX","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","cache","parentNodePrivacyLevel","nodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","tagName","inputElement","autocomplete","getAttribute","getPrivacySelector","nodeName","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","hasAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","censorText","text","getTextContent","textNode","ignoreWhiteSpace","parentTagName","textContent","trim","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","ACTION_NAME_PLACEHOLDER","getActionNameFromElement","userProgrammaticAttribute","defaultActionName","getActionNameFromElementProgrammatically","getActionNameFromElementForStrategies","priorityStrategies","fallbackStrategies","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","truncate","normalizeWhitespace","supportsLabelPropertyResult","privacy","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","privacyEnabledActionName","labelledByAttribute","refElement","getElementById","MAX_PARENTS_TO_CONSIDER","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","query","index","element_1","textToReplace","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","classes","getClassList","className","getSelectorFromElement","isConnected","documentElement","contains","targetElementSelector","currentElement","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","predicate","childSelector","selectorGetters_1","elementSelector","selectorGetter","currentElementSelector","isSiblingMatching","scopedSelector_1","supportScopeSelector","parent","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeoutId","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","every","isStopped","tryAppend","first","second","target","other","sqrt","pow","clientX","clientY","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","computeFrustration","clicks","rageClick","getUserActivity","scroll","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","CLICK_ACTION_MAX_DURATION","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","currentClickChain","history","reset","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onPointerUp","userActivity","listeners","SELECTION_CHANGE","SCROLL","localUserActivity_1","listener","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","width","round","height","position","x","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","viewEndedSubscription","endClocks","stopSubscription","startClickAction","findAll","rageClick_1","validate","finalizeClicks","activityEndTime","historyEntry","relative","eventCountsSubscription","frustrationTypes","newActivityEndTime","close","frustrationType","domEvents","clickAction","counts","events","processAction","pageStateHistory","autoActionProperties","isAutoAction","loading_time","count","long_task","resource","actionEvent","in_foreground","wasInPageStateAt","startErrorCollection","featureFlagContexts","errorObservable","consoleError","message","stack","fingerprint","CONSOLE","handling","trackConsoleError","trackRuntimeError","cspViolation","intervention","rawError","subtype","REPORT","originalError","originalReport","csp","disposition","trackReportError","handling_stack","causes","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","processError","stackTrace","Error","computeStackTrace","nonErrorPrefix","CUSTOM","doStartErrorCollection","alreadyMatchedEntries","matchRequestTiming","sameNameEntries","getEntriesByName","candidates","endTime","errorMargin","startResourceCollection","rawEvent","matchingTiming","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","correspondingTimingOverrides","computePerformanceEntryMetrics","wasInPageStateDuringPeriod","computeRequestDuration","resourceEvent","status_code","performanceEntry","requestInput","requestInit","processRequest","entries_1","processResourceEntry","computeEntryTracingInfo","statusCode","RESOURCE_TYPES_1","isType","computeResourceKind","entryMetrics","responseStatus","render_blocking_status","FCP_MAXIMUM_DELAY","LCP_MAXIMUM_DELAY","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","trackNavigationTimings","navigationTimings","firstHidden","eventTarget","stopListeners","visibilityState","Infinity","PAGE_HIDE","VISIBILITY_CHANGE","trackFirstHidden","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","biggestLcpSize","unsubscribeLifeCycle","lcpEntry","lcpTargetSelector","targetSelector","trackLargestContentfulPaint","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTargetSelector","trackFirstInput","firstInput","trackCumulativeLayoutShift","viewStart","maxClsTarget","maxClsStartTime","maxClsValue","cumulatedValue","maxValue","update","isMaxValue","MAX_UPDATE_GAP","MAX_WINDOW_DURATION","slidingSessionWindow","hadRecentInput","getTargetFromSource","sources","WeakRef","deref","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","viewportObservable","getInteractionCount","interactionCount","MAX_INTERACTION_ENTRIES","MAX_INP_VALUE","trackInteractionToNextPaint","viewLoadingType","PerformanceEventTiming","getInteractionToNextPaint","setViewEnd","interactionToNextPaintTargetSelector","interactionToNextPaintStartTime","interactionId","min","max","previousInteractionCount","stopped","computeViewInteractionCount","getViewInteractionCount","stopViewInteractionCount","trackViewInteractionCount","viewEnd","longestInteractions","sortAndTrimLongestInteractions","sort","a","b","splice","process","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaint","viewEndTime","newInteraction","getScrollX","scrollX","visual","visualViewport","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","initViewportObservable","updateDimension","getViewportDimension","throttled","RESIZE","createViewportObservable","scale","innerWidth","innerHeight","THROTTLE_SCROLL_DURATION","trackScrollMetrics","scrollValues","throttleDuration","scrollTop","scrollHeight","scrollDepth","scrollingElement","ResizeObserver","throttledNotify_1","leading","trailing","observerTarget_1","resizeObserver_1","eventListener_1","cancel","unobserve","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","now","maxDepth","maxDepthScrollTop","trackCommonViewMetrics","loadingType","commonViewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","trackLoadingTime","newLoadingTime","loadingTime","stopLoadingTimeTracking","stopScrollMetricsTracking","newScrollMetrics","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","getCommonViewMetrics","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","locationChangeSubscription","activeViews","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","customTimings","documentVersion","sessionIsActive","viewCreatedEvent","triggerViewUpdate","cancelScheduleViewUpdate","stopCommonViewMetricsTracking","_c","stopInitialViewMetricsTracking","_d","viewId","trackViewEventCounts","stopEventCountsTracking","keepAliveIntervalId","currentEnd","isActive","relativeTime","sanitized","sanitizeTiming","newView","pageExitEvent","reason","UNLOADING","currentLocation","otherLocation","hash","correspondingId","oldLocation","newLocation","pathname","getPathFromHash","renewViewOnLocationChange","startViewCollection","recorderApi","_e","_f","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","replayStats","getReplayStats","pageStates","viewEvent","document_version","replay_stats","page_states","cumulative_layout_shift","cumulative_layout_shift_time","cumulative_layout_shift_target_selector","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","first_input_target_selector","interaction_to_next_paint","interaction_to_next_paint_time","interaction_to_next_paint_target_selector","is_active","largest_contentful_paint","largest_contentful_paint_target_selector","load_event","loading_type","time_spent","max_depth","max_depth_scroll_top","max_scroll_height","max_scroll_height_time","replay_level","custom_timings","processViewUpdate","RUM_SESSION_KEY","startRumSessionManager","rawTrackingType","trackingType","hasValidRumSession","isTracked","isTypeTracked","computeSessionState","expireObservable","renewObservable","sessionStateUpdateObservable","previousState","newState","forcedReplay","sessionEntity","findSession","isReplayForced","expire","setForcedReplay","updateSessionState","rumSessionType","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","onPostCall","stopInstrumentingReplaceState","removeListener","POP_STATE","trackHistory","onLocationChange","stopHashTracking","onHashChange","HASH_CHANGE","trackHash","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","pageStateEntryHistory","addPageState","getPageState","stopEventListeners","PAGE_SHOW","FOCUS","BLUR","RESUME","FREEZE","persisted","computePageState","nextPageState","closeActive","eventStartTime","pageStateEntries","pageStateServerEntries","limit","pageState","relativeStartTime","hasFocus","startVitalCollection","vitalStartsByName","Map","clear","vitalStop","vital","stopClocks","buildDurationVital","isValid","valueComputedBySdk","custom","computed_value","processVital","createCookieObservable","cookieName","detectCookieChangeStrategy","cookieStore","CHANGE","changeEvent","changed","deleted","listenToCookieStoreChange","watchCookieFallback","WATCH_COOKIE_INTERVAL_DELAY","previousCookieValue","cookie","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","getSessionReplayUrl","errorType","sessionId","parameters","rumConfiguration","site","getSiteDefaultSubdomain","statsPerView","MAX_STATS_HISTORY","getSegmentsCount","getOrCreateReplayStats","segments_count","records_count","segments_total_raw_size","next","isFirst_1","_value","deleteOldestStats","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","quote","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","censoredImageForSize","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","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","from","cssRule","disabled","media","serializeAttribute","attributeValue","image","naturalWidth","naturalHeight","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","rule","isCSSStyleRule","selectorText","isCSSImportRule","styleSheet","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","isSVG","el","SVGElement","attributes","rr_width","rr_height","safeAttrs","doc","formValue","optionElement","selected","stylesheet","styleSheets","find","_cssText","sheet","scrollLeft","checked","mediaElement","rr_mediaState","paused","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","serializeAttributes","hasChildNodes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","serializeDocument","isTouchEvent","changedTouches","getEventTarget","composed","composedPath","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","isVisualViewportFactoredIn","assembleIncrementalSnapshot","timestamp","MOUSE_MOVE_OBSERVER_THRESHOLD","trackMove","moveCb","coordinates","tryToComputeCoordinates","timeOffset","positions","updatePosition","cancelThrottle","MOUSE_MOVE","TOUCH_MOVE","isFinite","isTrusted","eventTypeToMouseInteraction","CONTEXT_MENU","DBL_CLICK","TOUCH_END","trackMouseInteraction","mouseInteractionCb","recordIds","record","getIdForEvent","SCROLL_OBSERVER_THRESHOLD","trackScroll","scrollCb","scrollPositions","trackViewportResize","viewportResizeCb","viewportResizeSubscription","trackMediaInteraction","mediaInteractionCb","PLAY","PAUSE","trackStyleSheet","styleSheetCb","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","adds","removes","instrumentGroupingCSSRuleClass","cls","parentStyleSheet","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","stopper","currentRule","parentRule","index_1","unshift","trackFocus","focusCb","has_focus","trackFrustration","frustrationCb","frustrationSubscription","trackViewEnd","viewEndCb","viewEndSubscription","trackInput","inputCb","stopPropertySetterInstrumentation","lastInputStateMap","HTMLTextAreaElement","HTMLSelectElement","onElementChange","instrumentationStoppers_1","inputState","isChecked","cbWithDedup","lastInputState","MUTATION_PROCESS_MAX_DELAY","MUTATION_PROCESS_MIN_DELAY","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","flush","throttledFlush","addMutations","mutations","opts","requestIdleCallback","cancelIdleCallback","id_1","requestAnimationFrame","cancelAnimationFrame","timeout","trackMutation","mutationCallback","mutationBatch","nodePrivacyLevelCache","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","_loop_1","addedNodes","mutations_1","sortedAddedAndMovedNodes","nodes","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","shadowDomRemovedCallback","initShadowRootsController","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","emit","scrollPositionsByElement","emitAndComputeStats","sendToExtension","stopFullSnapshots","flushMutations","fullSnapshotCallback","takeFullSnapshot","records","initialOffset","startFullSnapshots","initRecordIds","trackers","viewEndRecord","tracker","Segment","encoder","creationReason","encodedBytesCount","metadata","creation_reason","has_full_snapshot","index_in_view","addRecord","prefix","isEmpty","write","stringify","additionalEncodedBytesCount","finish","encoderResult","additionalBytesCount","rawBytesCount","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","flushReason","segment","payload","rawSegmentBytesCount","formData","FormData","Blob","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","bytesCount","buildReplayPayload","output","sendOnExit","expirationTimeoutId","doStartSegmentCollection","computeSegmentContext","isBrowserSupported","URL","createObjectURL","NodeList","getSessionReplayLink","isRecordingStarted","getErrorType","createDeflateEncoder","worker","streamId","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","workerResponse","trailer","nextPendingAction","shift","writeCallback","finishCallback","consumeResult","outputBytesCount","encoding","sendResetIfNeeded","postMessage","isAsync","pendingWriteAction","finishSync","pendingData","estimateEncodedBytesCount","INITIALIZATION_TIME_OUT_DELAY","createDeflateWorker","Worker","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener_1","onError","removeMessageListener_1","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","Event","baseMessage","worker_version","stream_id","startRecordingImpl","onRumStart","isRecording","startStrategy","stopStrategy","getSessionReplayLinkStrategy","cachedDeflateEncoder","force","deflateEncoder","stopRecording","makeRecorderApi","replayRequest","sessionReplayEndpointBuilder","bridge","startRecordBridge","segmentCollection","datadogRum","startRumImpl","customerDataTrackerManager","globalContextManager","getOrCreateTracker","userContextManager","getContext","buildCommonContext","CUSTOM_VITALS","rumPublicApi","feature","stopTime","storeContextsAcrossPages","storeContextManager","setCompressionStatus","preStartStrategy","createPostStartStrategy","sanitizedOptions","m","setTrackingConsent","tracking_consent","setGlobalContext","setContext","getGlobalContext","setGlobalContextProperty","setContextProperty","removeGlobalContextProperty","removeContextProperty","clearGlobalContext","clearContext","getInitConfiguration","setUser","newUser","getUser","setUserProperty","property","sanitizedProperty","removeUserProperty","clearUser","startSessionReplayRecording","stopSessionReplayRecording","makeRumPublicApi","createEncoder","telemetry","bridge_1","startRumTelemetry","setContextProvider","customerDataTracker","resetCustomerData","currentContext","updateCustomerData","startFeatureFlagContexts","pageExitObservable","pageExitSubscription","startRumSessionManagerStub","startRumEventBridge","batch_1","telemetryEventObservable","sessionExpireObservable","replica","batch","startBatchWithReplica","endpoint","rumEndpointBuilder","transformMessage","upsert","startRumBatch","batchFlushObservable","enabled","getBytesCount","messagesCount","startCustomerDataTelemetry","flushObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","viewport","viewportDimension","startDisplayContext","cookieObservable","testExecutionId","Cypress","env","cookieObservableSubscription","test_execution_id","startCiVisibilityContext","startRumEventCollection","stopRumEventCollection","startLongTaskCollection","stopViewCollection","stopPerformanceCollection","vitalCollection","internalContext","application_id","session_id","user_action","startInternalContext","getGlobalObject"],"sourceRoot":""}