{"version":3,"file":"vendors-node_modules_datadog_browser-rum_esm_entries_main_js.b27c59476acb7d59.prod.js","mappings":"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","sources":["webpack://aurora-new-frontend/./node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/configuration.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceUtils.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/viewportObservable.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/displayContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/limitModification.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/ciTestContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/foregroundContexts.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewContexts.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/clickChain.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getActionNameFromElement.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getSelectorFromElement.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/listenActionEvents.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/computeFrustration.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/trackClickActions.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/actionCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/errorCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackConsoleError.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackReportError.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackFirstHidden.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/matchRequestTiming.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackInitialViewTimings.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewMetrics.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewEventCounts.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViews.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/viewCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/urlContexts.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/featureFlagContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/startCustomerDataTelemetry.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/pageStateHistory.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/getSessionReplayUrl.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/constants.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeDocument.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/moveObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/scrollObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/mouseInteractionObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/inputObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/styleSheetObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/viewportResizeObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/mutationObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/observers.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/mediaInteractionObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/focusObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/recordIds.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observers/frustrationObserver.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/deflateWorker.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startDeflateWorker.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/boot/isBrowserSupported.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/domain/getSessionReplayLink.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/longTask/longTaskCollection.js","webpack://aurora-new-frontend/./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, } from '@datadog/browser-core';\nexport function isTracingOption(item) {\n    var expectedItem = item;\n    return (getType(expectedItem) === 'object' &&\n        isMatchOption(expectedItem.match) &&\n        Array.isArray(expectedItem.propagatorTypes));\n}\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course, it might not be the case every time, but it should limit having incomplete traces a\n * bit.\n * */\nexport function clearTracingIfNeeded(context) {\n    if (context.status === 0 && !context.isAborted) {\n        context.traceId = undefined;\n        context.spanId = undefined;\n        context.traceSampled = undefined;\n    }\n}\nexport function startTracer(configuration, sessionManager) {\n    return {\n        clearTracingIfNeeded: clearTracingIfNeeded,\n        traceFetch: function (context) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                var _a;\n                if (context.input instanceof Request && !((_a = context.init) === null || _a === void 0 ? void 0 : _a.headers)) {\n                    context.input = new Request(context.input);\n                    Object.keys(tracingHeaders).forEach(function (key) {\n                        ;\n                        context.input.headers.append(key, tracingHeaders[key]);\n                    });\n                }\n                else {\n                    context.init = shallowClone(context.init);\n                    var headers_1 = [];\n                    if (context.init.headers instanceof Headers) {\n                        context.init.headers.forEach(function (value, key) {\n                            headers_1.push([key, value]);\n                        });\n                    }\n                    else if (Array.isArray(context.init.headers)) {\n                        context.init.headers.forEach(function (header) {\n                            headers_1.push(header);\n                        });\n                    }\n                    else if (context.init.headers) {\n                        Object.keys(context.init.headers).forEach(function (key) {\n                            headers_1.push([key, context.init.headers[key]]);\n                        });\n                    }\n                    context.init.headers = headers_1.concat(objectEntries(tracingHeaders));\n                }\n            });\n        },\n        traceXhr: function (context, xhr) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                Object.keys(tracingHeaders).forEach(function (name) {\n                    xhr.setRequestHeader(name, tracingHeaders[name]);\n                });\n            });\n        },\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, inject) {\n    if (!isTracingSupported() || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    var tracingOption = find(configuration.allowedTracingUrls, function (tracingOption) {\n        return matchList([tracingOption.match], context.url, true);\n    });\n    if (!tracingOption) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    context.traceSampled = !isNumber(configuration.traceSampleRate) || performDraw(configuration.traceSampleRate);\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes));\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\n}\n/**\n * When trace is not sampled, set priority to '0' instead of not adding the tracing headers\n * to prepare the implementation for sampling delegation.\n */\nfunction makeTracingHeaders(traceId, spanId, traceSampled, propagatorTypes) {\n    var tracingHeaders = {};\n    propagatorTypes.forEach(function (propagatorType) {\n        switch (propagatorType) {\n            case 'datadog': {\n                assign(tracingHeaders, {\n                    'x-datadog-origin': 'rum',\n                    'x-datadog-parent-id': spanId.toDecimalString(),\n                    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n                    'x-datadog-trace-id': traceId.toDecimalString(),\n                });\n                break;\n            }\n            // https://www.w3.org/TR/trace-context/\n            case 'tracecontext': {\n                assign(tracingHeaders, {\n                    traceparent: \"00-0000000000000000\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-0\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            // https://github.com/openzipkin/b3-propagation\n            case 'b3': {\n                assign(tracingHeaders, {\n                    b3: \"\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            case 'b3multi': {\n                assign(tracingHeaders, {\n                    'X-B3-TraceId': traceId.toPaddedHexadecimalString(),\n                    'X-B3-SpanId': spanId.toPaddedHexadecimalString(),\n                    'X-B3-Sampled': traceSampled ? '1' : '0',\n                });\n                break;\n            }\n        }\n    });\n    return tracingHeaders;\n}\n/* eslint-disable no-bitwise */\nvar TraceIdentifier = /** @class */ (function () {\n    function TraceIdentifier() {\n        this.buffer = new Uint8Array(8);\n        getCrypto().getRandomValues(this.buffer);\n        this.buffer[0] = this.buffer[0] & 0x7f; // force 63-bit\n    }\n    TraceIdentifier.prototype.toString = function (radix) {\n        var high = this.readInt32(0);\n        var low = this.readInt32(4);\n        var str = '';\n        do {\n            var mod = (high % radix) * 4294967296 + low;\n            high = Math.floor(high / radix);\n            low = Math.floor(mod / radix);\n            str = (mod % radix).toString(radix) + str;\n        } while (high || low);\n        return str;\n    };\n    /**\n     * Format used everywhere except the trace intake\n     */\n    TraceIdentifier.prototype.toDecimalString = function () {\n        return this.toString(10);\n    };\n    /**\n     * Format used by OTel headers\n     */\n    TraceIdentifier.prototype.toPaddedHexadecimalString = function () {\n        var traceId = this.toString(16);\n        return Array(17 - traceId.length).join('0') + traceId;\n    };\n    TraceIdentifier.prototype.readInt32 = function (offset) {\n        return (this.buffer[offset] * 16777216 +\n            (this.buffer[offset + 1] << 16) +\n            (this.buffer[offset + 2] << 8) +\n            this.buffer[offset + 3]);\n    };\n    return TraceIdentifier;\n}());\nexport { TraceIdentifier };\n/* eslint-enable no-bitwise */\n//# sourceMappingURL=tracer.js.map","import { getType, arrayFrom, getOrigin, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nimport { isTracingOption } from './tracing/tracer';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e, _f;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.sessionReplaySampleRate !== undefined &&\n        !isPercentage(initConfiguration.sessionReplaySampleRate)) {\n        display.error('Session Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // TODO remove fallback in next major\n    var premiumSampleRate = (_a = initConfiguration.premiumSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.replaySampleRate;\n    if (premiumSampleRate !== undefined && initConfiguration.sessionReplaySampleRate !== undefined) {\n        display.warn('Ignoring Premium Sample Rate because Session Replay Sample Rate is set');\n        premiumSampleRate = undefined;\n    }\n    if (premiumSampleRate !== undefined && !isPercentage(premiumSampleRate)) {\n        display.error('Premium Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    var traceSampleRate = (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.tracingSampleRate;\n    if (traceSampleRate !== undefined && !isPercentage(traceSampleRate)) {\n        display.error('Trace Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {\n        display.error('Excluded Activity Urls should be an array');\n        return;\n    }\n    var allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);\n    if (!allowedTracingUrls) {\n        return;\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    var trackUserInteractions = !!((_c = initConfiguration.trackUserInteractions) !== null && _c !== void 0 ? _c : initConfiguration.trackInteractions);\n    var trackFrustrations = !!initConfiguration.trackFrustrations;\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: (_e = (_d = initConfiguration.sessionReplaySampleRate) !== null && _d !== void 0 ? _d : premiumSampleRate) !== null && _e !== void 0 ? _e : 100,\n        oldPlansBehavior: initConfiguration.sessionReplaySampleRate === undefined,\n        traceSampleRate: traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_f = initConfiguration.excludedActivityUrls) !== null && _f !== void 0 ? _f : [],\n        trackUserInteractions: trackUserInteractions || trackFrustrations,\n        trackFrustrations: trackFrustrations,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: initConfiguration.trackResources,\n        trackLongTasks: initConfiguration.trackLongTasks,\n        subdomain: initConfiguration.subdomain,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK_USER_INPUT,\n        customerDataTelemetrySampleRate: 1,\n    }, baseConfiguration);\n}\n/**\n * Handles allowedTracingUrls and processes legacy allowedTracingOrigins\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    // Advise about parameters precedence.\n    if (initConfiguration.allowedTracingUrls !== undefined && initConfiguration.allowedTracingOrigins !== undefined) {\n        display.warn('Both allowedTracingUrls and allowedTracingOrigins (deprecated) have been defined. The parameter allowedTracingUrls will override allowedTracingOrigins.');\n    }\n    // Handle allowedTracingUrls first\n    if (initConfiguration.allowedTracingUrls !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n            display.error('Allowed Tracing URLs should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service needs to be configured when tracing is enabled');\n            return;\n        }\n        // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n        var tracingOptions_1 = [];\n        initConfiguration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                tracingOptions_1.push({ match: option, propagatorTypes: ['datadog'] });\n            }\n            else if (isTracingOption(option)) {\n                tracingOptions_1.push(option);\n            }\n            else {\n                display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);\n            }\n        });\n        return tracingOptions_1;\n    }\n    // Handle conversion of allowedTracingOrigins to allowedTracingUrls\n    if (initConfiguration.allowedTracingOrigins !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingOrigins)) {\n            display.error('Allowed Tracing Origins should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingOrigins.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service needs to be configured when tracing is enabled');\n            return;\n        }\n        var tracingOptions_2 = [];\n        initConfiguration.allowedTracingOrigins.forEach(function (legacyMatchOption) {\n            var tracingOption = convertLegacyMatchOptionToTracingOption(legacyMatchOption);\n            if (tracingOption) {\n                tracingOptions_2.push(tracingOption);\n            }\n        });\n        return tracingOptions_2;\n    }\n    return [];\n}\n/**\n * Converts parameters from the deprecated allowedTracingOrigins\n * to allowedTracingUrls. Handles the change from origin to full URLs.\n */\nfunction convertLegacyMatchOptionToTracingOption(item) {\n    var match;\n    if (typeof item === 'string') {\n        match = item;\n    }\n    else if (item instanceof RegExp) {\n        match = function (url) { return item.test(getOrigin(url)); };\n    }\n    else if (typeof item === 'function') {\n        match = function (url) { return item(getOrigin(url)); };\n    }\n    if (match === undefined) {\n        display.warn('Allowed Tracing Origins parameters should be a string, RegExp or function. Ignoring parameter', item);\n        return undefined;\n    }\n    return { match: match, propagatorTypes: ['datadog'] };\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls,\n * and assumes 'datadog' has been selected when using allowedTracingOrigins\n */\nfunction getSelectedTracingPropagators(configuration) {\n    var usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                usedTracingPropagators.add('datadog');\n            }\n            else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n                option.propagatorTypes.forEach(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n        });\n    }\n    if (Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0) {\n        usedTracingPropagators.add('datadog');\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a, _b;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\n        premium_sample_rate: configuration.premiumSampleRate,\n        replay_sample_rate: configuration.replaySampleRate,\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        trace_sample_rate: (_a = configuration.traceSampleRate) !== null && _a !== void 0 ? _a : configuration.tracingSampleRate,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_origins: Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0,\n        use_allowed_tracing_urls: Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\n        selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n        default_privacy_level: configuration.defaultPrivacyLevel,\n        use_excluded_activity_urls: Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\n        track_frustrations: configuration.trackFrustrations,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: (_b = configuration.trackUserInteractions) !== null && _b !== void 0 ? _b : configuration.trackInteractions,\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","export function buildCommonContext(globalContextManager, userContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    var MutationObserver = getMutationObserverConstructor();\n    var observable = new Observable(function () {\n        if (!MutationObserver) {\n            return;\n        }\n        var observer = new MutationObserver(monitor(function () { return observable.notify(); }));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return function () { return observer.disconnect(); };\n    });\n    return observable;\n}\nexport function getMutationObserverConstructor() {\n    var constructor;\n    var browserWindow = window;\n    // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n    // global MutationObserver constructor with a patched version to support the context propagation.\n    // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n    // component: on some occasions, the callback is being called in an infinite loop, causing the\n    // page to freeze (even if the callback is completely empty).\n    //\n    // To work around this issue, we try to get the original MutationObserver constructor stored by\n    // Zone.js.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n        //\n        // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n        constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver');\n        if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n            // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n            // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n            // instance in its properties[4]. Let's get the original MutationObserver constructor from\n            // there.\n            //\n            // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n            var patchedInstance = new browserWindow.MutationObserver(noop);\n            var originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance');\n            constructor = originalInstance && originalInstance.constructor;\n        }\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { addEventListener } from './addEventListener';\nexport function runOnReadyState(expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n        addEventListener(window, eventName, callback, { once: true });\n    }\n}\n//# sourceMappingURL=runOnReadyState.js.map","import { assign, addTelemetryDebug, elapsed, getPathName, includes, isValidUrl, toServerDuration, } from '@datadog/browser-core';\nexport var FAKE_INITIAL_DOCUMENT = 'initial_document';\nvar RESOURCE_TYPES = [\n    [\"document\" /* ResourceType.DOCUMENT */, function (initiatorType) { return FAKE_INITIAL_DOCUMENT === initiatorType; }],\n    [\"xhr\" /* ResourceType.XHR */, function (initiatorType) { return 'xmlhttprequest' === initiatorType; }],\n    [\"fetch\" /* ResourceType.FETCH */, function (initiatorType) { return 'fetch' === initiatorType; }],\n    [\"beacon\" /* ResourceType.BEACON */, function (initiatorType) { return 'beacon' === initiatorType; }],\n    [\"css\" /* ResourceType.CSS */, function (_, path) { return /\\.css$/i.test(path); }],\n    [\"js\" /* ResourceType.JS */, function (_, path) { return /\\.js$/i.test(path); }],\n    [\n        \"image\" /* ResourceType.IMAGE */,\n        function (initiatorType, path) {\n            return includes(['image', 'img', 'icon'], initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null;\n        },\n    ],\n    [\"font\" /* ResourceType.FONT */, function (_, path) { return /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null; }],\n    [\n        \"media\" /* ResourceType.MEDIA */,\n        function (initiatorType, path) {\n            return includes(['audio', 'video'], initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null;\n        },\n    ],\n];\nexport function computeResourceKind(timing) {\n    var url = timing.name;\n    if (!isValidUrl(url)) {\n        addTelemetryDebug(\"Failed to construct URL for \\\"\".concat(timing.name, \"\\\"\"));\n        return \"other\" /* ResourceType.OTHER */;\n    }\n    var path = getPathName(url);\n    for (var _i = 0, RESOURCE_TYPES_1 = RESOURCE_TYPES; _i < RESOURCE_TYPES_1.length; _i++) {\n        var _a = RESOURCE_TYPES_1[_i], type = _a[0], isType = _a[1];\n        if (isType(timing.initiatorType, path)) {\n            return type;\n        }\n    }\n    return \"other\" /* ResourceType.OTHER */;\n}\nfunction areInOrder() {\n    var numbers = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        numbers[_i] = arguments[_i];\n    }\n    for (var i = 1; i < numbers.length; i += 1) {\n        if (numbers[i - 1] > numbers[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function isRequestKind(timing) {\n    return timing.initiatorType === 'xmlhttprequest' || timing.initiatorType === 'fetch';\n}\nexport function computePerformanceResourceDuration(entry) {\n    var duration = entry.duration, startTime = entry.startTime, responseEnd = entry.responseEnd;\n    // Safari duration is always 0 on timings blocked by cross origin policies.\n    if (duration === 0 && startTime < responseEnd) {\n        return toServerDuration(elapsed(startTime, responseEnd));\n    }\n    return toServerDuration(duration);\n}\nexport function computePerformanceResourceDetails(entry) {\n    var validEntry = toValidEntry(entry);\n    if (!validEntry) {\n        return undefined;\n    }\n    var startTime = validEntry.startTime, fetchStart = validEntry.fetchStart, redirectStart = validEntry.redirectStart, redirectEnd = validEntry.redirectEnd, domainLookupStart = validEntry.domainLookupStart, domainLookupEnd = validEntry.domainLookupEnd, connectStart = validEntry.connectStart, secureConnectionStart = validEntry.secureConnectionStart, connectEnd = validEntry.connectEnd, requestStart = validEntry.requestStart, responseStart = validEntry.responseStart, responseEnd = validEntry.responseEnd;\n    var details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a connection occurred\n    if (connectEnd !== fetchStart) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (areInOrder(connectStart, secureConnectionStart, connectEnd)) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (domainLookupEnd !== fetchStart) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    if (hasRedirection(entry)) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\nexport function toValidEntry(entry) {\n    // Ensure timings are in the right order. On top of filtering out potential invalid\n    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n    // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n    // it.\n    if (!areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd)) {\n        return undefined;\n    }\n    if (!hasRedirection(entry)) {\n        return entry;\n    }\n    var redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd;\n    // Firefox doesn't provide redirect timings on cross origin requests.\n    // Provide a default for those.\n    if (redirectStart < entry.startTime) {\n        redirectStart = entry.startTime;\n    }\n    if (redirectEnd < entry.startTime) {\n        redirectEnd = entry.fetchStart;\n    }\n    // Make sure redirect timings are in order\n    if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {\n        return undefined;\n    }\n    return assign({}, entry, {\n        redirectEnd: redirectEnd,\n        redirectStart: redirectStart,\n    });\n}\nfunction hasRedirection(entry) {\n    // The only time fetchStart is different than startTime is if a redirection occurred.\n    return entry.fetchStart !== entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    return {\n        duration: toServerDuration(elapsed(start, end)),\n        start: toServerDuration(elapsed(origin, start)),\n    };\n}\nexport function computeSize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        return entry.decodedBodySize;\n    }\n    return undefined;\n}\nexport function isAllowedRequestUrl(configuration, url) {\n    return url && !configuration.isIntakeUrl(url);\n}\n//# sourceMappingURL=resourceUtils.js.map","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    var shadowRoot = node;\n    return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);\n}\nexport function getChildNodes(node) {\n    return isNodeShadowHost(node) ? node.shadowRoot.childNodes : node.childNodes;\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\nexport var INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    var data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);\n    if (!data || data.traceTime <= dateNow() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n        return undefined;\n    }\n    return data.traceId;\n}\nexport function getDocumentTraceDataFromMeta(document) {\n    var traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    var traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    var comment = findTraceComment(document);\n    if (!comment) {\n        return undefined;\n    }\n    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));\n}\nexport function createDocumentTraceData(traceId, rawTraceTime) {\n    var traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId: traceId,\n        traceTime: traceTime,\n    };\n}\nexport function findTraceComment(document) {\n    // 1. Try to find the comment as a direct child of the document\n    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n    // value is not an array or string (here, a NodeList).\n    for (var i = 0; i < document.childNodes.length; i += 1) {\n        var comment = getTraceCommentFromNode(document.childNodes[i]);\n        if (comment) {\n            return comment;\n        }\n    }\n    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n    // reverse order, stopping if we come across a non-text node.\n    if (document.body) {\n        for (var i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            var node = document.body.childNodes[i];\n            var comment = getTraceCommentFromNode(node);\n            if (comment) {\n                return comment;\n            }\n            if (!isTextNode(node)) {\n                break;\n            }\n        }\n    }\n}\nfunction getTraceCommentFromNode(node) {\n    if (node && isCommentNode(node)) {\n        var match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { dateNow, assign, addEventListeners, getRelativeTime, isNumber, monitor, setTimeout, relativeNow, runOnReadyState, addEventListener, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/rumEventsCollection/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\nfunction supportPerformanceObject() {\n    return window.performance !== undefined && 'getEntries' in performance;\n}\nexport function supportPerformanceTimingEvent(entryType) {\n    return (window.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes !== undefined &&\n        PerformanceObserver.supportedEntryTypes.includes(entryType));\n}\nexport function startPerformanceCollection(lifeCycle, configuration) {\n    retrieveInitialDocumentResourceTiming(function (timing) {\n        handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n    });\n    if (supportPerformanceObject()) {\n        var performanceEntries_1 = performance.getEntries();\n        // Because the performance entry list can be quite large\n        // delay the computation to prevent the SDK from blocking the main thread on init\n        setTimeout(function () { return handleRumPerformanceEntries(lifeCycle, configuration, performanceEntries_1); });\n    }\n    if (window.PerformanceObserver) {\n        var handlePerformanceEntryList_1 = monitor(function (entries) {\n            return handleRumPerformanceEntries(lifeCycle, configuration, entries.getEntries());\n        });\n        var mainEntries = ['resource', 'navigation', 'longtask', 'paint'];\n        var experimentalEntries = ['largest-contentful-paint', 'first-input', 'layout-shift'];\n        try {\n            // Experimental entries are not retrieved by performance.getEntries()\n            // use a single PerformanceObserver with buffered flag by type\n            // to get values that could happen before SDK init\n            experimentalEntries.forEach(function (type) {\n                var observer = new PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({ type: type, buffered: true });\n            });\n        }\n        catch (e) {\n            // Some old browser versions (ex: chrome 67) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to PerformanceObserver with entryTypes\n            mainEntries.push.apply(mainEntries, experimentalEntries);\n        }\n        var mainObserver = new PerformanceObserver(handlePerformanceEntryList_1);\n        mainObserver.observe({ entryTypes: mainEntries });\n        if (supportPerformanceObject() && 'addEventListener' in performance) {\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n            addEventListener(performance, 'resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            });\n        }\n    }\n    if (!supportPerformanceTimingEvent('navigation')) {\n        retrieveNavigationTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent('first-input')) {\n        retrieveFirstInputTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n}\nexport function retrieveInitialDocumentResourceTiming(callback) {\n    runOnReadyState('interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: 'resource',\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n        };\n        if (supportPerformanceTimingEvent('navigation') && performance.getEntriesByType('navigation').length > 0) {\n            var navigationEntry = performance.getEntriesByType('navigation')[0];\n            timing = assign(navigationEntry.toJSON(), forcedAttributes);\n        }\n        else {\n            var relativePerformanceTiming = computeRelativePerformanceTiming();\n            timing = assign(relativePerformanceTiming, {\n                decodedBodySize: 0,\n                duration: relativePerformanceTiming.responseEnd,\n                name: window.location.href,\n                startTime: 0,\n            }, forcedAttributes);\n        }\n        callback(timing);\n    });\n}\nfunction retrieveNavigationTiming(callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: 'navigation',\n        }));\n    }\n    runOnReadyState('complete', function () {\n        // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        setTimeout(sendFakeTiming);\n    });\n}\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nfunction retrieveFirstInputTiming(callback) {\n    var startTimeStamp = dateNow();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(window, [\"click\" /* DOM_EVENT.CLICK */, \"mousedown\" /* DOM_EVENT.MOUSE_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */], function (evt) {\n        // Only count cancelable events, which should trigger behavior important to the user.\n        if (!evt.cancelable) {\n            return;\n        }\n        // This timing will be used to compute the \"first Input delay\", which is the delta between\n        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n        // (e.g. performance.now()).\n        var timing = {\n            entryType: 'first-input',\n            processingStart: relativeNow(),\n            startTime: evt.timeStamp,\n        };\n        if (evt.type === \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true }).stop;\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(timing) {\n        addEventListeners(window, [\"pointerup\" /* DOM_EVENT.POINTER_UP */, \"pointercancel\" /* DOM_EVENT.POINTER_CANCEL */], function (event) {\n            if (event.type === \"pointerup\" /* DOM_EVENT.POINTER_UP */) {\n                sendTiming(timing);\n            }\n        }, { once: true });\n    }\n    function sendTiming(timing) {\n        if (!timingSent) {\n            timingSent = true;\n            removeEventListeners();\n            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n            // the time between now and when the page was loaded.\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n            var delay = timing.processingStart - timing.startTime;\n            if (delay >= 0 && delay < dateNow() - startTimeStamp) {\n                callback(timing);\n            }\n        }\n    }\n}\nfunction computeRelativePerformanceTiming() {\n    var result = {};\n    var timing = performance.timing;\n    for (var key in timing) {\n        if (isNumber(timing[key])) {\n            var numberKey = key;\n            var timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\nfunction handleRumPerformanceEntries(lifeCycle, configuration, entries) {\n    var rumPerformanceEntries = entries.filter(function (entry) {\n        return entry.entryType === 'resource' ||\n            entry.entryType === 'navigation' ||\n            entry.entryType === 'paint' ||\n            entry.entryType === 'longtask' ||\n            entry.entryType === 'largest-contentful-paint' ||\n            entry.entryType === 'first-input' ||\n            entry.entryType === 'layout-shift';\n    });\n    var rumAllowedPerformanceEntries = rumPerformanceEntries.filter(function (entry) { return !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry); });\n    if (rumAllowedPerformanceEntries.length) {\n        lifeCycle.notify(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, rumAllowedPerformanceEntries);\n    }\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.entryType === 'navigation' && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === 'resource' && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.js.map","import { Observable, throttle, addEventListener } from '@datadog/browser-core';\nvar viewportObservable;\nexport function initViewportObservable() {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable();\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable() {\n    var observable = new Observable(function () {\n        var updateDimension = throttle(function () {\n            observable.notify(getViewportDimension());\n        }, 200).throttled;\n        return addEventListener(window, \"resize\" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true }).stop;\n    });\n    return observable;\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nvar viewport;\nvar stopListeners;\nexport function getDisplayContext() {\n    if (!viewport) {\n        viewport = getViewportDimension();\n        stopListeners = initViewportObservable().subscribe(function (viewportDimension) {\n            viewport = viewportDimension;\n        }).unsubscribe;\n    }\n    return {\n        viewport: viewport,\n    };\n}\nexport function resetDisplayContext() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    viewport = undefined;\n}\n//# sourceMappingURL=displayContext.js.map","import { 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, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { getCiTestContext } from './contexts/ciTestContext';\nimport { getDisplayContext } from './contexts/displayContext';\nimport { limitModification } from './limitModification';\nvar VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nvar USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nvar modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, buildCommonContext, reportError) {\n    var _a, _b;\n    modifiableFieldPathsByEvent = (_a = {},\n        _a[\"view\" /* RumEventType.VIEW */] = VIEW_MODIFIABLE_FIELD_PATHS,\n        _a[\"error\" /* RumEventType.ERROR */] = assign({\n            'error.message': 'string',\n            'error.stack': 'string',\n            'error.resource.url': 'string',\n            'error.fingerprint': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"resource\" /* RumEventType.RESOURCE */] = assign({\n            'resource.url': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"action\" /* RumEventType.ACTION */] = assign({\n            'action.target.name': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"long_task\" /* RumEventType.LONG_TASK */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a);\n    var eventRateLimiters = (_b = {},\n        _b[\"error\" /* RumEventType.ERROR */] = createEventRateLimiter(\"error\" /* RumEventType.ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"action\" /* RumEventType.ACTION */] = createEventRateLimiter(\"action\" /* RumEventType.ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _b);\n    var syntheticsContext = getSyntheticsContext();\n    var ciTestContext = getCiTestContext();\n    lifeCycle.subscribe(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (_a) {\n        var startTime = _a.startTime, rawRumEvent = _a.rawRumEvent, domainContext = _a.domainContext, savedCommonContext = _a.savedCommonContext, customerContext = _a.customerContext;\n        var viewContext = viewContexts.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (session && viewContext && urlContext) {\n            var commonContext = savedCommonContext || buildCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.plan,\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"4.43.0\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: viewContext.service || configuration.service,\n                version: viewContext.version || configuration.version,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SessionType.SYNTHETICS */ : ciTestContext ? \"ci_test\" /* SessionType.CI_TEST */ : \"user\" /* SessionType.USER */,\n                },\n                view: {\n                    id: viewContext.id,\n                    name: viewContext.name,\n                    url: urlContext.url,\n                    referrer: urlContext.referrer,\n                },\n                action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n                display: getDisplayContext(),\n            };\n            var serverRumEvent = combine(rumContext, rawRumEvent);\n            serverRumEvent.context = combine(commonContext.context, customerContext);\n            if (!('has_replay' in serverRumEvent.session)) {\n                ;\n                serverRumEvent.session.has_replay = commonContext.hasReplay;\n            }\n            if (!isEmptyObject(commonContext.user)) {\n                ;\n                serverRumEvent.usr = commonContext.user;\n            }\n            if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n                if (isEmptyObject(serverRumEvent.context)) {\n                    delete serverRumEvent.context;\n                }\n                lifeCycle.notify(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, serverRumEvent);\n            }\n        }\n    });\n}\nfunction shouldSend(event, beforeSend, domainContext, eventRateLimiters) {\n    var _a;\n    if (beforeSend) {\n        var result = limitModification(event, modifiableFieldPathsByEvent[event.type], function (event) {\n            return beforeSend(event, domainContext);\n        });\n        if (result === false && event.type !== \"view\" /* RumEventType.VIEW */) {\n            return false;\n        }\n        if (result === false) {\n            display.warn(\"Can't dismiss view events using beforeSend!\");\n        }\n    }\n    var rateLimitReached = (_a = eventRateLimiters[event.type]) === null || _a === void 0 ? void 0 : _a.isLimitReached();\n    return !rateLimitReached;\n}\nfunction needToAssembleWithAction(event) {\n    return [\"error\" /* RumEventType.ERROR */, \"resource\" /* RumEventType.RESOURCE */, \"long_task\" /* RumEventType.LONG_TASK */].indexOf(event.type) !== -1;\n}\n//# sourceMappingURL=assembly.js.map","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","export function getCiTestContext() {\n    var _a;\n    var testExecutionId = (_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId');\n    if (typeof testExecutionId === 'string') {\n        return {\n            test_execution_id: testExecutionId,\n        };\n    }\n}\n//# sourceMappingURL=ciTestContext.js.map","import { addDuration, addEventListener, elapsed, relativeNow, toServerDuration } from '@datadog/browser-core';\n// Arbitrary value to cap number of element mostly for backend & to save bandwidth\nexport var MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS = 500;\n// Arbitrary value to cap number of element mostly for memory consumption in the browser\nexport var MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS = 2500;\nvar foregroundPeriods = [];\nexport function startForegroundContexts() {\n    if (document.hasFocus()) {\n        addNewForegroundPeriod();\n    }\n    var stopForegroundTracking = trackFocus(addNewForegroundPeriod).stop;\n    var stopBlurTracking = trackBlur(closeForegroundPeriod).stop;\n    return {\n        isInForegroundAt: isInForegroundAt,\n        selectInForegroundPeriodsFor: selectInForegroundPeriodsFor,\n        stop: function () {\n            foregroundPeriods = [];\n            stopForegroundTracking();\n            stopBlurTracking();\n        },\n    };\n}\nexport function addNewForegroundPeriod() {\n    if (foregroundPeriods.length > MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod !== undefined && currentForegroundPeriod.end === undefined) {\n        return;\n    }\n    foregroundPeriods.push({\n        start: now,\n    });\n}\nexport function closeForegroundPeriod() {\n    if (foregroundPeriods.length === 0) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod.end !== undefined) {\n        return;\n    }\n    currentForegroundPeriod.end = now;\n}\nfunction trackFocus(onFocusChange) {\n    return addEventListener(window, \"focus\" /* DOM_EVENT.FOCUS */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onFocusChange();\n    });\n}\nfunction trackBlur(onBlurChange) {\n    return addEventListener(window, \"blur\" /* DOM_EVENT.BLUR */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onBlurChange();\n    });\n}\nfunction isInForegroundAt(startTime) {\n    for (var i = foregroundPeriods.length - 1; i >= 0; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && startTime > foregroundPeriod.end) {\n            break;\n        }\n        if (startTime > foregroundPeriod.start &&\n            (foregroundPeriod.end === undefined || startTime < foregroundPeriod.end)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction selectInForegroundPeriodsFor(eventStartTime, duration) {\n    var eventEndTime = addDuration(eventStartTime, duration);\n    var filteredForegroundPeriods = [];\n    var earliestIndex = Math.max(0, foregroundPeriods.length - MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS);\n    for (var i = foregroundPeriods.length - 1; i >= earliestIndex; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && eventStartTime > foregroundPeriod.end) {\n            // event starts after the end of the current focus period\n            // since the array is sorted, we can stop looking for foreground periods\n            break;\n        }\n        if (eventEndTime < foregroundPeriod.start) {\n            // event ends before the start of the current focus period\n            // continue to previous one\n            continue;\n        }\n        var startTime = eventStartTime > foregroundPeriod.start ? eventStartTime : foregroundPeriod.start;\n        var startDuration = elapsed(eventStartTime, startTime);\n        var endTime = foregroundPeriod.end === undefined || eventEndTime < foregroundPeriod.end ? eventEndTime : foregroundPeriod.end;\n        var endDuration = elapsed(startTime, endTime);\n        filteredForegroundPeriods.unshift({\n            start: toServerDuration(startDuration),\n            duration: toServerDuration(endDuration),\n        });\n    }\n    return filteredForegroundPeriods;\n}\n//# sourceMappingURL=foregroundContexts.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.VIEW_CREATED */, function (view) {\n        viewContextHistory.add(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        viewContextHistory.reset();\n    });\n    function buildViewContext(view) {\n        return {\n            service: view.service,\n            version: view.version,\n            id: view.id,\n            name: view.name,\n            startClocks: view.startClocks,\n        };\n    }\n    return {\n        findView: function (startTime) { return viewContextHistory.find(startTime); },\n        stop: function () {\n            viewContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=viewContexts.js.map","import { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './rumEventsCollection/resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nvar nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    var tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, configuration, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceXhr(context, context.xhr);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(5 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(6 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    traceSampled: context.traceSampled,\n                    type: \"xhr\" /* RequestType.XHR */,\n                    url: context.url,\n                    xhr: context.xhr,\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nexport function trackFetch(lifeCycle, configuration, tracer) {\n    var subscription = initFetchObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(5 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, function (duration) {\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(6 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration: duration,\n                        method: context.method,\n                        requestIndex: context.requestIndex,\n                        responseType: context.responseType,\n                        spanId: context.spanId,\n                        startClocks: context.startClocks,\n                        status: context.status,\n                        traceId: context.traceId,\n                        traceSampled: context.traceSampled,\n                        type: \"fetch\" /* RequestType.FETCH */,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                    });\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nfunction getNextRequestIndex() {\n    var result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\nfunction waitForResponseToComplete(context, callback) {\n    var clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, function () {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(_a) {\n    var lifeCycle = _a.lifeCycle, isChildEvent = _a.isChildEvent, _b = _a.onChange, callback = _b === void 0 ? noop : _b;\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        if (event.type === 'view' || !isChildEvent(event)) {\n            return;\n        }\n        switch (event.type) {\n            case \"error\" /* RumEventType.ERROR */:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case \"action\" /* RumEventType.ACTION */:\n                eventCounts.actionCount += 1;\n                if (event.action.frustration) {\n                    eventCounts.frustrationCount += event.action.frustration.type.length;\n                }\n                callback();\n                break;\n            case \"long_task\" /* RumEventType.LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case \"resource\" /* RumEventType.RESOURCE */:\n                eventCounts.resourceCount += 1;\n                callback();\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { instrumentMethodAndCallOriginal, matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout, } from '@datadog/browser-core';\n// Delay to wait for a page activity to validate the tracking process\nexport var PAGE_ACTIVITY_VALIDATION_DELAY = 100;\n// Delay to wait after a page activity to end the tracking process\nexport var PAGE_ACTIVITY_END_DELAY = 100;\n/**\n * Wait for the page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, pageActivityEndCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    var pageActivityEndTimeoutId;\n    var hasCompleted = false;\n    var validationTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: false }); }), PAGE_ACTIVITY_VALIDATION_DELAY);\n    var maxDurationTimeoutId = maxDuration !== undefined\n        ? setTimeout(monitor(function () { return complete({ hadActivity: true, end: timeStampNow() }); }), maxDuration)\n        : undefined;\n    var pageActivitySubscription = pageActivityObservable.subscribe(function (_a) {\n        var isBusy = _a.isBusy;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: true, end: lastChangeTime }); }), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    var stop = function () {\n        hasCompleted = true;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        pageActivityEndCallback(event);\n    }\n    return { stop: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, configuration) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (entry) { return entry.entryType === 'resource' && !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(5 /* LifeCycleEventType.REQUEST_STARTED */, function (startEvent) {\n            if (isExcludedUrl(configuration, startEvent.url)) {\n                return;\n            }\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            pendingRequestsCount += 1;\n            notifyPageActivity();\n        }), lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n            if (isExcludedUrl(configuration, request.url) ||\n                firstRequestIndex === undefined ||\n                // If the request started before the tracking start, ignore it\n                request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            pendingRequestsCount -= 1;\n            notifyPageActivity();\n        }));\n        var stopTrackingWindowOpen = trackWindowOpen(notifyPageActivity).stop;\n        return function () {\n            stopTrackingWindowOpen();\n            subscriptions.forEach(function (s) { return s.unsubscribe(); });\n        };\n        function notifyPageActivity() {\n            observable.notify({ isBusy: pendingRequestsCount > 0 });\n        }\n    });\n    return observable;\n}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction trackWindowOpen(callback) {\n    return instrumentMethodAndCallOriginal(window, 'open', { before: callback });\n}\n//# sourceMappingURL=waitPageActivityEnd.js.map","import { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nexport var MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport var MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    var bufferedClicks = [];\n    var status = 0 /* ClickChainStatus.WaitingForMoreClicks */;\n    var maxDurationBetweenClicksTimeoutId;\n    appendClick(firstClick);\n    function appendClick(click) {\n        click.stopObservable.subscribe(tryFinalize);\n        bufferedClicks.push(click);\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        maxDurationBetweenClicksTimeoutId = setTimeout(dontAcceptMoreClick, MAX_DURATION_BETWEEN_CLICKS);\n    }\n    function tryFinalize() {\n        if (status === 1 /* ClickChainStatus.WaitingForClicksToStop */ && bufferedClicks.every(function (click) { return click.isStopped(); })) {\n            status = 2 /* ClickChainStatus.Finalized */;\n            onFinalize(bufferedClicks);\n        }\n    }\n    function dontAcceptMoreClick() {\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        if (status === 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n            status = 1 /* ClickChainStatus.WaitingForClicksToStop */;\n            tryFinalize();\n        }\n    }\n    return {\n        tryAppend: function (click) {\n            if (status !== 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n                return false;\n            }\n            if (bufferedClicks.length > 0 &&\n                !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)) {\n                dontAcceptMoreClick();\n                return false;\n            }\n            appendClick(click);\n            return true;\n        },\n        stop: function () {\n            dontAcceptMoreClick();\n        },\n    };\n}\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first, second) {\n    return (first.target === second.target &&\n        mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n        first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS);\n}\nfunction mouseEventDistance(origin, other) {\n    return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2));\n}\n//# sourceMappingURL=clickChain.js.map","import { safeTruncate, isIE, find } from '@datadog/browser-core';\n/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nexport var DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name';\nexport function getActionNameFromElement(element, userProgrammaticAttribute) {\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, use strategies that are known to return good results. Those strategies will be used on\n    //   the element and a few parents, but it's likely that they won't succeed at all.\n    // * if no name is found this way, use strategies returning less accurate names as a fallback.\n    //   Those are much likely to succeed.\n    return (getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute)) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies) ||\n        '');\n}\nfunction getActionNameFromElementProgrammatically(targetElement, programmaticAttribute) {\n    var elementWithAttribute;\n    // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n    // without limit. It is up to the user to declare a relevant naming strategy.\n    // If available, use element.closest() to match get the attribute from the element or any of its\n    // parent.  Else fallback to a more traditional implementation.\n    if (supportsElementClosest()) {\n        elementWithAttribute = targetElement.closest(\"[\".concat(programmaticAttribute, \"]\"));\n    }\n    else {\n        var element = targetElement;\n        while (element) {\n            if (element.hasAttribute(programmaticAttribute)) {\n                elementWithAttribute = element;\n                break;\n            }\n            element = element.parentElement;\n        }\n    }\n    if (!elementWithAttribute) {\n        return;\n    }\n    var name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nvar priorityStrategies = [\n    // associated LABEL text\n    function (element, userProgrammaticAttribute) {\n        // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n        // instead\n        if (supportsLabelProperty()) {\n            if ('labels' in element && element.labels && element.labels.length > 0) {\n                return getTextualContent(element.labels[0], userProgrammaticAttribute);\n            }\n        }\n        else if (element.id) {\n            var label = element.ownerDocument &&\n                find(element.ownerDocument.querySelectorAll('label'), function (label) { return label.htmlFor === element.id; });\n            return label && getTextualContent(label, userProgrammaticAttribute);\n        }\n    },\n    // INPUT button (and associated) value\n    function (element) {\n        if (element.nodeName === 'INPUT') {\n            var input = element;\n            var type = input.getAttribute('type');\n            if (type === 'button' || type === 'submit' || type === 'reset') {\n                return input.value;\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    function (element, userProgrammaticAttribute) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getTextualContent(element, userProgrammaticAttribute);\n        }\n    },\n    function (element) { return element.getAttribute('aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return labelledByAttribute\n                .split(/\\s+/)\n                .map(function (id) { return getElementById(element, id); })\n                .filter(function (label) { return Boolean(label); })\n                .map(function (element) { return getTextualContent(element, userProgrammaticAttribute); })\n                .join(' ');\n        }\n    },\n    function (element) { return element.getAttribute('alt'); },\n    function (element) { return element.getAttribute('name'); },\n    function (element) { return element.getAttribute('title'); },\n    function (element) { return element.getAttribute('placeholder'); },\n    // SELECT first OPTION text\n    function (element, userProgrammaticAttribute) {\n        if ('options' in element && element.options.length > 0) {\n            return getTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nvar fallbackStrategies = [\n    function (element, userProgrammaticAttribute) { return getTextualContent(element, userProgrammaticAttribute); },\n];\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nvar MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, userProgrammaticAttribute, strategies) {\n    var element = targetElement;\n    var recursionCounter = 0;\n    while (recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n        element &&\n        element.nodeName !== 'BODY' &&\n        element.nodeName !== 'HTML' &&\n        element.nodeName !== 'HEAD') {\n        for (var _i = 0, strategies_1 = strategies; _i < strategies_1.length; _i++) {\n            var strategy = strategies_1[_i];\n            var name_1 = strategy(element, userProgrammaticAttribute);\n            if (typeof name_1 === 'string') {\n                var trimmedName = name_1.trim();\n                if (trimmedName) {\n                    return truncate(normalizeWhitespace(trimmedName));\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".concat(safeTruncate(s, 100), \" [...]\") : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getTextualContent(element, userProgrammaticAttribute) {\n    if (element.isContentEditable) {\n        return;\n    }\n    if ('innerText' in element) {\n        var text_1 = element.innerText;\n        var removeTextFromElements = function (query) {\n            var list = element.querySelectorAll(query);\n            for (var index = 0; index < list.length; index += 1) {\n                var element_1 = list[index];\n                if ('innerText' in element_1) {\n                    var textToReplace = element_1.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text_1 = text_1.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        if (!supportsInnerTextScriptAndStyleRemoval()) {\n            // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n            // be relatively fast and work in most cases.\n            removeTextFromElements('script, style');\n        }\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(\"[\".concat(DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, \"]\"));\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(\"[\".concat(userProgrammaticAttribute, \"]\"));\n        }\n        return text_1;\n    }\n    return element.textContent;\n}\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n    return !isIE();\n}\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsLabelPropertyResult;\nfunction supportsLabelProperty() {\n    if (supportsLabelPropertyResult === undefined) {\n        supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype;\n    }\n    return supportsLabelPropertyResult;\n}\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsElementClosestResult;\nfunction supportsElementClosest() {\n    if (supportsElementClosestResult === undefined) {\n        supportsElementClosestResult = 'closest' in HTMLElement.prototype;\n    }\n    return supportsElementClosestResult;\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { cssEscape } from '@datadog/browser-core';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './getActionNameFromElement';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport var STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nvar GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nvar UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    var targetElementSelector = '';\n    var element = targetElement;\n    while (element && element.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(element, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(element, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(element), targetElementSelector);\n        element = element.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if a the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time. We might want to allow customers to\n    // provide their own `isGeneratedValue` at some point.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return \"#\".concat(cssEscape(element.id));\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    if (element.classList.length > 0) {\n        for (var i = 0; i < element.classList.length; i += 1) {\n            var className = element.classList[i];\n            if (isGeneratedValue(className)) {\n                continue;\n            }\n            return \"\".concat(element.tagName, \".\").concat(cssEscape(className));\n        }\n    }\n}\nfunction getTagNameSelector(element) {\n    return element.tagName;\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        var selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (var _i = 0, STABLE_ATTRIBUTES_1 = STABLE_ATTRIBUTES; _i < STABLE_ATTRIBUTES_1.length; _i++) {\n        var attributeName = STABLE_ATTRIBUTES_1[_i];\n        var selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return \"\".concat(element.tagName, \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = element.parentElement.firstElementChild;\n    var elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return \"\".concat(element.tagName, \":nth-of-type(\").concat(elementIndex, \")\");\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (var _i = 0, selectorGetters_1 = selectorGetters; _i < selectorGetters_1.length; _i++) {\n        var selectorGetter = selectorGetters_1[_i];\n        var elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        var fullSelector = combineSelector(elementSelector, childSelector);\n        if (predicate(element, fullSelector)) {\n            return fullSelector;\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, selector) {\n    return element.ownerDocument.querySelectorAll(selector).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > SELECTOR\" returns a single element.\n *\n * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT SELECTOR\" returns a single element), regardless of whether the selector is a\n * direct descendent of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\n */\nfunction isSelectorUniqueAmongSiblings(element, selector) {\n    return (element.parentElement.querySelectorAll(supportScopeSelector() ? combineSelector(':scope', selector) : selector)\n        .length === 1);\n}\nfunction combineSelector(parent, child) {\n    return child ? \"\".concat(parent, \">\").concat(child) : parent;\n}\nvar supportScopeSelectorCache;\nexport function supportScopeSelector() {\n    if (supportScopeSelectorCache === undefined) {\n        try {\n            document.querySelector(':scope');\n            supportScopeSelectorCache = true;\n        }\n        catch (_a) {\n            supportScopeSelectorCache = false;\n        }\n    }\n    return supportScopeSelectorCache;\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { addEventListener } from '@datadog/browser-core';\nexport function listenActionEvents(_a) {\n    var onPointerDown = _a.onPointerDown, onPointerUp = _a.onPointerUp;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(window, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, function (event) {\n            if (isValidPointerEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: false,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(window, \"selectionchange\" /* DOM_EVENT.SELECTION_CHANGE */, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(window, \"pointerup\" /* DOM_EVENT.POINTER_UP */, function (event) {\n            if (isValidPointerEvent(event) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                var localUserActivity_1 = userActivity;\n                onPointerUp(clickContext, event, function () { return localUserActivity_1; });\n                clickContext = undefined;\n            }\n        }, { capture: true }),\n        addEventListener(window, \"input\" /* DOM_EVENT.INPUT */, function () {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: function () {\n            listeners.forEach(function (listener) { return listener.stop(); });\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    var selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidPointerEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        event.isPrimary !== false);\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { elementMatches, ONE_SECOND } from '@datadog/browser-core';\nvar MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(\"rage_click\" /* FrustrationType.RAGE_CLICK */);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        return { isRage: true };\n    }\n    var hasSelectionChanged = clicks.some(function (click) { return click.getUserActivity().selection; });\n    clicks.forEach(function (click) {\n        if (click.hasError) {\n            click.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        if (isDead(click) &&\n            // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n            !hasSelectionChanged) {\n            click.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n    });\n    return { isRage: false };\n}\nexport function isRage(clicks) {\n    if (clicks.some(function (click) { return click.getUserActivity().selection; })) {\n        return false;\n    }\n    for (var i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n        if (clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n            ONE_SECOND) {\n            return true;\n        }\n    }\n    return false;\n}\nvar DEAD_CLICK_EXCLUDE_SELECTOR = \n// inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n// inputs (using a negative selector is shorter here)\n'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n    'textarea,' +\n    'select,' +\n    // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n    '[contenteditable],' +\n    '[contenteditable] *,' +\n    // canvas, as there is no good way to detect activity occurring on them\n    'canvas,' +\n    // links that are interactive (have an href attribute) or any of their descendants, as they can\n    // open a new tab or navigate to a hash without triggering a meaningful event\n    'a[href],' +\n    'a[href] *';\nexport function isDead(click) {\n    if (click.hasPageActivity || click.getUserActivity().input) {\n        return false;\n    }\n    return !elementMatches(click.event.target, DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { includes, timeStampNow, Observable, assign, getRelativeTime, ONE_MINUTE, ValueHistory, generateUUID, clocksNow, ONE_SECOND, elapsed, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { getSelectorFromElement } from './getSelectorFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\n// Maximum duration for click actions\nexport var CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, configuration) {\n    var history = new ValueHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    var stopObservable = new Observable();\n    var currentClickChain;\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents({\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent);\n        },\n        onPointerUp: function (_a, startEvent, getUserActivity) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            return startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) {\n            return configuration.trackFrustrations ? history.findAll(startTime) : history.find(startTime);\n        },\n    };\n    return {\n        stop: function () {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts: actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            var rageClick_1 = click.clone();\n            currentClickChain = createClickChain(click, function (clicks) {\n                finalizeClicks(clicks, rageClick_1);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent) {\n    if (!configuration.trackFrustrations && history.find()) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any new\n        // action if another one is already occurring.\n        return;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, configuration.actionNameAttribute);\n    if (!configuration.trackFrustrations && !clickActionBase.name) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any action\n        // with a blank name\n        return;\n    }\n    var hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n        hadActivityOnPointerDown = pageActivityEndEvent.hadActivity;\n    }, \n    // We don't care about the activity duration, we just want to know whether an activity did happen\n    // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n    PAGE_ACTIVITY_VALIDATION_DELAY);\n    return { clickActionBase: clickActionBase, hadActivityOnPointerDown: function () { return hadActivityOnPointerDown; } };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    if (configuration.trackFrustrations) {\n        appendClickToClickChain(click);\n    }\n    var stopWaitPageActivityEnd = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n            // If the clock is looking weird, just discard the click\n            click.discard();\n        }\n        else {\n            if (pageActivityEndEvent.hadActivity) {\n                click.stop(pageActivityEndEvent.end);\n            }\n            else if (hadActivityOnPointerDown()) {\n                click.stop(\n                // using the click start as activity end, so the click will have some activity but its\n                // duration will be 0 (as the activity started before the click start)\n                click.startClocks.timeStamp);\n            }\n            else {\n                click.stop();\n            }\n            // Validate or discard the click only if we don't track frustrations. It'll be done when\n            // the click chain is finalized.\n            if (!configuration.trackFrustrations) {\n                if (!pageActivityEndEvent.hadActivity) {\n                    // If we are not tracking frustrations, we should discard the click to keep backward\n                    // compatibility.\n                    click.discard();\n                }\n                else {\n                    click.validate();\n                }\n            }\n        }\n    }, CLICK_ACTION_MAX_DURATION).stop;\n    var viewEndedSubscription = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        click.stop(endClocks.timeStamp);\n    });\n    var stopSubscription = stopObservable.subscribe(function () {\n        click.stop();\n    });\n    click.stopObservable.subscribe(function () {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, actionNameAttribute) {\n    var rect = event.target.getBoundingClientRect();\n    return {\n        type: \"click\" /* ActionType.CLICK */,\n        target: {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector: getSelectorFromElement(event.target, actionNameAttribute),\n        },\n        position: {\n            // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n            x: Math.round(event.clientX - rect.left),\n            y: Math.round(event.clientY - rect.top),\n        },\n        name: getActionNameFromElement(event.target, actionNameAttribute),\n    };\n}\nfunction newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent) {\n    var id = generateUUID();\n    var startClocks = clocksNow();\n    var historyEntry = history.add(id, startClocks.relative);\n    var eventCountsSubscription = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) {\n            return event.action !== undefined &&\n                (Array.isArray(event.action.id) ? includes(event.action.id, id) : event.action.id === id);\n        },\n    });\n    var status = 0 /* ClickStatus.ONGOING */;\n    var activityEndTime;\n    var frustrationTypes = [];\n    var stopObservable = new Observable();\n    function stop(newActivityEndTime) {\n        if (status !== 0 /* ClickStatus.ONGOING */) {\n            return;\n        }\n        activityEndTime = newActivityEndTime;\n        status = 1 /* ClickStatus.STOPPED */;\n        if (activityEndTime) {\n            historyEntry.close(getRelativeTime(activityEndTime));\n        }\n        else {\n            historyEntry.remove();\n        }\n        eventCountsSubscription.stop();\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop: stop,\n        stopObservable: stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity: getUserActivity,\n        addFrustration: function (frustrationType) {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks: startClocks,\n        isStopped: function () { return status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */; },\n        clone: function () { return newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent); },\n        validate: function (domEvents) {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            var _a = eventCountsSubscription.eventCounts, resourceCount = _a.resourceCount, errorCount = _a.errorCount, longTaskCount = _a.longTaskCount;\n            var clickAction = assign({\n                type: \"click\" /* ActionType.CLICK */,\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks: startClocks,\n                id: id,\n                frustrationTypes: frustrationTypes,\n                counts: {\n                    resourceCount: resourceCount,\n                    errorCount: errorCount,\n                    longTaskCount: longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n            }, clickActionBase);\n            lifeCycle.notify(1 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n        discard: function () {\n            stop();\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    var isRage = computeFrustration(clicks, rageClick).isRage;\n    if (isRage) {\n        clicks.forEach(function (click) { return click.discard(); });\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map(function (click) { return click.event; }));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach(function (click) { return click.validate(); });\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts) {\n    lifeCycle.subscribe(1 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action, foregroundContexts));\n    });\n    var actionContexts = { findActionId: noop };\n    if (configuration.trackUserInteractions) {\n        actionContexts = trackClickActions(lifeCycle, domMutationObservable, configuration).actionContexts;\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, foregroundContexts)));\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction processAction(action, foregroundContexts) {\n    var autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                id: action.id,\n                loading_time: toServerDuration(action.duration),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\n                },\n            },\n        }\n        : undefined;\n    var customerContext = !isAutoAction(action) ? action.context : undefined;\n    var actionEvent = combine({\n        action: {\n            id: generateUUID(),\n            target: {\n                name: action.name,\n            },\n            type: action.type,\n        },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* RumEventType.ACTION */,\n    }, autoActionProperties);\n    var inForeground = foregroundContexts.isInForegroundAt(action.startClocks.relative);\n    if (inForeground !== undefined) {\n        actionEvent.view = { in_foreground: inForeground };\n    }\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: isAutoAction(action) ? { event: action.event, events: action.events } : {},\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* ActionType.CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","import { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts) {\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n            customerContext: customerContext,\n            savedCommonContext: savedCommonContext,\n        }, processError(error, foregroundContexts, featureFlagContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n            var rawError = computeRawError({\n                stackTrace: stackTrace,\n                originalError: error,\n                handlingStack: handlingStack,\n                startClocks: startClocks,\n                nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n                source: ErrorSource.CUSTOM,\n                handling: \"handled\" /* ErrorHandling.HANDLED */,\n            });\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction processError(error, foregroundContexts, featureFlagContexts) {\n    var rawRumEvent = {\n        date: error.startClocks.timeStamp,\n        error: {\n            id: generateUUID(),\n            message: error.message,\n            source: error.source,\n            stack: error.stack,\n            handling_stack: error.handlingStack,\n            type: error.type,\n            handling: error.handling,\n            causes: error.causes,\n            source_type: 'browser',\n            fingerprint: error.fingerprint,\n        },\n        type: \"error\" /* RumEventType.ERROR */,\n    };\n    var inForeground = foregroundContexts.isInForegroundAt(error.startClocks.relative);\n    if (inForeground) {\n        rawRumEvent.view = { in_foreground: inForeground };\n    }\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\n    }\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: {\n            error: error.originalError,\n        },\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { clocksNow, initConsoleObservable, ErrorSource, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    var subscription = initConsoleObservable([ConsoleApiName.error]).subscribe(function (consoleError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: consoleError.message,\n            stack: consoleError.stack,\n            fingerprint: consoleError.fingerprint,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            handlingStack: consoleError.handlingStack,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { clocksNow, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(errorObservable) {\n    var subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(function (reportError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: reportError.message,\n            stack: reportError.stack,\n            type: reportError.subtype,\n            source: ErrorSource.REPORT,\n            handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { addEventListeners } from '@datadog/browser-core';\nvar trackFirstHiddenSingleton;\nvar stopListeners;\nexport function trackFirstHidden(eventTarget) {\n    if (eventTarget === void 0) { eventTarget = window; }\n    if (!trackFirstHiddenSingleton) {\n        if (document.visibilityState === 'hidden') {\n            trackFirstHiddenSingleton = {\n                timeStamp: 0,\n            };\n        }\n        else {\n            trackFirstHiddenSingleton = {\n                timeStamp: Infinity,\n            };\n            (stopListeners = addEventListeners(eventTarget, [\"pagehide\" /* DOM_EVENT.PAGE_HIDE */, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */], function (event) {\n                if (event.type === 'pagehide' || document.visibilityState === 'hidden') {\n                    trackFirstHiddenSingleton.timeStamp = event.timeStamp;\n                    stopListeners();\n                }\n            }, { capture: true }).stop);\n        }\n    }\n    return trackFirstHiddenSingleton;\n}\nexport function resetFirstHidden() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    trackFirstHiddenSingleton = undefined;\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { addDuration } from '@datadog/browser-core';\nimport { toValidEntry } from './resourceUtils';\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestTiming(request) {\n    if (!performance || !('getEntriesByName' in performance)) {\n        return;\n    }\n    var sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    var candidates = sameNameEntries\n        .map(function (entry) { return entry.toJSON(); })\n        .filter(toValidEntry)\n        .filter(function (entry) {\n        return isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration }));\n    });\n    if (candidates.length === 1) {\n        return candidates[0];\n    }\n    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, isExperimentalFeatureEnabled, ExperimentalFeature, } from '@datadog/browser-core';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle, configuration, sessionManager, pageStateHistory) {\n    lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processRequest(request, configuration, sessionManager, pageStateHistory));\n    });\n    lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'resource' && !isRequestKind(entry)) {\n                lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processResourceEntry(entry, configuration, sessionManager, pageStateHistory));\n            }\n        }\n    });\n}\nfunction processRequest(request, configuration, sessionManager, pageStateHistory) {\n    var _a;\n    var type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.FETCH */;\n    var matchingTiming = matchRequestTiming(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined;\n    var tracingInfo = computeRequestTracingInfo(request, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var duration = computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, (_a = matchingTiming === null || matchingTiming === void 0 ? void 0 : matchingTiming.duration) !== null && _a !== void 0 ? _a : request.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: duration,\n            method: request.method,\n            status_code: request.status,\n            url: request.url,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides, indexingInfo, pageStateInfo);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming && toPerformanceEntryRepresentation(matchingTiming),\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n        },\n    };\n}\nfunction processResourceEntry(entry, configuration, sessionManager, pageStateHistory) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeEntryTracingInfo(entry, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, entry.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, entryMetrics, indexingInfo, pageStateInfo);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: toPerformanceEntryRepresentation(entry),\n        },\n    };\n}\nfunction computePerformanceEntryMetrics(timing) {\n    return {\n        resource: assign({\n            duration: computePerformanceResourceDuration(timing),\n            size: computeSize(timing),\n        }, computePerformanceResourceDetails(timing)),\n    };\n}\nfunction computeRequestTracingInfo(request, configuration) {\n    var hasBeenTraced = request.traceSampled && request.traceId && request.spanId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            span_id: request.spanId.toDecimalString(),\n            trace_id: request.traceId.toDecimalString(),\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry, configuration) {\n    var hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\n// TODO next major: use directly PerformanceEntry type in domain context\nfunction toPerformanceEntryRepresentation(entry) {\n    return entry;\n}\n/**\n * @returns number between 0 and 1 which represents trace sample rate\n */\nfunction getRulePsr(configuration) {\n    return isNumber(configuration.traceSampleRate) ? configuration.traceSampleRate / 100 : undefined;\n}\nfunction computeIndexingInfo(sessionManager, resourceStart) {\n    var session = sessionManager.findTrackedSession(resourceStart.relative);\n    return {\n        _dd: {\n            discarded: !session || !session.resourceAllowed,\n        },\n    };\n}\nfunction computePageStateInfo(pageStateHistory, startClocks, duration) {\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.RESOURCE_PAGE_STATES)) {\n        return;\n    }\n    return {\n        _dd: {\n            page_states: pageStateHistory.findAll(startClocks.relative, duration),\n            page_was_discarded: String(document.wasDiscarded),\n        },\n    };\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    var _a;\n    // TODO remove FF in next major\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.NO_RESOURCE_DURATION_FROZEN_STATE)) {\n        return toServerDuration(duration);\n    }\n    var requestCrossedFrozenState = (_a = pageStateHistory\n        .findAll(startClocks.relative, duration)) === null || _a === void 0 ? void 0 : _a.some(function (pageState) { return pageState.state === \"frozen\" /* PageState.FROZEN */; });\n    return !requestCrossedFrozenState ? toServerDuration(duration) : undefined;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { setTimeout, assign, addEventListeners, elapsed, ONE_MINUTE, find, findLast, relativeNow, } from '@datadog/browser-core';\nimport { trackFirstHidden } from './trackFirstHidden';\n// Discard LCP and FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var TIMING_MAXIMUM_DELAY = 10 * ONE_MINUTE;\n/**\n * The initial view can finish quickly, before some metrics can be produced (ex: before the page load\n * event, or the first input). Also, we don't want to trigger a view update indefinitely, to avoid\n * updates on views that ended a long time ago. Keep watching for metrics after the view ends for a\n * limited amount of time.\n */\nexport var KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackInitialViewTimings(lifeCycle, setLoadEvent, scheduleViewUpdate) {\n    var timings = {};\n    function setTimings(newTimings) {\n        assign(timings, newTimings);\n        scheduleViewUpdate();\n    }\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, function (newTimings) {\n        setLoadEvent(newTimings.loadEvent);\n        setTimings(newTimings);\n    }).stop;\n    var stopFCPTracking = trackFirstContentfulPaintTiming(lifeCycle, function (firstContentfulPaint) {\n        return setTimings({ firstContentfulPaint: firstContentfulPaint });\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaintTiming(lifeCycle, window, function (largestContentfulPaint) {\n        setTimings({\n            largestContentfulPaint: largestContentfulPaint,\n        });\n    }).stop;\n    var stopFIDTracking = trackFirstInputTimings(lifeCycle, function (_a) {\n        var firstInputDelay = _a.firstInputDelay, firstInputTime = _a.firstInputTime;\n        setTimings({\n            firstInputDelay: firstInputDelay,\n            firstInputTime: firstInputTime,\n        });\n    }).stop;\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n    }\n    return {\n        stop: stop,\n        timings: timings,\n        scheduleStop: function () {\n            setTimeout(stop, KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY);\n        },\n    };\n}\nexport function trackNavigationTimings(lifeCycle, callback) {\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'navigation') {\n                callback({\n                    domComplete: entry.domComplete,\n                    domContentLoaded: entry.domContentLoadedEventEnd,\n                    domInteractive: entry.domInteractive,\n                    loadEvent: entry.loadEventEnd,\n                    // In some cases the value reported is negative or is larger\n                    // than the current page time. Ignore these cases:\n                    // https://github.com/GoogleChrome/web-vitals/issues/137\n                    // https://github.com/GoogleChrome/web-vitals/issues/162\n                    firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\n                });\n            }\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\nexport function trackFirstContentfulPaintTiming(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === 'paint' &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getLCP.ts\n */\nexport function trackLargestContentfulPaintTiming(lifeCycle, eventTarget, callback) {\n    var firstHidden = trackFirstHidden();\n    // Ignore entries that come after the first user interaction.  According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    var firstInteractionTimestamp = Infinity;\n    var stopEventListener = addEventListeners(eventTarget, [\"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === 'largest-contentful-paint' &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (lcpEntry) {\n            callback(lcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInputTimings(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === 'first-input' && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                firstInputDelay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                firstInputTime: firstInputEntry.startTime,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=trackInitialViewTimings.js.map","import { noop, round, ONE_SECOND, elapsed } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nexport function trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    var viewMetrics = {};\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadingType, viewStart, function (newLoadingTime) {\n        viewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopCLSTracking;\n    if (isLayoutShiftSupported()) {\n        viewMetrics.cumulativeLayoutShift = 0;\n        (stopCLSTracking = trackCumulativeLayoutShift(lifeCycle, function (cumulativeLayoutShift) {\n            viewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n            scheduleViewUpdate();\n        }).stop);\n    }\n    else {\n        stopCLSTracking = noop;\n    }\n    return {\n        stop: function () {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        viewMetrics: viewMetrics,\n    };\n}\nfunction trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadType, viewStart, callback) {\n    var isWaitingForLoadEvent = loadType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */;\n    var isWaitingForActivityLoadingTime = true;\n    var loadingTimeCandidates = [];\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            callback(Math.max.apply(Math, loadingTimeCandidates));\n        }\n    }\n    var stop = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (event) {\n        if (isWaitingForActivityLoadingTime) {\n            isWaitingForActivityLoadingTime = false;\n            if (event.hadActivity) {\n                loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));\n            }\n            invokeCallbackIfAllCandidatesAreReceived();\n        }\n    }).stop;\n    return {\n        stop: stop,\n        setLoadEvent: function (loadEvent) {\n            if (isWaitingForLoadEvent) {\n                isWaitingForLoadEvent = false;\n                loadingTimeCandidates.push(loadEvent);\n                invokeCallbackIfAllCandidatesAreReceived();\n            }\n        },\n    };\n}\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nfunction trackCumulativeLayoutShift(lifeCycle, callback) {\n    var maxClsValue = 0;\n    var window = slidingSessionWindow();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'layout-shift' && !entry.hadRecentInput) {\n                window.update(entry);\n                if (window.value() > maxClsValue) {\n                    maxClsValue = window.value();\n                    callback(round(maxClsValue, 4));\n                }\n            }\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\nfunction slidingSessionWindow() {\n    var value = 0;\n    var startTime;\n    var endTime;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= ONE_SECOND ||\n                entry.startTime - startTime >= 5 * ONE_SECOND;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                value = entry.value;\n            }\n            else {\n                value += entry.value;\n                endTime = entry.startTime;\n            }\n        },\n        value: function () { return value; },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nfunction isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent('layout-shift');\n}\n//# sourceMappingURL=trackViewMetrics.js.map","import { ONE_MINUTE, setTimeout } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\n// Some events are not being counted as they transcend views. To reduce the occurrence;\n// an arbitrary delay is added for stopping event counting after the view ends.\n//\n// Ideally, we would not stop and keep counting events until the end of the session.\n// But this might have a small performance impact if there are many many views:\n// we would need to go through each event to see if the related view matches.\n// So let's have a fairly short delay to avoid impacting performances too much.\n//\n// In the future, we could have views stored in a data structure similar to ContextHistory. Whenever\n// a child event is collected, we could look into this history to find the matching view and\n// increase the associated and increase its counter. Having a centralized data structure for it\n// would allow us to look for views more efficiently.\n//\n// For now, having a small cleanup delay will already improve the situation in most cases.\nexport var KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    var _a = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) { return event.view.id === viewId; },\n        onChange: onChange,\n    }), stop = _a.stop, eventCounts = _a.eventCounts;\n    return {\n        scheduleStop: function () {\n            setTimeout(stop, KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY);\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { noop, PageExitReason, shallowClone, assign, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, } from '@datadog/browser-core';\nimport { trackInitialViewTimings } from './trackInitialViewTimings';\nimport { trackViewMetrics } from './trackViewMetrics';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    var currentView = startNewView(\"initial_load\" /* ViewLoadingType.INITIAL_LOAD */, clocksOrigin(), initialViewOptions);\n    startViewLifeCycle();\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        return newView(lifeCycle, domMutationObservable, configuration, location, loadingType, startClocks, viewOptions);\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n            // Renew view on session renewal\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, undefined, {\n                name: currentView.name,\n                service: currentView.service,\n                version: currentView.version,\n            });\n        });\n        lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n            currentView.end({ sessionIsActive: false });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(9 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING || pageExitEvent.reason === PageExitReason.PAGEHIDE) {\n                currentView.end();\n            }\n        });\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(function (_a) {\n            var oldLocation = _a.oldLocation, newLocation = _a.newLocation;\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */);\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n        },\n        startView: function (options, startClocks) {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, startClocks, options);\n        },\n        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            currentView.end();\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, configuration, initialLocation, loadingType, startClocks, viewOptions) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    var sessionIsActive = true;\n    var name;\n    var service;\n    var version;\n    if (viewOptions) {\n        name = viewOptions.name;\n        service = viewOptions.service;\n        version = viewOptions.version;\n    }\n    lifeCycle.notify(2 /* LifeCycleEventType.VIEW_CREATED */, {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n    });\n    // Update the view every time the measures are changing\n    var _a = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopViewMetricsTracking = _b.stop, viewMetrics = _b.viewMetrics;\n    var _c = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewTimings(lifeCycle, setLoadEvent, scheduleViewUpdate)\n        : { scheduleStop: noop, timings: {} }, scheduleStopInitialViewTimingsTracking = _c.scheduleStop, timings = _c.timings;\n    var _d = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), scheduleStopEventCountsTracking = _d.scheduleStop, eventCounts = _d.eventCounts;\n    // Session keep alive\n    var keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(3 /* LifeCycleEventType.VIEW_UPDATED */, assign({\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            service: service,\n            version: version,\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            timings: timings,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive: sessionIsActive,\n            eventCounts: eventCounts,\n        }, viewMetrics));\n    }\n    return {\n        name: name,\n        service: service,\n        version: version,\n        end: function (options) {\n            var _a, _b;\n            if (options === void 0) { options = {}; }\n            if (endClocks) {\n                // view already ended\n                return;\n            }\n            endClocks = (_a = options.endClocks) !== null && _a !== void 0 ? _a : clocksNow();\n            sessionIsActive = (_b = options.sessionIsActive) !== null && _b !== void 0 ? _b : true;\n            lifeCycle.notify(4 /* LifeCycleEventType.VIEW_ENDED */, { endClocks: endClocks });\n            clearInterval(keepAliveIntervalId);\n            stopViewMetricsTracking();\n            scheduleStopInitialViewTimingsTracking();\n            scheduleStopEventCountsTracking();\n            triggerViewUpdate();\n        },\n        addTiming: function (name, time) {\n            if (endClocks) {\n                return;\n            }\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    var sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(\"Invalid timing name: \".concat(name, \", sanitized to: \").concat(sanitized));\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    var correspondingId = hash.substr(1);\n    return !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    var index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { isExperimentalFeatureEnabled, ExperimentalFeature, isEmptyObject, mapValues, toServerDuration, isNumber, } from '@datadog/browser-core';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, foregroundContexts, featureFlagContexts, recorderApi, pageStateHistory));\n    });\n    var trackViewResult = trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n    return trackViewResult;\n}\nfunction processViewUpdate(view, foregroundContexts, featureFlagContexts, recorderApi, pageStateHistory) {\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\n    var pageStatesEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGE_STATES);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            page_states: pageStatesEnabled ? pageStateHistory.findAll(view.startClocks.relative, view.duration) : undefined,\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* RumEventType.VIEW */,\n        view: {\n            action: {\n                count: view.eventCounts.actionCount,\n            },\n            frustration: {\n                count: view.eventCounts.frustrationCount,\n            },\n            cumulative_layout_shift: view.cumulativeLayoutShift,\n            first_byte: toServerDuration(view.timings.firstByte),\n            dom_complete: toServerDuration(view.timings.domComplete),\n            dom_content_loaded: toServerDuration(view.timings.domContentLoaded),\n            dom_interactive: toServerDuration(view.timings.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.timings.firstContentfulPaint),\n            first_input_delay: toServerDuration(view.timings.firstInputDelay),\n            first_input_time: toServerDuration(view.timings.firstInputTime),\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration(view.timings.largestContentfulPaint),\n            load_event: toServerDuration(view.timings.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n            in_foreground_periods: !pageStatesEnabled\n                ? foregroundContexts.selectInForegroundPeriodsFor(view.startClocks.relative, view.duration)\n                : undefined,\n        },\n        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\n        session: {\n            has_replay: replayStats ? true : undefined,\n            is_active: view.sessionIsActive ? undefined : false,\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\nfunction discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=viewCollection.js.map","import { Observable, noop, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle) {\n    var sessionManager = startSessionManager(\n    // TODO - Improve configuration type and remove assertion\n    configuration.sessionStoreStrategyType, RUM_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); });\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(7 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(8 /* LifeCycleEventType.SESSION_RENEWED */);\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findActiveSession(startTime);\n            if (!session || !isTypeTracked(session.trackingType)) {\n                return;\n            }\n            var plan = session.trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */\n                ? 2 /* RumSessionPlan.WITH_SESSION_REPLAY */\n                : 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */;\n            return {\n                id: session.id,\n                plan: plan,\n                sessionReplayAllowed: plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                longTaskAllowed: configuration.trackLongTasks !== undefined\n                    ? configuration.trackLongTasks\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                resourceAllowed: configuration.trackResources !== undefined\n                    ? configuration.trackResources\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n            };\n        },\n        expire: sessionManager.expire,\n        expireObservable: sessionManager.expireObservable,\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        plan: 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */,\n        sessionReplayAllowed: false,\n        longTaskAllowed: true,\n        resourceAllowed: true,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n        expire: noop,\n        expireObservable: new Observable(),\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sessionSampleRate)) {\n        trackingType = \"0\" /* RumTrackingType.NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.sessionReplaySampleRate)) {\n        trackingType = \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    else {\n        trackingType = \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;\n    }\n    return {\n        trackingType: trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* RumTrackingType.NOT_TRACKED */ ||\n        trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||\n        trackingType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return (rumSessionType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */ ||\n        rumSessionType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { createFlushController, Batch, combine, createHttpRequest, isTelemetryReplicationAllowed, } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable, sessionExpireObservable) {\n    var batch = makeRumBatch(configuration, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        if (serverRumEvent.type === \"view\" /* RumEventType.VIEW */) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    telemetryEventObservable.subscribe(function (event) { return batch.add(event, isTelemetryReplicationAllowed(configuration)); });\n    return batch;\n}\nfunction makeRumBatch(configuration, reportError, pageExitObservable, sessionExpireObservable) {\n    var _a = createRumBatch(configuration.rumEndpointBuilder), primaryBatch = _a.batch, primaryFlushController = _a.flushController;\n    var replicaBatch;\n    var replica = configuration.replica;\n    if (replica !== undefined) {\n        replicaBatch = createRumBatch(replica.rumEndpointBuilder).batch;\n    }\n    function createRumBatch(endpointBuilder) {\n        var flushController = createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageExitObservable: pageExitObservable,\n            sessionExpireObservable: sessionExpireObservable,\n        });\n        var batch = new Batch(createHttpRequest(endpointBuilder, configuration.batchBytesLimit, reportError), flushController, configuration.messageBytesLimit);\n        return {\n            batch: batch,\n            flushController: flushController,\n        };\n    }\n    function withReplicaApplicationId(message) {\n        return combine(message, { application: { id: replica.applicationId } });\n    }\n    return {\n        flushObservable: primaryFlushController.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(withReplicaApplicationId(message));\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(withReplicaApplicationId(message), key);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startRumBatch.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, ValueHistory } from '@datadog/browser-core';\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\nexport var URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, locationChangeObservable, location) {\n    var urlContextHistory = new ValueHistory(URL_CONTEXT_TIME_OUT_DELAY);\n    var previousViewUrl;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var viewUrl = location.href;\n        urlContextHistory.add(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    var locationChangeSubscription = locationChangeObservable.subscribe(function (_a) {\n        var newLocation = _a.newLocation;\n        var current = urlContextHistory.find();\n        if (current) {\n            var changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            url: url,\n            referrer: referrer,\n        };\n    }\n    return {\n        findUrl: function (startTime) { return urlContextHistory.find(startTime); },\n        stop: function () {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { addEventListener, instrumentMethodAndCallOriginal, Observable, shallowClone, } from '@datadog/browser-core';\nexport function createLocationChangeObservable(location) {\n    var currentLocation = shallowClone(location);\n    var observable = new Observable(function () {\n        var stopHistoryTracking = trackHistory(onLocationChange).stop;\n        var stopHashTracking = trackHash(onLocationChange).stop;\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n    function onLocationChange() {\n        if (currentLocation.href === location.href) {\n            return;\n        }\n        var newLocation = shallowClone(location);\n        observable.notify({\n            newLocation: newLocation,\n            oldLocation: currentLocation,\n        });\n        currentLocation = newLocation;\n    }\n    return observable;\n}\nfunction trackHistory(onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethodAndCallOriginal(history, 'pushState', {\n        after: onHistoryChange,\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethodAndCallOriginal(history, 'replaceState', {\n        after: onHistoryChange,\n    }).stop;\n    var removeListener = addEventListener(window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(onHashChange) {\n    return addEventListener(window, \"hashchange\" /* DOM_EVENT.HASH_CHANGE */, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { warnIfCustomerDataLimitReached, throttle, jsonStringify, computeBytesCount, noop, isExperimentalFeatureEnabled, SESSION_TIME_OUT_DELAY, ValueHistory, ExperimentalFeature, } from '@datadog/browser-core';\nexport var FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(lifeCycle, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.FEATURE_FLAGS)) {\n        return {\n            findFeatureFlagEvaluations: function () { return undefined; },\n            getFeatureFlagBytesCount: function () { return 0; },\n            addFeatureFlagEvaluation: noop,\n            stop: noop,\n        };\n    }\n    var featureFlagContexts = new ValueHistory(FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY);\n    var bytesCountCache = 0;\n    var alreadyWarned = false;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        bytesCountCache = 0;\n    });\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call addFeatureFlagEvaluation API synchronously multiple times in a row\n    var _a = throttle(function (context) {\n        bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n        if (!alreadyWarned) {\n            alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, \"feature flag evaluation\" /* CustomerDataType.FeatureFlag */);\n        }\n    }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a.throttled, cancelPendingComputation = _a.cancel;\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        getFeatureFlagBytesCount: function () {\n            var currentContext = featureFlagContexts.find();\n            if (!currentContext) {\n                return 0;\n            }\n            return bytesCountCache;\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n                computeBytesCountThrottled(currentContext);\n            }\n        },\n        stop: cancelPendingComputation,\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { isEmptyObject, includes, performDraw, ONE_SECOND, addTelemetryDebug, setInterval } from '@datadog/browser-core';\nexport var MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nvar currentPeriodMeasures;\nvar currentBatchMeasures;\nvar batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batchFlushObservable) {\n    var customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate);\n    if (!customerDataTelemetryEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    initCurrentBatchMeasures();\n    // We measure the data of every view updates even if there could only be one per batch due to the upsert\n    // It means that contexts bytes count sums can be higher than it really is\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, !isEmptyObject(globalContextManager.get()) ? globalContextManager.getBytesCount() : 0);\n        updateMeasure(currentBatchMeasures.userContextBytes, !isEmptyObject(userContextManager.get()) ? userContextManager.getBytesCount() : 0);\n        var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations();\n        var hasFeatureFlagContext = includes([\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */], event.type) &&\n            featureFlagContext &&\n            !isEmptyObject(featureFlagContext);\n        updateMeasure(currentBatchMeasures.featureFlagBytes, hasFeatureFlagContext ? featureFlagContexts.getFeatureFlagBytesCount() : 0);\n    });\n    batchFlushObservable.subscribe(function (_a) {\n        var bytesCount = _a.bytesCount, messagesCount = _a.messagesCount;\n        // Don't measure batch that only contains telemetry events to avoid batch sending loop\n        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n        if (!batchHasRumEvent) {\n            return;\n        }\n        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);\n        mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes);\n        mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes);\n        mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes);\n        initCurrentBatchMeasures();\n    });\n    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    addTelemetryDebug('Customer data measures', currentPeriodMeasures);\n    initCurrentPeriodMeasures();\n}\nfunction createMeasure() {\n    return { min: Infinity, max: 0, sum: 0 };\n}\nfunction updateMeasure(measure, value) {\n    measure.sum += value;\n    measure.min = Math.min(measure.min, value);\n    measure.max = Math.max(measure.max, value);\n}\nfunction mergeMeasure(target, source) {\n    target.sum += source.sum;\n    target.min = Math.min(target.min, source.min);\n    target.max = Math.max(target.max, source.max);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\nfunction initCurrentBatchMeasures() {\n    batchHasRumEvent = false;\n    currentBatchMeasures = {\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { elapsed, ValueHistory, SESSION_TIME_OUT_DELAY, toServerDuration, addEventListeners, relativeNow, } from '@datadog/browser-core';\n// Arbitrary value to cap number of element for memory consumption in the browser\nexport var MAX_PAGE_STATE_ENTRIES = 4000;\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport var MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500;\nexport var PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startPageStateHistory(maxPageStateEntriesSelectable) {\n    if (maxPageStateEntriesSelectable === void 0) { maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE; }\n    var pageStateHistory = new ValueHistory(PAGE_STATE_CONTEXT_TIME_OUT_DELAY, MAX_PAGE_STATE_ENTRIES);\n    var currentPageState;\n    addPageState(getPageState(), relativeNow());\n    var stopEventListeners = addEventListeners(window, [\n        \"pageshow\" /* DOM_EVENT.PAGE_SHOW */,\n        \"focus\" /* DOM_EVENT.FOCUS */,\n        \"blur\" /* DOM_EVENT.BLUR */,\n        \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */,\n        \"resume\" /* DOM_EVENT.RESUME */,\n        \"freeze\" /* DOM_EVENT.FREEZE */,\n        \"pagehide\" /* DOM_EVENT.PAGE_HIDE */,\n    ], function (event) {\n        // Only get events fired by the browser to avoid false currentPageState changes done with custom events\n        // cf: developer extension auto flush: https://github.com/DataDog/browser-sdk/blob/2f72bf05a672794c9e33965351964382a94c72ba/developer-extension/src/panel/flushEvents.ts#L11-L12\n        if (event.isTrusted) {\n            addPageState(computePageState(event), event.timeStamp);\n        }\n    }, { capture: true }).stop;\n    function addPageState(nextPageState, startTime) {\n        if (startTime === void 0) { startTime = relativeNow(); }\n        if (nextPageState === currentPageState) {\n            return;\n        }\n        currentPageState = nextPageState;\n        pageStateHistory.closeActive(startTime);\n        pageStateHistory.add({ state: currentPageState, startTime: startTime }, startTime);\n    }\n    return {\n        findAll: function (eventStartTime, duration) {\n            var pageStateEntries = pageStateHistory.findAll(eventStartTime, duration);\n            if (pageStateEntries.length === 0) {\n                return;\n            }\n            var pageStateServerEntries = [];\n            // limit the number of entries to return\n            var limit = Math.max(0, pageStateEntries.length - maxPageStateEntriesSelectable);\n            // loop page state entries backward to return the selected ones in desc order\n            for (var index = pageStateEntries.length - 1; index >= limit; index--) {\n                var pageState = pageStateEntries[index];\n                // compute the start time relative to the event start time (ex: to be relative to the view start time)\n                var relativeStartTime = elapsed(eventStartTime, pageState.startTime);\n                pageStateServerEntries.push({\n                    state: pageState.state,\n                    start: toServerDuration(relativeStartTime),\n                });\n            }\n            return pageStateServerEntries;\n        },\n        addPageState: addPageState,\n        stop: function () {\n            stopEventListeners();\n            pageStateHistory.stop();\n        },\n    };\n}\nfunction computePageState(event) {\n    if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */) {\n        return event.persisted ? \"frozen\" /* PageState.FROZEN */ : \"terminated\" /* PageState.TERMINATED */;\n    }\n    return getPageState();\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* PageState.HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* PageState.ACTIVE */;\n    }\n    return \"passive\" /* PageState.PASSIVE */;\n}\n//# sourceMappingURL=pageStateHistory.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, _a) {\n    var session = _a.session, viewContext = _a.viewContext, errorType = _a.errorType;\n    var sessionId = session ? session.id : 'no-session-id';\n    var parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(\"error-type=\".concat(errorType));\n    }\n    if (viewContext) {\n        parameters.push(\"seed=\".concat(viewContext.id));\n        parameters.push(\"from=\".concat(viewContext.startClocks.timeStamp));\n    }\n    var origin = getDatadogSiteUrl(configuration);\n    var path = \"/rum/replay/sessions/\".concat(sessionId);\n    return \"\".concat(origin).concat(path, \"?\").concat(parameters.join('&'));\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    var site = rumConfiguration.site;\n    var subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return \"https://\".concat(subdomain ? \"\".concat(subdomain, \".\") : '').concat(site);\n}\nfunction getSiteDefaultSubdomain(configuration) {\n    switch (configuration.site) {\n        case INTAKE_SITE_US1:\n        case INTAKE_SITE_EU1:\n            return 'app';\n        case INTAKE_SITE_STAGING:\n            return 'dd';\n        default:\n            return undefined;\n    }\n}\n//# sourceMappingURL=getSessionReplayUrl.js.map","export var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport var NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport var IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport var MouseInteractionType = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport var MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport var NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n};\nexport var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_ALLOW = 'dd-privacy-allow';\nexport var PRIVACY_CLASS_MASK = 'dd-privacy-mask';\nexport var PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input';\nexport var PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\n//# sourceMappingURL=constants.js.map","import { isElementNode, getParentNode, isTextNode } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_CLASS_ALLOW, PRIVACY_CLASS_MASK, PRIVACY_CLASS_MASK_USER_INPUT, PRIVACY_CLASS_HIDDEN, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, } from '../../constants';\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100000;\nvar TEXT_MASKING_CHAR = 'x';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel) {\n    var parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel) : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElementNode(node)) {\n        return;\n    }\n    var privAttr = node.getAttribute(PRIVACY_ATTR_NAME);\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        var inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        var autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_ALLOW)) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    var element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport var censorText = function (text) { return text.replace(/\\S/g, TEXT_MASKING_CHAR); };\nexport function getTextContent(textNode, ignoreWhiteSpace, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var isStyle = parentTagName === 'STYLE' ? true : undefined;\n    var isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel) &&\n        // Style tags are `overruled` (Use `hide` to enforce privacy)\n        !isStyle) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        var relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\n//# sourceMappingURL=privacy.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nimport { CENSORED_STRING_MARK } from '../../../constants';\nimport { shouldMaskNode } from '../privacy';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var current = node;\n    while (current) {\n        if (!hasSerializedNode(current) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\nexport var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(quote, \")\");\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_) {\n        return url;\n    }\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    var processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\n//# sourceMappingURL=serializationUtils.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { startsWith } from '@datadog/browser-core';\nimport { STABLE_ATTRIBUTES } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK } from '../../../constants';\nimport { MAX_ATTRIBUTE_VALUE_CHAR_LENGTH } from '../privacy';\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' || tagName === 'SOURCE') {\n            if (attributeName === 'src' || attributeName === 'srcset') {\n                return CENSORED_IMG_MARK;\n            }\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && startsWith(attributeName, 'data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n        return 'data:truncated';\n    }\n    return attributeValue;\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel } from '../../../constants';\nimport { shouldMaskNode } from '../privacy';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    var _a;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName, options.configuration);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        var formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' &&\n        element.sheet &&\n        // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n        !(element.innerText || element.textContent || '').trim().length) {\n        var cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    var inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            delete safeAttrs.checked;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        var mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element only for full snapshot\n     */\n    var scrollTop;\n    var scrollLeft;\n    var serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\nfunction getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    var rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    var styleSheetCssText = Array.from(rules, getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleString(rule) {\n    return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { isNodeShadowRoot, isNodeShadowHost } from '@datadog/browser-rum-core';\nimport { assign } from '@datadog/browser-core';\nimport { NodeType } from '../../../types';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN } from '../../../constants';\nimport { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent } from '../privacy';\nimport { getSerializedNodeId, getValidTagName, setSerializedNodeId } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\nexport function serializeNodeWithId(node, options) {\n    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nvar _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    node.childNodes.forEach(function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    var childNodes = [];\n    if (element.childNodes.length) {\n        childNodes = serializeChildNodes(element, options);\n    }\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: childNodes,\n        isShadowRoot: isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nfunction serializeElementNode(element, options) {\n    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: NodeType.Element,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    var childNodes = [];\n    if (element.childNodes.length) {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    if (isNodeShadowHost(element)) {\n        var shadowRoot = serializeNodeWithId(element.shadowRoot, options);\n        if (shadowRoot !== null) {\n            childNodes.push(shadowRoot);\n        }\n    }\n    return {\n        type: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { serializeNodeWithId } from './serializeNode';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: configuration,\n    });\n}\n//# sourceMappingURL=serializeDocument.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nvar TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visualViewport = window.visualViewport;\n    var normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport var getVisualViewport = function (visualViewport) { return ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n}); };\nexport 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=viewports.js.map","import { addEventListeners, addTelemetryDebug, throttle } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function initMoveObserver(cb) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nexport function tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\n        return undefined;\n    }\n    return { x: x, y: y };\n}\n//# sourceMappingURL=moveObserver.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { getScrollX, getScrollY } from '../viewports';\nimport { NodePrivacyLevel } from '../../../constants';\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nexport function initScrollObserver(cb, defaultPrivacyLevel, elementsScrollPositions) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        cb({\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        });\n    }, SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\n//# sourceMappingURL=scrollObserver.js.map","var _a;\nimport { assign, addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './moveObserver';\nvar eventTypeToMouseInteraction = (_a = {},\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    _a[\"pointerup\" /* DOM_EVENT.POINTER_UP */] = MouseInteractionType.MouseUp,\n    _a[\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */] = MouseInteractionType.MouseDown,\n    _a[\"click\" /* DOM_EVENT.CLICK */] = MouseInteractionType.Click,\n    _a[\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */] = MouseInteractionType.ContextMenu,\n    _a[\"dblclick\" /* DOM_EVENT.DBL_CLICK */] = MouseInteractionType.DblClick,\n    _a[\"focus\" /* DOM_EVENT.FOCUS */] = MouseInteractionType.Focus,\n    _a[\"blur\" /* DOM_EVENT.BLUR */] = MouseInteractionType.Blur,\n    _a[\"touchstart\" /* DOM_EVENT.TOUCH_START */] = MouseInteractionType.TouchStart,\n    _a[\"touchend\" /* DOM_EVENT.TOUCH_END */] = MouseInteractionType.TouchEnd,\n    _a);\nexport function initMouseInteractionObserver(cb, defaultPrivacyLevel, recordIds) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: recordIds.getIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\n        cb(record);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\n//# sourceMappingURL=mouseInteractionObserver.js.map","import { instrumentSetter, assign, addEventListeners, forEach } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel, shouldMaskNode } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initInputObserver(cb, defaultPrivacyLevel, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.domEvents, domEvents = _c === void 0 ? [\"input\" /* DOM_EVENT.INPUT */, \"change\" /* DOM_EVENT.CHANGE */] : _c, _d = _b.target, target = _d === void 0 ? document : _d;\n    var lastInputStateMap = new WeakMap();\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(name, \"\\\"]\")), function (el) {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        var lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            cb(assign({\n                id: getSerializedNodeId(target),\n            }, inputState));\n        }\n    }\n    var stopEventListeners = addEventListeners(target, domEvents, 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 instrumentationStoppers = [\n        instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n    ];\n    return function () {\n        instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        stopEventListeners();\n    };\n}\n//# sourceMappingURL=inputObserver.js.map","import { instrumentMethodAndCallOriginal } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initStyleSheetObserver(cb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n            before: function (rule, index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, adds: [{ rule: rule, index: index }] }); });\n            },\n        }),\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n            before: function (index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, removes: [{ index: index }] }); });\n            },\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethodAndCallOriginal(cls.prototype, 'insertRule', {\n            before: function (rule, index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index || 0);\n                        cb({ id: id, adds: [{ rule: rule, index: path }] });\n                    }\n                });\n            },\n        }), instrumentMethodAndCallOriginal(cls.prototype, 'deleteRule', {\n            before: function (index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index);\n                        cb({ id: id, removes: [{ index: path }] });\n                    }\n                });\n            },\n        }));\n    }\n    return function () { return instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); }); };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=styleSheetObserver.js.map","import { throttle, addEventListeners, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { getVisualViewport } from '../viewports';\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function initViewportResizeObserver(cb) {\n    return initViewportObservable().subscribe(cb).unsubscribe;\n}\nexport function initVisualViewportResizeObserver(cb) {\n    var visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return noop;\n    }\n    var _a = throttle(function () {\n        cb(getVisualViewport(visualViewport));\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\n//# sourceMappingURL=viewportResizeObserver.js.map","import { noop, monitor } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar MUTATION_PROCESS_MAX_DELAY = 100;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n        },\n    };\n}\n/**\n * Use 'requestIdleCallback' when available: it will throttle the mutation processing if the\n * browser is busy rendering frames (ex: when frames are below 60fps). When not available, the\n * fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any\n * browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes efficiently.\n *\n * Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n */\nfunction requestIdleCallback(callback, opts) {\n    if (window.requestIdleCallback && window.cancelIdleCallback) {\n        var id_1 = window.requestIdleCallback(monitor(callback), opts);\n        return function () { return window.cancelIdleCallback(id_1); };\n    }\n    var id = window.requestAnimationFrame(monitor(callback));\n    return function () { return window.cancelAnimationFrame(id); };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { getChildNodes, isNodeShadowHost, getMutationObserverConstructor, getParentNode, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getNodePrivacyLevel, getTextContent } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function initMutationObserver(mutationCallback, configuration, shadowRootsController, target) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController, target);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController, target) {\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (removedNode) {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    var filteredMutations = mutations.filter(function (mutation) {\n        return target.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), configuration);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback({\n        adds: adds,\n        removes: removes,\n        texts: texts,\n        attributes: attributes,\n    });\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    var sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    var removedNodeMutations = [];\n    removedNodes.forEach(function (parent, node) {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, configuration) {\n    var _a;\n    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (mutation) {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, configuration) {\n    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes === null || handledAttributes === void 0 ? void 0 : handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    var emittedMutations = new Map();\n    for (var _i = 0, filteredMutations_2 = filteredMutations; _i < filteredMutations_2.length; _i++) {\n        var mutation = filteredMutations_2[_i];\n        var uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        var privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        var emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort(function (a, b) {\n        var position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    getChildNodes(removedNode).forEach(function (child) { return traverseRemovedShadowDom(child, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=mutationObserver.js.map","import { initMoveObserver } from './moveObserver';\nimport { initScrollObserver } from './scrollObserver';\nimport { initMouseInteractionObserver } from './mouseInteractionObserver';\nimport { initInputObserver } from './inputObserver';\nimport { initStyleSheetObserver } from './styleSheetObserver';\nimport { initMediaInteractionObserver } from './mediaInteractionObserver';\nimport { initFrustrationObserver } from './frustrationObserver';\nimport { initViewportResizeObserver, initVisualViewportResizeObserver } from './viewportResizeObserver';\nimport { initMutationObserver } from './mutationObserver';\nimport { initFocusObserver } from './focusObserver';\nimport { initRecordIds } from './recordIds';\nexport function initObservers(o) {\n    var recordIds = initRecordIds();\n    var mutationHandler = initMutationObserver(o.mutationCb, o.configuration, o.shadowRootsController, document);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.configuration.defaultPrivacyLevel, recordIds);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.configuration.defaultPrivacyLevel, o.elementsScrollPositions);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.configuration.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.configuration.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    var frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb, recordIds);\n    return {\n        flush: function () {\n            mutationHandler.flush();\n        },\n        stop: function () {\n            mutationHandler.stop();\n            mousemoveHandler();\n            mouseInteractionHandler();\n            scrollHandler();\n            viewportResizeHandler();\n            inputHandler();\n            mediaInteractionHandler();\n            styleSheetObserver();\n            focusHandler();\n            visualViewportResizeHandler();\n            frustrationHandler();\n        },\n    };\n}\n//# sourceMappingURL=observers.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb({\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* DOM_EVENT.PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        });\n    };\n    return addEventListeners(document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], handler, { capture: true, passive: true }).stop;\n}\n//# sourceMappingURL=mediaInteractionObserver.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function initFocusObserver(focusCb) {\n    return addEventListeners(window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\n//# sourceMappingURL=focusObserver.js.map","export function initRecordIds() {\n    var recordIds = new WeakMap();\n    var nextId = 1;\n    return {\n        getIdForEvent: function (event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { RecordType } from '../../../types';\nexport function initFrustrationObserver(lifeCycle, frustrationCb, recordIds) {\n    return lifeCycle.subscribe(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (data) {\n        var _a, _b, _c;\n        if (data.rawRumEvent.type === \"action\" /* RumEventType.ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* ActionType.CLICK */ &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            ((_c = data.domainContext.events) === null || _c === void 0 ? void 0 : _c.length)) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map(function (e) { return recordIds.getIdForEvent(e); }),\n                },\n            });\n        }\n    }).unsubscribe;\n}\n//# sourceMappingURL=frustrationObserver.js.map","import { initInputObserver, initMutationObserver } from './observers';\nexport var initShadowRootsController = function (configuration, _a) {\n    var mutationCb = _a.mutationCb, inputCb = _a.inputCb;\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            var _a = initMutationObserver(mutationCb, configuration, shadowRootsController, shadowRoot), stopMutationObserver = _a.stop, flush = _a.flush;\n            // the change event no do bubble up across the shadow root, we have to listen on the shadow root\n            var stopInputObserver = initInputObserver(inputCb, configuration.defaultPrivacyLevel, {\n                target: shadowRoot,\n                domEvents: [\"change\" /* DOM_EVENT.CHANGE */],\n            });\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: flush,\n                stop: function () {\n                    stopMutationObserver();\n                    stopInputObserver();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { getViewportDimension } from '@datadog/browser-rum-core';\nimport { RecordType, IncrementalSource } from '../../types';\nimport { assembleIncrementalSnapshot } from './assembly';\nimport { serializeDocument } from './serialization';\nimport { initObservers } from './observers';\nimport { getVisualViewport, getScrollX, getScrollY } from './viewports';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nexport function record(options) {\n    var emit = options.emit;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var elementsScrollPositions = createElementsScrollPositions();\n    var mutationCb = function (mutation) {\n        emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, mutation));\n    };\n    var inputCb = function (s) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, s)); };\n    var shadowRootsController = initShadowRootsController(options.configuration, { mutationCb: mutationCb, inputCb: inputCb });\n    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        emit({\n            data: {\n                height: height,\n                href: window.location.href,\n                width: width,\n            },\n            type: RecordType.Meta,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, options.configuration, serializationContext),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp: timestamp,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var _a = initObservers({\n        lifeCycle: options.lifeCycle,\n        configuration: options.configuration,\n        elementsScrollPositions: elementsScrollPositions,\n        inputCb: inputCb,\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (mouseInteractionRecord) { return emit(mouseInteractionRecord); },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: mutationCb,\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        frustrationCb: function (frustrationRecord) { return emit(frustrationRecord); },\n        focusCb: function (data) {\n            return emit({\n                data: data,\n                type: RecordType.Focus,\n                timestamp: timeStampNow(),\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n                timestamp: timeStampNow(),\n            });\n        },\n        shadowRootsController: shadowRootsController,\n    }), stopObservers = _a.stop, flushMutationsFromObservers = _a.flush;\n    function flushMutations() {\n        shadowRootsController.flush();\n        flushMutationsFromObservers();\n    }\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            stopObservers();\n        },\n        takeSubsequentFullSnapshot: function (timestamp) {\n            flushMutations();\n            takeFullSnapshot(timestamp, {\n                shadowRootsController: shadowRootsController,\n                status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n                elementsScrollPositions: elementsScrollPositions,\n            });\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","export var MAX_STATS_HISTORY = 10;\nvar statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    var replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    if (statsPerView.keys) {\n        statsPerView.delete(statsPerView.keys().next().value);\n    }\n    else {\n        // IE11 doesn't support map.keys\n        var isFirst_1 = true;\n        statsPerView.forEach(function (_value, key) {\n            if (isFirst_1) {\n                statsPerView.delete(key);\n                isFirst_1 = false;\n            }\n        });\n    }\n}\n//# sourceMappingURL=replayStats.js.map","import { addTelemetryDebug, assign, sendToExtension, addEventListener } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar nextId = 0;\nvar Segment = /** @class */ (function () {\n    function Segment(worker, context, creationReason, initialRecord, onWrote, onFlushed) {\n        var _this = this;\n        this.worker = worker;\n        this.id = nextId++;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: initialRecord.timestamp,\n            end: initialRecord.timestamp,\n            creation_reason: creationReason,\n            records_count: 1,\n            has_full_snapshot: initialRecord.type === RecordType.FullSnapshot,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n            source: 'browser',\n        }, context);\n        replayStats.addSegment(viewId);\n        replayStats.addRecord(viewId);\n        var removeMessageListener = addEventListener(worker, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored' || data.type === 'initialized') {\n                return;\n            }\n            if (data.id === _this.id) {\n                replayStats.addWroteData(viewId, data.additionalBytesCount);\n                if (data.type === 'flushed') {\n                    onFlushed(data.result, data.rawBytesCount);\n                    removeMessageListener();\n                }\n                else {\n                    onWrote(data.compressedBytesCount);\n                }\n            }\n            else if (data.id > _this.id) {\n                // Messages should be received in the same order as they are sent, so if we receive a\n                // message with an id superior to this Segment instance id, we know that another, more\n                // recent Segment instance is being used.\n                //\n                // In theory, a \"flush\" response should have been received at this point, so the listener\n                // should already have been removed. But if something goes wrong and we didn't receive a\n                // \"flush\" response, remove the listener to avoid any leak, and send a monitor message to\n                // help investigate the issue.\n                removeMessageListener();\n                addTelemetryDebug(\"Segment did not receive a 'flush' response before being replaced.\");\n            }\n        }).stop;\n        sendToExtension('record', { record: initialRecord, segment: this.metadata });\n        this.worker.postMessage({ data: \"{\\\"records\\\":[\".concat(JSON.stringify(initialRecord)), id: this.id, action: 'write' });\n    }\n    Segment.prototype.addRecord = function (record) {\n        var _a;\n        this.metadata.start = Math.min(this.metadata.start, record.timestamp);\n        this.metadata.end = Math.max(this.metadata.end, record.timestamp);\n        this.metadata.records_count += 1;\n        replayStats.addRecord(this.metadata.view.id);\n        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        sendToExtension('record', { record: record, segment: this.metadata });\n        this.worker.postMessage({ data: \",\".concat(JSON.stringify(record)), id: this.id, action: 'write' });\n    };\n    Segment.prototype.flush = function (reason) {\n        this.worker.postMessage({\n            data: \"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"),\n            id: this.id,\n            action: 'flush',\n        });\n        this.flushReason = reason;\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","var workerURL;\nexport function createDeflateWorker() {\n    // Lazily compute the worker URL to allow importing the SDK in NodeJS\n    if (!workerURL) {\n        workerURL = URL.createObjectURL(new Blob([\"(\".concat(workerCodeFn, \")(self)\")]));\n    }\n    return new Worker(workerURL);\n}\nfunction workerCodeFn() {\n    monitor(function () {\n        var _a = makePakoDeflate(), Deflate = _a.Deflate, constants = _a.constants, string2buf = _a.string2buf;\n        var deflate = new Deflate();\n        var rawBytesCount = 0;\n        self.addEventListener('message', monitor(function (event) {\n            var data = event.data;\n            switch (data.action) {\n                case 'init':\n                    self.postMessage({\n                        type: 'initialized',\n                    });\n                    break;\n                case 'write': {\n                    var additionalBytesCount = pushData(data.data);\n                    self.postMessage({\n                        type: 'wrote',\n                        id: data.id,\n                        compressedBytesCount: deflate.chunks.reduce(function (total, chunk) { return total + chunk.length; }, 0),\n                        additionalBytesCount: additionalBytesCount,\n                    });\n                    break;\n                }\n                case 'flush': {\n                    var additionalBytesCount = data.data ? pushData(data.data) : 0;\n                    deflate.push('', constants.Z_FINISH);\n                    self.postMessage({\n                        type: 'flushed',\n                        id: data.id,\n                        result: deflate.result,\n                        additionalBytesCount: additionalBytesCount,\n                        rawBytesCount: rawBytesCount,\n                    });\n                    deflate = new Deflate();\n                    rawBytesCount = 0;\n                    break;\n                }\n            }\n        }));\n        function pushData(data) {\n            // TextEncoder is not supported on old browser version like Edge 18, therefore we use string2buf\n            var binaryData = string2buf(data);\n            deflate.push(binaryData, constants.Z_SYNC_FLUSH);\n            rawBytesCount += binaryData.length;\n            return binaryData.length;\n        }\n    })();\n    function monitor(fn) {\n        return function () {\n            try {\n                return fn.apply(this, arguments);\n            }\n            catch (e) {\n                try {\n                    self.postMessage({\n                        type: 'errored',\n                        error: e,\n                    });\n                }\n                catch (_) {\n                    // DATA_CLONE_ERR, cf https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n                    self.postMessage({\n                        type: 'errored',\n                        error: \"\".concat(e),\n                    });\n                }\n            }\n        };\n    }\n    // https://github.com/nodeca/pako/blob/034669ba0f1a4c0590e45f7c2820128200f972b3/dist/pako_deflate.es5.js\n    function makePakoDeflate() {\n        /* eslint-disable camelcase, no-bitwise */\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        // const Z_FILTERED          = 1;\n        // const Z_HUFFMAN_ONLY      = 2;\n        // const Z_RLE               = 3;\n        var Z_FIXED = 4; // const Z_DEFAULT_STRATEGY  = 0;\n        /* Possible values of the data_type field (though see inflate()) */\n        var Z_BINARY = 0;\n        var Z_TEXT = 1; // const Z_ASCII             = 1; // = Z_TEXT\n        var Z_UNKNOWN = 2;\n        /* ============================================================================ */\n        function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        } // From zutil.h\n        var STORED_BLOCK = 0;\n        var STATIC_TREES = 1;\n        var DYN_TREES = 2;\n        /* The three kinds of block type */\n        var MIN_MATCH = 3;\n        var MAX_MATCH = 258;\n        /* The minimum and maximum match lengths */\n        // From deflate.h\n        /* ===========================================================================\n         * Internal compression state.\n         */\n        var LENGTH_CODES = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES = LITERALS + 1 + LENGTH_CODES;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES = 30;\n        /* number of distance codes */\n        var BL_CODES = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE = 2 * L_CODES + 1;\n        /* maximum heap size */\n        var MAX_BITS = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var Buf_size = 16;\n        /* size of bit buffer in bi_buf */\n        /* ===========================================================================\n         * Constants\n         */\n        var MAX_BL_BITS = 7;\n        /* Bit length codes must not exceed MAX_BL_BITS bits */\n        var END_BLOCK = 256;\n        /* end of block literal code */\n        var REP_3_6 = 16;\n        /* repeat previous bit length 3-6 times (2 bits of repeat count) */\n        var REPZ_3_10 = 17;\n        /* repeat a zero length 3-10 times  (3 bits of repeat count) */\n        var REPZ_11_138 = 18;\n        /* repeat a zero length 11-138 times  (7 bits of repeat count) */\n        var extra_lbits = \n        /* extra bits for each length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);\n        var extra_dbits = \n        /* extra bits for each distance code */\n        new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);\n        var extra_blbits = \n        /* extra bits for each bit length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);\n        var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n        /* eslint-enable comma-spacing,array-bracket-spacing */\n        /* The lengths of the bit length codes are sent in order of decreasing\n         * probability, to avoid transmitting the lengths for unused bit length codes.\n         */\n        /* ===========================================================================\n         * Local data. These are initialized only once.\n         */\n        // We pre-fill arrays with 0 to avoid uninitialized gaps\n        var DIST_CODE_LEN = 512;\n        /* see definition of array dist_code below */\n        // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\n        var static_ltree = new Array((L_CODES + 2) * 2);\n        zero(static_ltree);\n        /* The static literal tree. Since the bit lengths are imposed, there is no\n         * need for the L_CODES extra codes used during heap construction. However\n         * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n         * below).\n         */\n        var static_dtree = new Array(D_CODES * 2);\n        zero(static_dtree);\n        /* The static distance tree. (Actually a trivial tree since all codes use\n         * 5 bits.)\n         */\n        var _dist_code = new Array(DIST_CODE_LEN);\n        zero(_dist_code);\n        /* Distance codes. The first 256 values correspond to the distances\n         * 3 .. 258, the last 256 values correspond to the top 8 bits of\n         * the 15 bit distances.\n         */\n        var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);\n        zero(_length_code);\n        /* length code for each normalized match length (0 == MIN_MATCH) */\n        var base_length = new Array(LENGTH_CODES);\n        zero(base_length);\n        /* First normalized length for each code (0 = MIN_MATCH) */\n        var base_dist = new Array(D_CODES);\n        zero(base_dist);\n        /* First normalized distance for each code (0 = distance of 1) */\n        function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n            this.static_tree = static_tree;\n            /* static tree or NULL */\n            this.extra_bits = extra_bits;\n            /* extra bits for each code or NULL */\n            this.extra_base = extra_base;\n            /* base index for extra_bits */\n            this.elems = elems;\n            /* max number of elements in the tree */\n            this.max_length = max_length;\n            /* max bit length for the codes */\n            // show if `static_tree` has data or dummy - needed for monomorphic objects\n            this.has_stree = static_tree && static_tree.length;\n        }\n        var static_l_desc;\n        var static_d_desc;\n        var static_bl_desc;\n        function TreeDesc(dyn_tree, stat_desc) {\n            this.dyn_tree = dyn_tree;\n            /* the dynamic tree */\n            this.max_code = 0;\n            /* largest code with non zero frequency */\n            this.stat_desc = stat_desc;\n            /* the corresponding static tree */\n        }\n        var d_code = function d_code(dist) {\n            return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n        };\n        /* ===========================================================================\n         * Output a short LSB first on the stream.\n         * IN assertion: there is enough room in pendingBuf.\n         */\n        var put_short = function put_short(s, w) {\n            //    put_byte(s, (uch)((w) & 0xff));\n            //    put_byte(s, (uch)((ush)(w) >> 8));\n            s.pending_buf[s.pending++] = w & 0xff;\n            s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n        };\n        /* ===========================================================================\n         * Send a value on a given number of bits.\n         * IN assertion: length <= 16 and value fits in length bits.\n         */\n        var send_bits = function send_bits(s, value, length) {\n            if (s.bi_valid > Buf_size - length) {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                put_short(s, s.bi_buf);\n                s.bi_buf = value >> (Buf_size - s.bi_valid);\n                s.bi_valid += length - Buf_size;\n            }\n            else {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                s.bi_valid += length;\n            }\n        };\n        var send_code = function send_code(s, c, tree) {\n            send_bits(s, tree[c * 2], \n            /* .Code */\n            tree[c * 2 + 1]\n            /* .Len */\n            );\n        };\n        /* ===========================================================================\n         * Reverse the first len bits of a code, using straightforward code (a faster\n         * method would use a table)\n         * IN assertion: 1 <= len <= 15\n         */\n        var bi_reverse = function bi_reverse(code, len) {\n            var res = 0;\n            do {\n                res |= code & 1;\n                code >>>= 1;\n                res <<= 1;\n            } while (--len > 0);\n            return res >>> 1;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer, keeping at most 7 bits in it.\n         */\n        var bi_flush = function bi_flush(s) {\n            if (s.bi_valid === 16) {\n                put_short(s, s.bi_buf);\n                s.bi_buf = 0;\n                s.bi_valid = 0;\n            }\n            else if (s.bi_valid >= 8) {\n                s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n                s.bi_buf >>= 8;\n                s.bi_valid -= 8;\n            }\n        };\n        /* ===========================================================================\n         * Compute the optimal bit lengths for a tree and update the total bit length\n         * for the current block.\n         * IN assertion: the fields freq and dad are set, heap[heap_max] and\n         *    above are the tree nodes sorted by increasing frequency.\n         * OUT assertions: the field len is set to the optimal bit length, the\n         *     array bl_count contains the frequencies for each bit length.\n         *     The length opt_len is updated; static_len is also updated if stree is\n         *     not null.\n         */\n        var gen_bitlen = function gen_bitlen(s, desc //    deflate_state *s; //    tree_desc *desc;    /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var max_code = desc.max_code;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var extra = desc.stat_desc.extra_bits;\n            var base = desc.stat_desc.extra_base;\n            var max_length = desc.stat_desc.max_length;\n            var h;\n            /* heap index */\n            var n;\n            var m;\n            /* iterate over the tree elements */\n            var bits;\n            /* bit length */\n            var xbits;\n            /* extra bits */\n            var f;\n            /* frequency */\n            var overflow = 0;\n            /* number of elements with bit length too large */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                s.bl_count[bits] = 0;\n            }\n            /* In a first pass, compute the optimal bit lengths (which may\n             * overflow in the case of the bit length tree).\n             */\n            tree[s.heap[s.heap_max] * 2 + 1] =\n                /* .Len */\n                0;\n            /* root of the heap */\n            for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n                n = s.heap[h];\n                bits =\n                    tree[tree[n * 2 + 1] *\n                        /* .Dad */\n                        2 +\n                        1] +\n                        /* .Len */\n                        1;\n                if (bits > max_length) {\n                    bits = max_length;\n                    overflow++;\n                }\n                tree[n * 2 + 1] =\n                    /* .Len */\n                    bits;\n                /* We overwrite tree[n].Dad which is no longer needed */\n                if (n > max_code) {\n                    continue;\n                }\n                /* not a leaf node */\n                s.bl_count[bits]++;\n                xbits = 0;\n                if (n >= base) {\n                    xbits = extra[n - base];\n                }\n                f = tree[n * 2];\n                /* .Freq */\n                s.opt_len += f * (bits + xbits);\n                if (has_stree) {\n                    s.static_len +=\n                        f *\n                            (stree[n * 2 + 1] +\n                                /* .Len */\n                                xbits);\n                }\n            }\n            if (overflow === 0) {\n                return;\n            } // Trace((stderr,\"\\nbit length overflow\\n\"));\n            /* This happens for example on obj2 and pic of the Calgary corpus */\n            /* Find the first bit length which could increase: */\n            do {\n                bits = max_length - 1;\n                while (s.bl_count[bits] === 0) {\n                    bits--;\n                }\n                s.bl_count[bits]--;\n                /* move one leaf down the tree */\n                s.bl_count[bits + 1] += 2;\n                /* move one overflow item as its brother */\n                s.bl_count[max_length]--;\n                /* The brother of the overflow item also moves one step up,\n                 * but this does not affect bl_count[max_length]\n                 */\n                overflow -= 2;\n            } while (overflow > 0);\n            /* Now recompute all bit lengths, scanning in increasing frequency.\n             * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n             * lengths instead of fixing only the wrong ones. This idea is taken\n             * from 'ar' written by Haruhiko Okumura.)\n             */\n            for (bits = max_length; bits !== 0; bits--) {\n                n = s.bl_count[bits];\n                while (n !== 0) {\n                    m = s.heap[--h];\n                    if (m > max_code) {\n                        continue;\n                    }\n                    if (tree[m * 2 + 1] !==\n                        /* .Len */\n                        bits) {\n                        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n                        s.opt_len +=\n                            (bits - tree[m * 2 + 1]) *\n                                /* .Len */\n                                tree[m * 2];\n                        /* .Freq */\n                        tree[m * 2 + 1] =\n                            /* .Len */\n                            bits;\n                    }\n                    n--;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Generate the codes for a given tree and bit counts (which need not be\n         * optimal).\n         * IN assertion: the array bl_count contains the bit length statistics for\n         * the given tree and the field len is set for all tree elements.\n         * OUT assertion: the field code is set for all tree elements of non\n         *     zero code length.\n         */\n        var gen_codes = function gen_codes(tree, max_code, bl_count\n        //    ct_data *tree;             /* the tree to decorate */\n        //    int max_code;              /* largest code with non zero frequency */\n        //    ushf *bl_count;            /* number of codes at each bit length */\n        ) {\n            var next_code = new Array(MAX_BITS + 1);\n            /* next code value for each bit length */\n            var code = 0;\n            /* running code value */\n            var bits;\n            /* bit index */\n            var n;\n            /* code index */\n            /* The distribution counts are first used to generate the code values\n             * without bit reversal.\n             */\n            for (bits = 1; bits <= MAX_BITS; bits++) {\n                next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n            }\n            /* Check that the bit counts in bl_count are consistent. The last code\n             * must be all ones.\n             */\n            // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n            //        \"inconsistent bit counts\");\n            // Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n            for (n = 0; n <= max_code; n++) {\n                var len = tree[n * 2 + 1];\n                /* .Len */\n                if (len === 0) {\n                    continue;\n                }\n                /* Now reverse the bits */\n                tree[n * 2] =\n                    /* .Code */\n                    bi_reverse(next_code[len]++, len); // Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n                //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n            }\n        };\n        /* ===========================================================================\n         * Initialize the various 'constant' tables.\n         */\n        var tr_static_init = function tr_static_init() {\n            var n;\n            /* iterates over tree elements */\n            var bits;\n            /* bit counter */\n            var length;\n            /* length value */\n            var code;\n            /* code value */\n            var dist;\n            /* distance index */\n            var bl_count = new Array(MAX_BITS + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // do check in _tr_init()\n            // if (static_init_done) return;\n            /* For some embedded targets, global variables are not initialized: */\n            /* #ifdef NO_INIT_GLOBAL_POINTERS\n            static_l_desc.static_tree = static_ltree;\n            static_l_desc.extra_bits = extra_lbits;\n            static_d_desc.static_tree = static_dtree;\n            static_d_desc.extra_bits = extra_dbits;\n            static_bl_desc.extra_bits = extra_blbits;\n          #endif */\n            /* Initialize the mapping length (0..255) -> length code (0..28) */\n            length = 0;\n            for (code = 0; code < LENGTH_CODES - 1; code++) {\n                base_length[code] = length;\n                for (n = 0; n < 1 << extra_lbits[code]; n++) {\n                    _length_code[length++] = code;\n                }\n            } // Assert (length == 256, \"tr_static_init: length != 256\");\n            /* Note that the length 255 (match length 258) can be represented\n             * in two different ways: code 284 + 5 bits or code 285, so we\n             * overwrite length_code[255] to use the best encoding:\n             */\n            _length_code[length - 1] = code;\n            /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n            dist = 0;\n            for (code = 0; code < 16; code++) {\n                base_dist[code] = dist;\n                for (n = 0; n < 1 << extra_dbits[code]; n++) {\n                    _dist_code[dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: dist != 256\");\n            dist >>= 7;\n            /* from now on, all distances are divided by 128 */\n            for (; code < D_CODES; code++) {\n                base_dist[code] = dist << 7;\n                for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {\n                    _dist_code[256 + dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n            /* Construct the codes of the static literal tree */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                bl_count[bits] = 0;\n            }\n            n = 0;\n            while (n <= 143) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            while (n <= 255) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    9;\n                n++;\n                bl_count[9]++;\n            }\n            while (n <= 279) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    7;\n                n++;\n                bl_count[7]++;\n            }\n            while (n <= 287) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            /* Codes 286 and 287 do not exist, but we must include them in the\n             * tree construction to get a canonical Huffman tree (longest code\n             * all ones)\n             */\n            gen_codes(static_ltree, L_CODES + 1, bl_count);\n            /* The static distance tree is trivial: */\n            for (n = 0; n < D_CODES; n++) {\n                static_dtree[n * 2 + 1] =\n                    /* .Len */\n                    5;\n                static_dtree[n * 2] =\n                    /* .Code */\n                    bi_reverse(n, 5);\n            } // Now data ready and we can init static trees\n            static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n            static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);\n            static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);\n            // static_init_done = true;\n        };\n        /* ===========================================================================\n         * Initialize a new block.\n         */\n        var init_block = function init_block(s) {\n            var n;\n            /* iterates over tree elements */\n            /* Initialize the trees. */\n            for (n = 0; n < L_CODES; n++) {\n                s.dyn_ltree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < D_CODES; n++) {\n                s.dyn_dtree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < BL_CODES; n++) {\n                s.bl_tree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            s.dyn_ltree[END_BLOCK * 2] =\n                /* .Freq */\n                1;\n            s.opt_len = s.static_len = 0;\n            s.last_lit = s.matches = 0;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer and align the output on a byte boundary\n         */\n        var bi_windup = function bi_windup(s) {\n            if (s.bi_valid > 8) {\n                put_short(s, s.bi_buf);\n            }\n            else if (s.bi_valid > 0) {\n                // put_byte(s, (Byte)s->bi_buf);\n                s.pending_buf[s.pending++] = s.bi_buf;\n            }\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n        };\n        /* ===========================================================================\n         * Copy a stored block, storing first the length and its\n         * one's complement if requested.\n         */\n        var copy_block = function copy_block(s, buf, len, header\n        // DeflateState *s;\n        // charf    *buf;    /* the input data */\n        // unsigned len;     /* its length */\n        // int      header;  /* true if block header must be written */\n        ) {\n            bi_windup(s);\n            /* align on byte boundary */\n            if (header) {\n                put_short(s, len);\n                put_short(s, ~len);\n            }\n            //  while (len--) {\n            //    put_byte(s, *buf++);\n            //  }\n            s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);\n            s.pending += len;\n        };\n        /* ===========================================================================\n         * Compares to subtrees, using the tree depth as tie breaker when\n         * the subtrees have equal frequency. This minimizes the worst case length.\n         */\n        var smaller = function smaller(tree, n, m, depth) {\n            var _n2 = n * 2;\n            var _m2 = m * 2;\n            return (tree[_n2] <\n                /* .Freq */\n                tree[_m2] ||\n                /* .Freq */\n                (tree[_n2] ===\n                    /* .Freq */\n                    tree[_m2] &&\n                    /* .Freq */\n                    depth[n] <= depth[m]));\n        };\n        /* ===========================================================================\n         * Restore the heap property by moving down the tree starting at node k,\n         * exchanging a node with the smallest of its two sons if necessary, stopping\n         * when the heap property is re-established (each father smaller than its\n         * two sons).\n         */\n        var pqdownheap = function pqdownheap(s, tree, k\n        //    deflate_state *s;\n        //    ct_data *tree;  /* the tree to restore */\n        //    int k;               /* node to move down */\n        ) {\n            var v = s.heap[k];\n            var j = k << 1;\n            /* left son of k */\n            while (j <= s.heap_len) {\n                /* Set j to the smallest of the two sons: */\n                if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n                    j++;\n                }\n                /* Exit if v is smaller than both sons */\n                if (smaller(tree, v, s.heap[j], s.depth)) {\n                    break;\n                }\n                /* Exchange v with the smallest son */\n                s.heap[k] = s.heap[j];\n                k = j;\n                /* And continue down the tree, setting j to the left son of k */\n                j <<= 1;\n            }\n            s.heap[k] = v;\n        }; // inlined manually\n        // const SMALLEST = 1;\n        /* ===========================================================================\n         * Send the block data compressed using the given Huffman trees\n         */\n        var compress_block = function compress_block(s, ltree, dtree\n        //    deflate_state *s;\n        //    const ct_data *ltree; /* literal tree */\n        //    const ct_data *dtree; /* distance tree */\n        ) {\n            var dist;\n            /* distance of matched string */\n            var lc;\n            /* match length or unmatched char (if dist == 0) */\n            var lx = 0;\n            /* running index in l_buf */\n            var code;\n            /* the code to send */\n            var extra;\n            /* number of extra bits to send */\n            if (s.last_lit !== 0) {\n                do {\n                    dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | s.pending_buf[s.d_buf + lx * 2 + 1];\n                    lc = s.pending_buf[s.l_buf + lx];\n                    lx++;\n                    if (dist === 0) {\n                        send_code(s, lc, ltree);\n                        /* send a literal byte */\n                        // Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n                    }\n                    else {\n                        /* Here, lc is the match length - MIN_MATCH */\n                        code = _length_code[lc];\n                        send_code(s, code + LITERALS + 1, ltree);\n                        /* send the length code */\n                        extra = extra_lbits[code];\n                        if (extra !== 0) {\n                            lc -= base_length[code];\n                            send_bits(s, lc, extra);\n                            /* send the extra length bits */\n                        }\n                        dist--;\n                        /* dist is now the match distance - 1 */\n                        code = d_code(dist); // Assert (code < D_CODES, \"bad d_code\");\n                        send_code(s, code, dtree);\n                        /* send the distance code */\n                        extra = extra_dbits[code];\n                        if (extra !== 0) {\n                            dist -= base_dist[code];\n                            send_bits(s, dist, extra);\n                            /* send the extra distance bits */\n                        }\n                    }\n                    /* literal or match pair ? */\n                    /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n                    // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n                    //       \"pendingBuf overflow\");\n                } while (lx < s.last_lit);\n            }\n            send_code(s, END_BLOCK, ltree);\n        };\n        /* ===========================================================================\n         * Construct one Huffman tree and assigns the code bit strings and lengths.\n         * Update the total bit length for the current block.\n         * IN assertion: the field freq is set for all tree elements.\n         * OUT assertions: the fields len and code are set to the optimal bit length\n         *     and corresponding code. The length opt_len is updated; static_len is\n         *     also updated if stree is not null. The field max_code is set.\n         */\n        var build_tree = function build_tree(s, desc //    deflate_state *s; //    tree_desc *desc; /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var elems = desc.stat_desc.elems;\n            var n;\n            var m;\n            /* iterate over heap elements */\n            var max_code = -1;\n            /* largest code with non zero frequency */\n            var node;\n            /* new node being created */\n            /* Construct the initial heap, with least frequent element in\n             * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n             * heap[0] is not used.\n             */\n            s.heap_len = 0;\n            s.heap_max = HEAP_SIZE;\n            for (n = 0; n < elems; n++) {\n                if (tree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    s.heap[++s.heap_len] = max_code = n;\n                    s.depth[n] = 0;\n                }\n                else {\n                    tree[n * 2 + 1] =\n                        /* .Len */\n                        0;\n                }\n            }\n            /* The pkzip format requires that at least one distance code exists,\n             * and that at least one bit should be sent even if there is only one\n             * possible code. So to avoid special checks later on we force at least\n             * two codes of non zero frequency.\n             */\n            while (s.heap_len < 2) {\n                node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;\n                tree[node * 2] =\n                    /* .Freq */\n                    1;\n                s.depth[node] = 0;\n                s.opt_len--;\n                if (has_stree) {\n                    s.static_len -= stree[node * 2 + 1];\n                    /* .Len */\n                }\n                /* node is 0 or 1 so it does not have extra bits */\n            }\n            desc.max_code = max_code;\n            /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n             * establish sub-heaps of increasing lengths:\n             */\n            for (n = s.heap_len >> 1; \n            /* int /2 */\n            n >= 1; n--) {\n                pqdownheap(s, tree, n);\n            }\n            /* Construct the Huffman tree by repeatedly combining the least two\n             * frequent nodes.\n             */\n            node = elems;\n            /* next internal node of the tree */\n            do {\n                // pqremove(s, tree, n);  /* n = node of least frequency */\n                /** * pqremove ** */\n                n = s.heap[1];\n                /* SMALLEST */\n                s.heap[1] = s.heap[s.heap_len--];\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n                /***/\n                m = s.heap[1];\n                /* SMALLEST */\n                /* m = node of next least frequency */\n                s.heap[--s.heap_max] = n;\n                /* keep the nodes sorted by frequency */\n                s.heap[--s.heap_max] = m;\n                /* Create a new node father of n and m */\n                tree[node * 2] =\n                    /* .Freq */\n                    tree[n * 2] +\n                        /* .Freq */\n                        tree[m * 2];\n                /* .Freq */\n                s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n                tree[n * 2 + 1] =\n                    /* .Dad */\n                    tree[m * 2 + 1] =\n                        /* .Dad */\n                        node;\n                /* and insert the new node in the heap */\n                s.heap[1] = node++;\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n            } while (s.heap_len >= 2);\n            s.heap[--s.heap_max] = s.heap[1];\n            /* SMALLEST */\n            /* At this point, the fields freq and dad are set. We can now\n             * generate the bit lengths.\n             */\n            gen_bitlen(s, desc);\n            /* The field len is now set, we can generate the bit codes */\n            gen_codes(tree, max_code, s.bl_count);\n        };\n        /* ===========================================================================\n         * Scan a literal or distance tree to determine the frequencies of the codes\n         * in the bit length tree.\n         */\n        var scan_tree = function scan_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree;   /* the tree to be scanned */\n        //    int max_code;    /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            tree[(max_code + 1) * 2 + 1] =\n                /* .Len */\n                0xffff;\n            /* guard */\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    s.bl_tree[curlen * 2] +=\n                        /* .Freq */\n                        count;\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        s.bl_tree[curlen * 2] /* .Freq */++;\n                    }\n                    s.bl_tree[REP_3_6 * 2] /* .Freq */++;\n                }\n                else if (count <= 10) {\n                    s.bl_tree[REPZ_3_10 * 2] /* .Freq */++;\n                }\n                else {\n                    s.bl_tree[REPZ_11_138 * 2] /* .Freq */++;\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Send a literal or distance tree in compressed form, using the codes in\n         * bl_tree.\n         */\n        var send_tree = function send_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree; /* the tree to be scanned */\n        //    int max_code;       /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            /* tree[max_code+1].Len = -1; */\n            /* guard already set */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    do {\n                        send_code(s, curlen, s.bl_tree);\n                    } while (--count !== 0);\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        send_code(s, curlen, s.bl_tree);\n                        count--;\n                    } // Assert(count >= 3 && count <= 6, \" 3_6?\");\n                    send_code(s, REP_3_6, s.bl_tree);\n                    send_bits(s, count - 3, 2);\n                }\n                else if (count <= 10) {\n                    send_code(s, REPZ_3_10, s.bl_tree);\n                    send_bits(s, count - 3, 3);\n                }\n                else {\n                    send_code(s, REPZ_11_138, s.bl_tree);\n                    send_bits(s, count - 11, 7);\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Construct the Huffman tree for the bit lengths and return the index in\n         * bl_order of the last bit length code to send.\n         */\n        var build_bl_tree = function build_bl_tree(s) {\n            var max_blindex;\n            /* index of last bit length code of non zero freq */\n            /* Determine the bit length frequencies for literal and distance trees */\n            scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n            scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n            /* Build the bit length tree: */\n            build_tree(s, s.bl_desc);\n            /* opt_len now includes the length of the tree representations, except\n             * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n             */\n            /* Determine the number of bit length codes to send. The pkzip format\n             * requires that at least 4 bit length codes be sent. (appnote.txt says\n             * 3 but the actual value used is 4.)\n             */\n            for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n                if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !==\n                    /* .Len */\n                    0) {\n                    break;\n                }\n            }\n            /* Update opt_len to include the bit length tree and counts */\n            s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; // Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n            //        s->opt_len, s->static_len));\n            return max_blindex;\n        };\n        /* ===========================================================================\n         * Send the header for a block using dynamic Huffman trees: the counts, the\n         * lengths of the bit length codes, the literal tree and the distance tree.\n         * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n         */\n        var send_all_trees = function send_all_trees(s, lcodes, dcodes, blcodes //    deflate_state *s; //    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n        ) {\n            var rank;\n            /* index in bl_order */\n            // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n            // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n            //        \"too many codes\");\n            // Tracev((stderr, \"\\nbl counts: \"));\n            send_bits(s, lcodes - 257, 5);\n            /* not +255 as stated in appnote.txt */\n            send_bits(s, dcodes - 1, 5);\n            send_bits(s, blcodes - 4, 4);\n            /* not -3 as stated in appnote.txt */\n            for (rank = 0; rank < blcodes; rank++) {\n                // Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n                send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], \n                /* .Len */\n                3);\n            } // Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_ltree, lcodes - 1);\n            /* literal tree */\n            // Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_dtree, dcodes - 1);\n            /* distance tree */\n            // Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n        };\n        /* ===========================================================================\n         * Check if the data type is TEXT or BINARY, using the following algorithm:\n         * - TEXT if the two conditions below are satisfied:\n         *    a) There are no non-portable control characters belonging to the\n         *       \"black list\" (0..6, 14..25, 28..31).\n         *    b) There is at least one printable character belonging to the\n         *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n         * - BINARY otherwise.\n         * - The following partially-portable control characters form a\n         *   \"gray list\" that is ignored in this detection algorithm:\n         *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n         * IN assertion: the fields Freq of dyn_ltree are set.\n         */\n        var detect_data_type = function detect_data_type(s) {\n            /* black_mask is the bit mask of black-listed bytes\n             * set bits 0..6, 14..25, and 28..31\n             * 0xf3ffc07f = binary 11110011111111111100000001111111\n             */\n            var black_mask = 0xf3ffc07f;\n            var n;\n            /* Check for non-textual (\"black-listed\") bytes. */\n            for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n                if (black_mask & 1 &&\n                    s.dyn_ltree[n * 2] !==\n                        /* .Freq */\n                        0) {\n                    return Z_BINARY;\n                }\n            }\n            /* Check for textual (\"white-listed\") bytes. */\n            if (s.dyn_ltree[9 * 2] !==\n                /* .Freq */\n                0 ||\n                s.dyn_ltree[10 * 2] !==\n                    /* .Freq */\n                    0 ||\n                s.dyn_ltree[13 * 2] !==\n                    /* .Freq */\n                    0) {\n                return Z_TEXT;\n            }\n            for (n = 32; n < LITERALS; n++) {\n                if (s.dyn_ltree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    return Z_TEXT;\n                }\n            }\n            /* There are no \"black-listed\" or \"white-listed\" bytes:\n             * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n             */\n            return Z_BINARY;\n        };\n        var static_init_done = false;\n        /* ===========================================================================\n         * Initialize the tree data structures for a new zlib stream.\n         */\n        var _tr_init = function _tr_init(s) {\n            if (!static_init_done) {\n                tr_static_init();\n                static_init_done = true;\n            }\n            s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);\n            s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);\n            s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n            /* Initialize the first block of the first file: */\n            init_block(s);\n        };\n        /* ===========================================================================\n         * Send a stored block\n         */\n        var _tr_stored_block = function _tr_stored_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);\n            /* send block type */\n            copy_block(s, buf, stored_len, true);\n            /* with header */\n        };\n        /* ===========================================================================\n         * Send one empty static block to give enough lookahead for inflate.\n         * This takes 10 bits, of which 7 may remain in the bit buffer.\n         */\n        var _tr_align = function _tr_align(s) {\n            send_bits(s, STATIC_TREES << 1, 3);\n            send_code(s, END_BLOCK, static_ltree);\n            bi_flush(s);\n        };\n        /* ===========================================================================\n         * Determine the best encoding for the current block: dynamic trees, static\n         * trees or store, and output the encoded block to the zip file.\n         */\n        var _tr_flush_block = function _tr_flush_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block, or NULL if too old */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            var opt_lenb;\n            var static_lenb;\n            /* opt_len and static_len in bytes */\n            var max_blindex = 0;\n            /* index of last bit length code of non zero freq */\n            /* Build the Huffman trees unless a stored block is forced */\n            if (s.level > 0) {\n                /* Check if the file is binary or text */\n                if (s.strm.data_type === Z_UNKNOWN) {\n                    s.strm.data_type = detect_data_type(s);\n                }\n                /* Construct the literal and distance trees */\n                build_tree(s, s.l_desc); // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                build_tree(s, s.d_desc); // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                /* At this point, opt_len and static_len are the total bit lengths of\n                 * the compressed block data, excluding the tree representations.\n                 */\n                /* Build the bit length tree for the above two trees, and get the index\n                 * in bl_order of the last bit length code to send.\n                 */\n                max_blindex = build_bl_tree(s);\n                /* Determine the best encoding. Compute the block lengths in bytes. */\n                opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n                static_lenb = (s.static_len + 3 + 7) >>> 3; // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n                //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n                //        s->last_lit));\n                if (static_lenb <= opt_lenb) {\n                    opt_lenb = static_lenb;\n                }\n            }\n            else {\n                // Assert(buf != (char*)0, \"lost buf\");\n                opt_lenb = static_lenb = stored_len + 5;\n                /* force a stored block */\n            }\n            if (stored_len + 4 <= opt_lenb && buf !== -1) {\n                /* 4: two words for the lengths */\n                /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n                 * Otherwise we can't have processed more than WSIZE input bytes since\n                 * the last block flush, because compression would have been\n                 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n                 * transform a block into a stored block.\n                 */\n                _tr_stored_block(s, buf, stored_len, last);\n            }\n            else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n                send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n                compress_block(s, static_ltree, static_dtree);\n            }\n            else {\n                send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n                send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n                compress_block(s, s.dyn_ltree, s.dyn_dtree);\n            } // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n            /* The above check is made mod 2^32, for files larger than 512 MB\n             * and uLong implemented on 32 bits.\n             */\n            init_block(s);\n            if (last) {\n                bi_windup(s);\n            } // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n            //       s->compressed_len-7*last));\n        };\n        /* ===========================================================================\n         * Save the match info and tally the frequency counts. Return true if\n         * the current block must be flushed.\n         */\n        var _tr_tally = function _tr_tally(s, dist, lc\n        //    deflate_state *s;\n        //    unsigned dist;  /* distance of matched string */\n        //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n        ) {\n            // let out_length, in_length, dcode;\n            s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;\n            s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n            s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n            s.last_lit++;\n            if (dist === 0) {\n                /* lc is the unmatched char */\n                s.dyn_ltree[lc * 2] /* .Freq */++;\n            }\n            else {\n                s.matches++;\n                /* Here, lc is the match length - MIN_MATCH */\n                dist--;\n                /* dist = match distance - 1 */\n                // Assert((ush)dist < (ush)MAX_DIST(s) &&\n                //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n                //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n                s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /* .Freq */++;\n                s.dyn_dtree[d_code(dist) * 2] /* .Freq */++;\n            } // (!) This block is disabled in zlib defaults,\n            // don't enable it for binary compatibility\n            // #ifdef TRUNCATE_BLOCK\n            //  /* Try to guess if it is profitable to stop the current block here */\n            //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n            //    /* Compute an upper bound for the compressed length */\n            //    out_length = s.last_lit*8;\n            //    in_length = s.strstart - s.block_start;\n            //\n            //    for (dcode = 0; dcode < D_CODES; dcode++) {\n            //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n            //    }\n            //    out_length >>>= 3;\n            //    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n            //    //       s->last_lit, in_length, out_length,\n            //    //       100L - out_length*100L/in_length));\n            //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n            //      return true;\n            //    }\n            //  }\n            // #endif\n            return s.last_lit === s.lit_bufsize - 1;\n            /* We avoid equality with lit_bufsize because of wraparound at 64K\n             * on 16 bit machines and because stored blocks are restricted to\n             * 64K-1 bytes.\n             */\n        };\n        var _tr_init_1 = _tr_init;\n        var _tr_stored_block_1 = _tr_stored_block;\n        var _tr_flush_block_1 = _tr_flush_block;\n        var _tr_tally_1 = _tr_tally;\n        var _tr_align_1 = _tr_align;\n        var trees = {\n            _tr_init: _tr_init_1,\n            _tr_stored_block: _tr_stored_block_1,\n            _tr_flush_block: _tr_flush_block_1,\n            _tr_tally: _tr_tally_1,\n            _tr_align: _tr_align_1,\n        };\n        // It isn't worth it to make additional optimizations as in original.\n        // Small size is preferable.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var adler32 = function adler32(adler, buf, len, pos) {\n            var s1 = (adler & 0xffff) | 0;\n            var s2 = ((adler >>> 16) & 0xffff) | 0;\n            var n = 0;\n            while (len !== 0) {\n                // Set limit ~ twice less than 5552, to keep\n                // s2 in 31-bits, because we force signed ints.\n                // in other case %= will fail.\n                n = len > 2000 ? 2000 : len;\n                len -= n;\n                do {\n                    s1 = (s1 + buf[pos++]) | 0;\n                    s2 = (s2 + s1) | 0;\n                } while (--n);\n                s1 %= 65521;\n                s2 %= 65521;\n            }\n            return s1 | (s2 << 16) | 0;\n        };\n        var adler32_1 = adler32;\n        // So write code to minimize size - no pregenerated tables\n        // and array tools dependencies.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        // Use ordinary array, since untyped makes no boost here\n        var makeTable = function makeTable() {\n            var c;\n            var table = [];\n            for (var n = 0; n < 256; n++) {\n                c = n;\n                for (var k = 0; k < 8; k++) {\n                    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n                }\n                table[n] = c;\n            }\n            return table;\n        }; // Create table on load. Just 255 signed longs. Not a problem.\n        var crcTable = new Uint32Array(makeTable());\n        var crc32 = function crc32(crc, buf, len, pos) {\n            var t = crcTable;\n            var end = pos + len;\n            crc ^= -1;\n            for (var i = pos; i < end; i++) {\n                crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xff];\n            }\n            return crc ^ -1; // >>> 0;\n        };\n        var crc32_1 = crc32;\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var messages = {\n            2: 'need dictionary',\n            /* Z_NEED_DICT       2  */\n            1: 'stream end',\n            /* Z_STREAM_END      1  */\n            0: '',\n            /* Z_OK              0  */\n            '-1': 'file error',\n            /* Z_ERRNO         (-1) */\n            '-2': 'stream error',\n            /* Z_STREAM_ERROR  (-2) */\n            '-3': 'data error',\n            /* Z_DATA_ERROR    (-3) */\n            '-4': 'insufficient memory',\n            /* Z_MEM_ERROR     (-4) */\n            '-5': 'buffer error',\n            /* Z_BUF_ERROR     (-5) */\n            '-6': 'incompatible version',\n            /* Z_VERSION_ERROR (-6) */\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var constants = {\n            /* Allowed flush values; see deflate() and inflate() below for details */\n            Z_NO_FLUSH: 0,\n            Z_PARTIAL_FLUSH: 1,\n            Z_SYNC_FLUSH: 2,\n            Z_FULL_FLUSH: 3,\n            Z_FINISH: 4,\n            Z_BLOCK: 5,\n            Z_TREES: 6,\n            /* Return codes for the compression/decompression functions. Negative values\n             * are errors, positive values are used for special but normal events.\n             */\n            Z_OK: 0,\n            Z_STREAM_END: 1,\n            Z_NEED_DICT: 2,\n            Z_ERRNO: -1,\n            Z_STREAM_ERROR: -2,\n            Z_DATA_ERROR: -3,\n            Z_MEM_ERROR: -4,\n            Z_BUF_ERROR: -5,\n            // Z_VERSION_ERROR: -6,\n            /* compression levels */\n            Z_NO_COMPRESSION: 0,\n            Z_BEST_SPEED: 1,\n            Z_BEST_COMPRESSION: 9,\n            Z_DEFAULT_COMPRESSION: -1,\n            Z_FILTERED: 1,\n            Z_HUFFMAN_ONLY: 2,\n            Z_RLE: 3,\n            Z_FIXED: 4,\n            Z_DEFAULT_STRATEGY: 0,\n            /* Possible values of the data_type field (though see inflate()) */\n            Z_BINARY: 0,\n            Z_TEXT: 1,\n            // Z_ASCII:                1, // = Z_TEXT (deprecated)\n            Z_UNKNOWN: 2,\n            /* The deflate compression method */\n            Z_DEFLATED: 8, // Z_NULL:                 null // Use -1 or null inline, depending on var type\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var _tr_init$1 = trees._tr_init;\n        var _tr_stored_block$1 = trees._tr_stored_block;\n        var _tr_flush_block$1 = trees._tr_flush_block;\n        var _tr_tally$1 = trees._tr_tally;\n        var _tr_align$1 = trees._tr_align;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH = constants.Z_NO_FLUSH;\n        var Z_PARTIAL_FLUSH = constants.Z_PARTIAL_FLUSH;\n        var Z_FULL_FLUSH = constants.Z_FULL_FLUSH;\n        var Z_FINISH = constants.Z_FINISH;\n        var Z_BLOCK = constants.Z_BLOCK;\n        var Z_OK = constants.Z_OK;\n        var Z_STREAM_END = constants.Z_STREAM_END;\n        var Z_STREAM_ERROR = constants.Z_STREAM_ERROR;\n        var Z_DATA_ERROR = constants.Z_DATA_ERROR;\n        var Z_BUF_ERROR = constants.Z_BUF_ERROR;\n        var Z_DEFAULT_COMPRESSION = constants.Z_DEFAULT_COMPRESSION;\n        var Z_FILTERED = constants.Z_FILTERED;\n        var Z_HUFFMAN_ONLY = constants.Z_HUFFMAN_ONLY;\n        var Z_RLE = constants.Z_RLE;\n        var Z_FIXED$1 = constants.Z_FIXED;\n        var Z_DEFAULT_STRATEGY = constants.Z_DEFAULT_STRATEGY;\n        var Z_UNKNOWN$1 = constants.Z_UNKNOWN;\n        var Z_DEFLATED = constants.Z_DEFLATED;\n        /* ============================================================================ */\n        var MAX_MEM_LEVEL = 9;\n        /* Maximum value for memLevel in deflateInit2 */\n        var MAX_WBITS = 15;\n        /* 32K LZ77 window */\n        var DEF_MEM_LEVEL = 8;\n        var LENGTH_CODES$1 = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS$1 = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES$1 = 30;\n        /* number of distance codes */\n        var BL_CODES$1 = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE$1 = 2 * L_CODES$1 + 1;\n        /* maximum heap size */\n        var MAX_BITS$1 = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var MIN_MATCH$1 = 3;\n        var MAX_MATCH$1 = 258;\n        var MIN_LOOKAHEAD = MAX_MATCH$1 + MIN_MATCH$1 + 1;\n        var PRESET_DICT = 0x20;\n        var INIT_STATE = 42;\n        var EXTRA_STATE = 69;\n        var NAME_STATE = 73;\n        var COMMENT_STATE = 91;\n        var HCRC_STATE = 103;\n        var BUSY_STATE = 113;\n        var FINISH_STATE = 666;\n        var BS_NEED_MORE = 1;\n        /* block not completed, need more input or more output */\n        var BS_BLOCK_DONE = 2;\n        /* block flush performed */\n        var BS_FINISH_STARTED = 3;\n        /* finish started, need only more output at next deflate */\n        var BS_FINISH_DONE = 4;\n        /* finish done, accept no more input or output */\n        var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n        var err = function err(strm, errorCode) {\n            strm.msg = messages[errorCode];\n            return errorCode;\n        };\n        var rank = function rank(f) {\n            return (f << 1) - (f > 4 ? 9 : 0);\n        };\n        var zero$1 = function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        };\n        var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {\n            return ((prev << s.hash_shift) ^ data) & s.hash_mask;\n        }; // This hash causes less collisions, https://github.com/nodeca/pako/issues/135\n        // But breaks binary compatibility\n        // let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;\n        var HASH = HASH_ZLIB;\n        /* =========================================================================\n         * Flush as much pending output as possible. All deflate() output goes\n         * through this function so some applications may wish to modify it\n         * to avoid allocating a large strm->output buffer and copying into it.\n         * (See also read_buf()).\n         */\n        var flush_pending = function flush_pending(strm) {\n            var s = strm.state; // _tr_flush_bits(s);\n            var len = s.pending;\n            if (len > strm.avail_out) {\n                len = strm.avail_out;\n            }\n            if (len === 0) {\n                return;\n            }\n            strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);\n            strm.next_out += len;\n            s.pending_out += len;\n            strm.total_out += len;\n            strm.avail_out -= len;\n            s.pending -= len;\n            if (s.pending === 0) {\n                s.pending_out = 0;\n            }\n        };\n        var flush_block_only = function flush_block_only(s, last) {\n            _tr_flush_block$1(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n            s.block_start = s.strstart;\n            flush_pending(s.strm);\n        };\n        var put_byte = function put_byte(s, b) {\n            s.pending_buf[s.pending++] = b;\n        };\n        /* =========================================================================\n         * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n         * IN assertion: the stream state is correct and there is enough room in\n         * pending_buf.\n         */\n        var putShortMSB = function putShortMSB(s, b) {\n            //  put_byte(s, (Byte)(b >> 8));\n            //  put_byte(s, (Byte)(b & 0xff));\n            s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n            s.pending_buf[s.pending++] = b & 0xff;\n        };\n        /* ===========================================================================\n         * Read a new buffer from the current input stream, update the adler32\n         * and total number of bytes read.  All deflate() input goes through\n         * this function so some applications may wish to modify it to avoid\n         * allocating a large strm->input buffer and copying from it.\n         * (See also flush_pending()).\n         */\n        var read_buf = function read_buf(strm, buf, start, size) {\n            var len = strm.avail_in;\n            if (len > size) {\n                len = size;\n            }\n            if (len === 0) {\n                return 0;\n            }\n            strm.avail_in -= len; // zmemcpy(buf, strm->next_in, len);\n            buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);\n            if (strm.state.wrap === 1) {\n                strm.adler = adler32_1(strm.adler, buf, len, start);\n            }\n            else if (strm.state.wrap === 2) {\n                strm.adler = crc32_1(strm.adler, buf, len, start);\n            }\n            strm.next_in += len;\n            strm.total_in += len;\n            return len;\n        };\n        /* ===========================================================================\n         * Set match_start to the longest match starting at the given string and\n         * return its length. Matches shorter or equal to prev_length are discarded,\n         * in which case the result is equal to prev_length and match_start is\n         * garbage.\n         * IN assertions: cur_match is the head of the hash chain for the current\n         *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n         * OUT assertion: the match length is not greater than s->lookahead.\n         */\n        var longest_match = function longest_match(s, cur_match) {\n            var chain_length = s.max_chain_length;\n            /* max hash chain length */\n            var scan = s.strstart;\n            /* current string */\n            var match;\n            /* matched string */\n            var len;\n            /* length of current match */\n            var best_len = s.prev_length;\n            /* best match length so far */\n            var nice_match = s.nice_match;\n            /* stop if match long enough */\n            var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;\n            /* NIL */\n            var _win = s.window; // shortcut\n            var wmask = s.w_mask;\n            var prev = s.prev;\n            /* Stop when cur_match becomes <= limit. To simplify the code,\n             * we prevent matches with the string of window index 0.\n             */\n            var strend = s.strstart + MAX_MATCH$1;\n            var scan_end1 = _win[scan + best_len - 1];\n            var scan_end = _win[scan + best_len];\n            /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n             * It is easy to get rid of this optimization if necessary.\n             */\n            // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n            /* Do not waste too much time if we already have a good match: */\n            if (s.prev_length >= s.good_match) {\n                chain_length >>= 2;\n            }\n            /* Do not look for matches beyond the end of the input. This is necessary\n             * to make deflate deterministic.\n             */\n            if (nice_match > s.lookahead) {\n                nice_match = s.lookahead;\n            } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n            do {\n                // Assert(cur_match < s->strstart, \"no future\");\n                match = cur_match;\n                /* Skip to next match if the match length cannot increase\n                 * or if the match length is less than 2.  Note that the checks below\n                 * for insufficient lookahead only occur occasionally for performance\n                 * reasons.  Therefore uninitialized memory will be accessed, and\n                 * conditional jumps will be made that depend on those values.\n                 * However the length of the match is limited to the lookahead, so\n                 * the output of deflate is not affected by the uninitialized values.\n                 */\n                if (_win[match + best_len] !== scan_end ||\n                    _win[match + best_len - 1] !== scan_end1 ||\n                    _win[match] !== _win[scan] ||\n                    _win[++match] !== _win[scan + 1]) {\n                    continue;\n                }\n                /* The check at best_len-1 can be removed because it will be made\n                 * again later. (This heuristic is not always a win.)\n                 * It is not necessary to compare scan[2] and match[2] since they\n                 * are always equal when the other bytes match, given that\n                 * the hash keys are equal and that HASH_BITS >= 8.\n                 */\n                scan += 2;\n                match++; // Assert(*scan == *match, \"match[2]?\");\n                /* We check for insufficient lookahead only every 8th comparison;\n                 * the 256th check will be made at strstart+258.\n                 */\n                do {\n                    /* jshint noempty:false */\n                } while (_win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    scan < strend); // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n                len = MAX_MATCH$1 - (strend - scan);\n                scan = strend - MAX_MATCH$1;\n                if (len > best_len) {\n                    s.match_start = cur_match;\n                    best_len = len;\n                    if (len >= nice_match) {\n                        break;\n                    }\n                    scan_end1 = _win[scan + best_len - 1];\n                    scan_end = _win[scan + best_len];\n                }\n            } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n            if (best_len <= s.lookahead) {\n                return best_len;\n            }\n            return s.lookahead;\n        };\n        /* ===========================================================================\n         * Fill the window when the lookahead becomes insufficient.\n         * Updates strstart and lookahead.\n         *\n         * IN assertion: lookahead < MIN_LOOKAHEAD\n         * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n         *    At least one byte has been read, or avail_in == 0; reads are\n         *    performed for at least two bytes (required for the zip translate_eol\n         *    option -- not supported here).\n         */\n        var fill_window = function fill_window(s) {\n            var _w_size = s.w_size;\n            var p;\n            var n;\n            var m;\n            var more;\n            var str; // Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n            do {\n                more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed\n                /* Deal with !@#$% 64K limit: */\n                // if (sizeof(int) <= 2) {\n                //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n                //        more = wsize;\n                //\n                //  } else if (more == (unsigned)(-1)) {\n                //        /* Very unlikely, but possible on 16 bit machine if\n                //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n                //         */\n                //        more--;\n                //    }\n                // }\n                /* If the window is almost full and there is insufficient lookahead,\n                 * move the upper half to the lower one to make room in the upper half.\n                 */\n                if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n                    s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);\n                    s.match_start -= _w_size;\n                    s.strstart -= _w_size;\n                    /* we now have strstart >= MAX_DIST */\n                    s.block_start -= _w_size;\n                    /* Slide the hash table (could be avoided with 32 bit values\n                   at the expense of memory usage). We slide even when level == 0\n                   to keep the hash table consistent if we switch back to level > 0\n                   later. (Using level 0 permanently is not an optimal usage of\n                   zlib, so we don't care about this pathological case.)\n                   */\n                    n = s.hash_size;\n                    p = n;\n                    do {\n                        m = s.head[--p];\n                        s.head[p] = m >= _w_size ? m - _w_size : 0;\n                    } while (--n);\n                    n = _w_size;\n                    p = n;\n                    do {\n                        m = s.prev[--p];\n                        s.prev[p] = m >= _w_size ? m - _w_size : 0;\n                        /* If n is not on any hash chain, prev[n] is garbage but\n                         * its value will never be used.\n                         */\n                    } while (--n);\n                    more += _w_size;\n                }\n                if (s.strm.avail_in === 0) {\n                    break;\n                }\n                /* If there was no sliding:\n                 *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n                 *    more == window_size - lookahead - strstart\n                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n                 * => more >= window_size - 2*WSIZE + 2\n                 * In the BIG_MEM or MMAP case (not yet supported),\n                 *   window_size == input_size + MIN_LOOKAHEAD  &&\n                 *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n                 * Otherwise, window_size == 2*WSIZE so more >= 2.\n                 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n                 */\n                // Assert(more >= 2, \"more < 2\");\n                n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n                s.lookahead += n;\n                /* Initialize the hash value now that we have some input: */\n                if (s.lookahead + s.insert >= MIN_MATCH$1) {\n                    str = s.strstart - s.insert;\n                    s.ins_h = s.window[str];\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + 1]); // #if MIN_MATCH != 3\n                    //        Call update_hash() MIN_MATCH-3 more times\n                    // #endif\n                    while (s.insert) {\n                        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                        s.prev[str & s.w_mask] = s.head[s.ins_h];\n                        s.head[s.ins_h] = str;\n                        str++;\n                        s.insert--;\n                        if (s.lookahead + s.insert < MIN_MATCH$1) {\n                            break;\n                        }\n                    }\n                }\n                /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n                 * but this is not important since only literal bytes will be emitted.\n                 */\n            } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n            /* If the WIN_INIT bytes after the end of the current data have never been\n             * written, then zero those bytes in order to avoid memory check reports of\n             * the use of uninitialized (or uninitialised as Julian writes) bytes by\n             * the longest match routines.  Update the high water mark for the next\n             * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n             * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n             */\n            //  if (s.high_water < s.window_size) {\n            //    const curr = s.strstart + s.lookahead;\n            //    let init = 0;\n            //\n            //    if (s.high_water < curr) {\n            //      /* Previous high water mark below current data -- zero WIN_INIT\n            //       * bytes or up to end of window, whichever is less.\n            //       */\n            //      init = s.window_size - curr;\n            //      if (init > WIN_INIT)\n            //        init = WIN_INIT;\n            //      zmemzero(s->window + curr, (unsigned)init);\n            //      s->high_water = curr + init;\n            //    }\n            //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n            //      /* High water mark at or above current data, but below current data\n            //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n            //       * to end of window, whichever is less.\n            //       */\n            //      init = (ulg)curr + WIN_INIT - s->high_water;\n            //      if (init > s->window_size - s->high_water)\n            //        init = s->window_size - s->high_water;\n            //      zmemzero(s->window + s->high_water, (unsigned)init);\n            //      s->high_water += init;\n            //    }\n            //  }\n            //\n            //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n            //    \"not enough room for search\");\n        };\n        /* ===========================================================================\n         * Copy without compression as much as possible from the input stream, return\n         * the current block state.\n         * This function does not insert new strings in the dictionary since\n         * uncompressible data is probably not useful. This function is used\n         * only for the level=0 compression option.\n         * NOTE: this function should be optimized to avoid extra copying from\n         * window to pending_buf.\n         */\n        var deflate_stored = function deflate_stored(s, flush) {\n            /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n             * to pending_buf_size, and each stored block has a 5 byte header:\n             */\n            var max_block_size = 0xffff;\n            if (max_block_size > s.pending_buf_size - 5) {\n                max_block_size = s.pending_buf_size - 5;\n            }\n            /* Copy as much as possible from input to output: */\n            for (;;) {\n                /* Fill the window as much as possible: */\n                if (s.lookahead <= 1) {\n                    // Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n                    //  s->block_start >= (long)s->w_size, \"slide too late\");\n                    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n                    //        s.block_start >= s.w_size)) {\n                    //        throw  new Error(\"slide too late\");\n                    //      }\n                    fill_window(s);\n                    if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                } // Assert(s->block_start >= 0L, \"block gone\");\n                //    if (s.block_start < 0) throw new Error(\"block gone\");\n                s.strstart += s.lookahead;\n                s.lookahead = 0;\n                /* Emit a stored block if pending_buf will be full: */\n                var max_start = s.block_start + max_block_size;\n                if (s.strstart === 0 || s.strstart >= max_start) {\n                    /* strstart == 0 is possible when wraparound on 16-bit machine */\n                    s.lookahead = s.strstart - max_start;\n                    s.strstart = max_start;\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n                /* Flush if we may have to slide, otherwise block_start may become\n                 * negative and the data will be gone:\n                 */\n                if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.strstart > s.block_start) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_NEED_MORE;\n        };\n        /* ===========================================================================\n         * Compress as much as possible from the input stream, return the current\n         * block state.\n         * This function does not perform lazy evaluation of matches and inserts\n         * new strings in the dictionary only for unmatched strings or for short\n         * matches. It is used only for the fast compression options.\n         */\n        var deflate_fast = function deflate_fast(s, flush) {\n            var hash_head;\n            /* head of the hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 * At this point we have always match_length < MIN_MATCH\n                 */\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                }\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n                    /** * _tr_tally_dist(s, s.strstart - s.match_start,\n                                 s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    /* Insert new strings in the hash table only if the match length\n                     * is not too large. This saves time but degrades compression.\n                     */\n                    if (s.match_length <= s.max_lazy_match &&\n                        /* max_insert_length */\n                        s.lookahead >= MIN_MATCH$1) {\n                        s.match_length--;\n                        /* string at strstart already in table */\n                        do {\n                            s.strstart++;\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                            /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n                             * always MIN_MATCH bytes ahead.\n                             */\n                        } while (--s.match_length !== 0);\n                        s.strstart++;\n                    }\n                    else {\n                        s.strstart += s.match_length;\n                        s.match_length = 0;\n                        s.ins_h = s.window[s.strstart];\n                        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]); // #if MIN_MATCH != 3\n                        //                Call UPDATE_HASH() MIN_MATCH-3 more times\n                        // #endif\n                        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n                         * matter since it will be recomputed at next deflate call.\n                         */\n                    }\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s.window[s.strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * Same as above, but achieves better compression. We use a lazy\n         * evaluation for matches: a match is finally adopted only if there is\n         * no better match at the next window position.\n         */\n        var deflate_slow = function deflate_slow(s, flush) {\n            var hash_head;\n            /* head of hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            var max_insert;\n            /* Process the input block. */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 */\n                s.prev_length = s.match_length;\n                s.prev_match = s.match_start;\n                s.match_length = MIN_MATCH$1 - 1;\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.prev_length < s.max_lazy_match &&\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n                /* MAX_DIST(s) */\n                ) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                    if (s.match_length <= 5 &&\n                        (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096))\n                    /* TOO_FAR */\n                    ) {\n                        /* If prev_match is also MIN_MATCH, match_start is garbage\n                         * but we will ignore the current match anyway.\n                         */\n                        s.match_length = MIN_MATCH$1 - 1;\n                    }\n                }\n                /* If there was a match at the previous step and the current\n                 * match is not better, output the previous match:\n                 */\n                if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {\n                    max_insert = s.strstart + s.lookahead - MIN_MATCH$1;\n                    /* Do not insert strings in hash table beyond this. */\n                    // check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n                    /** *_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                                 s.prev_length - MIN_MATCH, bflush);** */\n                    bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);\n                    /* Insert in hash table all strings up to the end of the match.\n                     * strstart-1 and strstart are already inserted. If there is not\n                     * enough lookahead, the last two strings are not inserted in\n                     * the hash table.\n                     */\n                    s.lookahead -= s.prev_length - 1;\n                    s.prev_length -= 2;\n                    do {\n                        if (++s.strstart <= max_insert) {\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                        }\n                    } while (--s.prev_length !== 0);\n                    s.match_available = 0;\n                    s.match_length = MIN_MATCH$1 - 1;\n                    s.strstart++;\n                    if (bflush) {\n                        /** * FLUSH_BLOCK(s, 0); ** */\n                        flush_block_only(s, false);\n                        if (s.strm.avail_out === 0) {\n                            return BS_NEED_MORE;\n                        }\n                        /***/\n                    }\n                }\n                else if (s.match_available) {\n                    /* If there was no match at the previous position, output a\n                     * single literal. If there was a match but the current match\n                     * is longer, truncate the previous match to a single literal.\n                     */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                    if (bflush) {\n                        /** * FLUSH_BLOCK_ONLY(s, 0) ** */\n                        flush_block_only(s, false);\n                        /***/\n                    }\n                    s.strstart++;\n                    s.lookahead--;\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                }\n                else {\n                    /* There is no previous match to compare with, wait for\n                     * the next step to decide.\n                     */\n                    s.match_available = 1;\n                    s.strstart++;\n                    s.lookahead--;\n                }\n            } // Assert (flush != Z_NO_FLUSH, \"no flush?\");\n            if (s.match_available) {\n                // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                s.match_available = 0;\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n         * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n         * deflate switches away from Z_RLE.)\n         */\n        var deflate_rle = function deflate_rle(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            var prev;\n            /* byte at distance one to match */\n            var scan;\n            var strend;\n            /* scan goes up to strend for length of run */\n            var _win = s.window;\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the longest run, plus one for the unrolled loop.\n                 */\n                if (s.lookahead <= MAX_MATCH$1) {\n                    fill_window(s);\n                    if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* See how many times the previous byte repeats */\n                s.match_length = 0;\n                if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {\n                    scan = s.strstart - 1;\n                    prev = _win[scan];\n                    if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n                        strend = s.strstart + MAX_MATCH$1;\n                        do {\n                            /* jshint noempty:false */\n                        } while (prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            scan < strend);\n                        s.match_length = MAX_MATCH$1 - (strend - scan);\n                        if (s.match_length > s.lookahead) {\n                            s.match_length = s.lookahead;\n                        }\n                    } // Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n                }\n                /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.strstart - 1, s.match_length);\n                    /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    s.strstart += s.match_length;\n                    s.match_length = 0;\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n         * (It will be regenerated if this run of deflate switches away from Huffman.)\n         */\n        var deflate_huff = function deflate_huff(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we have a literal to write. */\n                if (s.lookahead === 0) {\n                    fill_window(s);\n                    if (s.lookahead === 0) {\n                        if (flush === Z_NO_FLUSH) {\n                            return BS_NEED_MORE;\n                        }\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Output a literal byte */\n                s.match_length = 0; // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                s.lookahead--;\n                s.strstart++;\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* Values for max_lazy_match, good_match and max_chain_length, depending on\n         * the desired pack level (0..9). The values given below have been tuned to\n         * exclude worst case performance for pathological files. Better values may be\n         * found for specific files.\n         */\n        function Config(good_length, max_lazy, nice_length, max_chain, func) {\n            this.good_length = good_length;\n            this.max_lazy = max_lazy;\n            this.nice_length = nice_length;\n            this.max_chain = max_chain;\n            this.func = func;\n        }\n        var configuration_table = [\n            /*      good lazy nice chain */\n            new Config(0, 0, 0, 0, deflate_stored),\n            /* 0 store only */\n            new Config(4, 4, 8, 4, deflate_fast),\n            /* 1 max speed, no lazy matches */\n            new Config(4, 5, 16, 8, deflate_fast),\n            /* 2 */\n            new Config(4, 6, 32, 32, deflate_fast),\n            /* 3 */\n            new Config(4, 4, 16, 16, deflate_slow),\n            /* 4 lazy matches */\n            new Config(8, 16, 32, 32, deflate_slow),\n            /* 5 */\n            new Config(8, 16, 128, 128, deflate_slow),\n            /* 6 */\n            new Config(8, 32, 128, 256, deflate_slow),\n            /* 7 */\n            new Config(32, 128, 258, 1024, deflate_slow),\n            /* 8 */\n            new Config(32, 258, 258, 4096, deflate_slow),\n            /* 9 max compression */\n        ];\n        /* ===========================================================================\n         * Initialize the \"longest match\" routines for a new zlib stream\n         */\n        var lm_init = function lm_init(s) {\n            s.window_size = 2 * s.w_size;\n            /** * CLEAR_HASH(s); ** */\n            zero$1(s.head); // Fill with NIL (= 0);\n            /* Set the default configuration parameters:\n             */\n            s.max_lazy_match = configuration_table[s.level].max_lazy;\n            s.good_match = configuration_table[s.level].good_length;\n            s.nice_match = configuration_table[s.level].nice_length;\n            s.max_chain_length = configuration_table[s.level].max_chain;\n            s.strstart = 0;\n            s.block_start = 0;\n            s.lookahead = 0;\n            s.insert = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            s.ins_h = 0;\n        };\n        function DeflateState() {\n            this.strm = null;\n            /* pointer back to this zlib stream */\n            this.status = 0;\n            /* as the name implies */\n            this.pending_buf = null;\n            /* output still pending */\n            this.pending_buf_size = 0;\n            /* size of pending_buf */\n            this.pending_out = 0;\n            /* next pending byte to output to the stream */\n            this.pending = 0;\n            /* nb of bytes in the pending buffer */\n            this.wrap = 0;\n            /* bit 0 true for zlib, bit 1 true for gzip */\n            this.gzhead = null;\n            /* gzip header information to write */\n            this.gzindex = 0;\n            /* where in extra, name, or comment */\n            this.method = Z_DEFLATED;\n            /* can only be DEFLATED */\n            this.last_flush = -1;\n            /* value of flush param for previous deflate call */\n            this.w_size = 0;\n            /* LZ77 window size (32K by default) */\n            this.w_bits = 0;\n            /* log2(w_size)  (8..16) */\n            this.w_mask = 0;\n            /* w_size - 1 */\n            this.window = null;\n            /* Sliding window. Input bytes are read into the second half of the window,\n             * and move to the first half later to keep a dictionary of at least wSize\n             * bytes. With this organization, matches are limited to a distance of\n             * wSize-MAX_MATCH bytes, but this ensures that IO is always\n             * performed with a length multiple of the block size.\n             */\n            this.window_size = 0;\n            /* Actual size of window: 2*wSize, except when the user input buffer\n             * is directly used as sliding window.\n             */\n            this.prev = null;\n            /* Link to older string with same hash index. To limit the size of this\n             * array to 64K, this link is maintained only for the last 32K strings.\n             * An index in this array is thus a window index modulo 32K.\n             */\n            this.head = null;\n            /* Heads of the hash chains or NIL. */\n            this.ins_h = 0;\n            /* hash index of string to be inserted */\n            this.hash_size = 0;\n            /* number of elements in hash table */\n            this.hash_bits = 0;\n            /* log2(hash_size) */\n            this.hash_mask = 0;\n            /* hash_size-1 */\n            this.hash_shift = 0;\n            /* Number of bits by which ins_h must be shifted at each input\n             * step. It must be such that after MIN_MATCH steps, the oldest\n             * byte no longer takes part in the hash key, that is:\n             *   hash_shift * MIN_MATCH >= hash_bits\n             */\n            this.block_start = 0;\n            /* Window position at the beginning of the current output block. Gets\n             * negative when the window is moved backwards.\n             */\n            this.match_length = 0;\n            /* length of best match */\n            this.prev_match = 0;\n            /* previous match */\n            this.match_available = 0;\n            /* set if previous match exists */\n            this.strstart = 0;\n            /* start of string to insert */\n            this.match_start = 0;\n            /* start of matching string */\n            this.lookahead = 0;\n            /* number of valid bytes ahead in window */\n            this.prev_length = 0;\n            /* Length of the best match at previous step. Matches not greater than this\n             * are discarded. This is used in the lazy match evaluation.\n             */\n            this.max_chain_length = 0;\n            /* To speed up deflation, hash chains are never searched beyond this\n             * length.  A higher limit improves compression ratio but degrades the\n             * speed.\n             */\n            this.max_lazy_match = 0;\n            /* Attempt to find a better match only when the current match is strictly\n             * smaller than this value. This mechanism is used only for compression\n             * levels >= 4.\n             */\n            // That's alias to max_lazy_match, don't use directly\n            // this.max_insert_length = 0;\n            /* Insert new strings in the hash table only if the match length is not\n             * greater than this length. This saves time but degrades compression.\n             * max_insert_length is used only for compression levels <= 3.\n             */\n            this.level = 0;\n            /* compression level (1..9) */\n            this.strategy = 0;\n            /* favor or force Huffman coding */\n            this.good_match = 0;\n            /* Use a faster search when the previous match is longer than this */\n            this.nice_match = 0;\n            /* Stop searching when current match exceeds this */\n            /* used by trees.c: */\n            /* Didn't use ct_data typedef below to suppress compiler warning */\n            // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n            // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n            // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n            // Use flat array of DOUBLE size, with interleaved fata,\n            // because JS does not support effective\n            this.dyn_ltree = new Uint16Array(HEAP_SIZE$1 * 2);\n            this.dyn_dtree = new Uint16Array((2 * D_CODES$1 + 1) * 2);\n            this.bl_tree = new Uint16Array((2 * BL_CODES$1 + 1) * 2);\n            zero$1(this.dyn_ltree);\n            zero$1(this.dyn_dtree);\n            zero$1(this.bl_tree);\n            this.l_desc = null;\n            /* desc. for literal tree */\n            this.d_desc = null;\n            /* desc. for distance tree */\n            this.bl_desc = null;\n            /* desc. for bit length tree */\n            // ush bl_count[MAX_BITS+1];\n            this.bl_count = new Uint16Array(MAX_BITS$1 + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n            this.heap = new Uint16Array(2 * L_CODES$1 + 1);\n            /* heap used to build the Huffman trees */\n            zero$1(this.heap);\n            this.heap_len = 0;\n            /* number of elements in the heap */\n            this.heap_max = 0;\n            /* element of largest frequency */\n            /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n             * The same heap array is used to build all trees.\n             */\n            this.depth = new Uint16Array(2 * L_CODES$1 + 1); // uch depth[2*L_CODES+1];\n            zero$1(this.depth);\n            /* Depth of each subtree used as tie breaker for trees of equal frequency\n             */\n            this.l_buf = 0;\n            /* buffer index for literals or lengths */\n            this.lit_bufsize = 0;\n            /* Size of match buffer for literals/lengths.  There are 4 reasons for\n             * limiting lit_bufsize to 64K:\n             *   - frequencies can be kept in 16 bit counters\n             *   - if compression is not successful for the first block, all input\n             *     data is still in the window so we can still emit a stored block even\n             *     when input comes from standard input.  (This can also be done for\n             *     all blocks if lit_bufsize is not greater than 32K.)\n             *   - if compression is not successful for a file smaller than 64K, we can\n             *     even emit a stored file instead of a stored block (saving 5 bytes).\n             *     This is applicable only for zip (not gzip or zlib).\n             *   - creating new Huffman trees less frequently may not provide fast\n             *     adaptation to changes in the input data statistics. (Take for\n             *     example a binary file with poorly compressible code followed by\n             *     a highly compressible string table.) Smaller buffer sizes give\n             *     fast adaptation but have of course the overhead of transmitting\n             *     trees more frequently.\n             *   - I can't count above 4\n             */\n            this.last_lit = 0;\n            /* running index in l_buf */\n            this.d_buf = 0;\n            /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n             * the same number of elements. To use different lengths, an extra flag\n             * array would be necessary.\n             */\n            this.opt_len = 0;\n            /* bit length of current block with optimal trees */\n            this.static_len = 0;\n            /* bit length of current block with static trees */\n            this.matches = 0;\n            /* number of string matches in current block */\n            this.insert = 0;\n            /* bytes at end of window left to insert */\n            this.bi_buf = 0;\n            /* Output buffer. bits are inserted starting at the bottom (least\n             * significant bits).\n             */\n            this.bi_valid = 0;\n            /* Number of valid bits in bi_buf.  All bits above the last valid bit\n             * are always zero.\n             */\n            // Used for window memory init. We safely ignore it for JS. That makes\n            // sense only for pointers and memory check tools.\n            // this.high_water = 0;\n            /* High water mark offset in window for initialized bytes -- bytes above\n             * this are set to zero in order to avoid memory check warnings when\n             * longest match routines access bytes past the input.  This is then\n             * updated to the new high water mark.\n             */\n        }\n        var deflateResetKeep = function deflateResetKeep(strm) {\n            if (!strm || !strm.state) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.total_in = strm.total_out = 0;\n            strm.data_type = Z_UNKNOWN$1;\n            var s = strm.state;\n            s.pending = 0;\n            s.pending_out = 0;\n            if (s.wrap < 0) {\n                s.wrap = -s.wrap;\n                /* was made negative by deflate(..., Z_FINISH); */\n            }\n            s.status = s.wrap ? INIT_STATE : BUSY_STATE;\n            strm.adler =\n                s.wrap === 2\n                    ? 0 // crc32(0, Z_NULL, 0)\n                    : 1; // adler32(0, Z_NULL, 0)\n            s.last_flush = Z_NO_FLUSH;\n            _tr_init$1(s);\n            return Z_OK;\n        };\n        var deflateReset = function deflateReset(strm) {\n            var ret = deflateResetKeep(strm);\n            if (ret === Z_OK) {\n                lm_init(strm.state);\n            }\n            return ret;\n        };\n        var deflateSetHeader = function deflateSetHeader(strm, head) {\n            if (!strm || !strm.state) {\n                return Z_STREAM_ERROR;\n            }\n            if (strm.state.wrap !== 2) {\n                return Z_STREAM_ERROR;\n            }\n            strm.state.gzhead = head;\n            return Z_OK;\n        };\n        var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n            if (!strm) {\n                // === Z_NULL\n                return Z_STREAM_ERROR;\n            }\n            var wrap = 1;\n            if (level === Z_DEFAULT_COMPRESSION) {\n                level = 6;\n            }\n            if (windowBits < 0) {\n                /* suppress zlib wrapper */\n                wrap = 0;\n                windowBits = -windowBits;\n            }\n            else if (windowBits > 15) {\n                wrap = 2;\n                /* write gzip wrapper instead */\n                windowBits -= 16;\n            }\n            if (memLevel < 1 ||\n                memLevel > MAX_MEM_LEVEL ||\n                method !== Z_DEFLATED ||\n                windowBits < 8 ||\n                windowBits > 15 ||\n                level < 0 ||\n                level > 9 ||\n                strategy < 0 ||\n                strategy > Z_FIXED$1) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            if (windowBits === 8) {\n                windowBits = 9;\n            }\n            /* until 256-byte window bug fixed */\n            var s = new DeflateState();\n            strm.state = s;\n            s.strm = strm;\n            s.wrap = wrap;\n            s.gzhead = null;\n            s.w_bits = windowBits;\n            s.w_size = 1 << s.w_bits;\n            s.w_mask = s.w_size - 1;\n            s.hash_bits = memLevel + 7;\n            s.hash_size = 1 << s.hash_bits;\n            s.hash_mask = s.hash_size - 1;\n            s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);\n            s.window = new Uint8Array(s.w_size * 2);\n            s.head = new Uint16Array(s.hash_size);\n            s.prev = new Uint16Array(s.w_size); // Don't need mem init magic for JS.\n            // s.high_water = 0;  /* nothing written to s->window yet */\n            s.lit_bufsize = 1 << (memLevel + 6);\n            /* 16K elements by default */\n            s.pending_buf_size = s.lit_bufsize * 4;\n            // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n            // s->pending_buf = (uchf *) overlay;\n            // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n            s.pending_buf = new Uint8Array(s.pending_buf_size);\n            // s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n            s.d_buf = 1 * s.lit_bufsize; // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n            s.l_buf = (1 + 2) * s.lit_bufsize;\n            s.level = level;\n            s.strategy = strategy;\n            s.method = method;\n            return deflateReset(strm);\n        };\n        var deflateInit = function deflateInit(strm, level) {\n            return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n        };\n        var deflate = function deflate(strm, flush) {\n            var beg;\n            var val; // for gzip header write only\n            if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n                return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            if (!strm.output || (!strm.input && strm.avail_in !== 0) || (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n                return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);\n            }\n            s.strm = strm;\n            /* just in case */\n            var old_flush = s.last_flush;\n            s.last_flush = flush;\n            /* Write the header */\n            if (s.status === INIT_STATE) {\n                if (s.wrap === 2) {\n                    // GZIP header\n                    strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                    put_byte(s, 31);\n                    put_byte(s, 139);\n                    put_byte(s, 8);\n                    if (!s.gzhead) {\n                        // s->gzhead == Z_NULL\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, OS_CODE);\n                        s.status = BUSY_STATE;\n                    }\n                    else {\n                        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                            (s.gzhead.hcrc ? 2 : 0) +\n                            (!s.gzhead.extra ? 0 : 4) +\n                            (!s.gzhead.name ? 0 : 8) +\n                            (!s.gzhead.comment ? 0 : 16));\n                        put_byte(s, s.gzhead.time & 0xff);\n                        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, s.gzhead.os & 0xff);\n                        if (s.gzhead.extra && s.gzhead.extra.length) {\n                            put_byte(s, s.gzhead.extra.length & 0xff);\n                            put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n                        }\n                        if (s.gzhead.hcrc) {\n                            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);\n                        }\n                        s.gzindex = 0;\n                        s.status = EXTRA_STATE;\n                    }\n                } // DEFLATE header\n                else {\n                    var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n                    var level_flags = -1;\n                    if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n                        level_flags = 0;\n                    }\n                    else if (s.level < 6) {\n                        level_flags = 1;\n                    }\n                    else if (s.level === 6) {\n                        level_flags = 2;\n                    }\n                    else {\n                        level_flags = 3;\n                    }\n                    header |= level_flags << 6;\n                    if (s.strstart !== 0) {\n                        header |= PRESET_DICT;\n                    }\n                    header += 31 - (header % 31);\n                    s.status = BUSY_STATE;\n                    putShortMSB(s, header);\n                    /* Save the adler32 of the preset dictionary: */\n                    if (s.strstart !== 0) {\n                        putShortMSB(s, strm.adler >>> 16);\n                        putShortMSB(s, strm.adler & 0xffff);\n                    }\n                    strm.adler = 1; // adler32(0L, Z_NULL, 0);\n                }\n            } // #ifdef GZIP\n            if (s.status === EXTRA_STATE) {\n                if (s.gzhead.extra\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                break;\n                            }\n                        }\n                        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n                        s.gzindex++;\n                    }\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (s.gzindex === s.gzhead.extra.length) {\n                        s.gzindex = 0;\n                        s.status = NAME_STATE;\n                    }\n                }\n                else {\n                    s.status = NAME_STATE;\n                }\n            }\n            if (s.status === NAME_STATE) {\n                if (s.gzhead.name\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.name.length) {\n                            val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.gzindex = 0;\n                        s.status = COMMENT_STATE;\n                    }\n                }\n                else {\n                    s.status = COMMENT_STATE;\n                }\n            }\n            if (s.status === COMMENT_STATE) {\n                if (s.gzhead.comment\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.comment.length) {\n                            val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.status = HCRC_STATE;\n                    }\n                }\n                else {\n                    s.status = HCRC_STATE;\n                }\n            }\n            if (s.status === HCRC_STATE) {\n                if (s.gzhead.hcrc) {\n                    if (s.pending + 2 > s.pending_buf_size) {\n                        flush_pending(strm);\n                    }\n                    if (s.pending + 2 <= s.pending_buf_size) {\n                        put_byte(s, strm.adler & 0xff);\n                        put_byte(s, (strm.adler >> 8) & 0xff);\n                        strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                        s.status = BUSY_STATE;\n                    }\n                }\n                else {\n                    s.status = BUSY_STATE;\n                }\n            } // #endif\n            /* Flush as much pending output as possible */\n            if (s.pending !== 0) {\n                flush_pending(strm);\n                if (strm.avail_out === 0) {\n                    /* Since avail_out is 0, deflate will be called again with\n                     * more output space, but possibly with both pending and\n                     * avail_in equal to zero. There won't be anything to do,\n                     * but this is not an error situation so make sure we\n                     * return OK instead of BUF_ERROR at next call of deflate:\n                     */\n                    s.last_flush = -1;\n                    return Z_OK;\n                }\n                /* Make sure there is something to do and avoid duplicate consecutive\n                 * flushes. For repeated and useless calls with Z_FINISH, we keep\n                 * returning Z_STREAM_END instead of Z_BUF_ERROR.\n                 */\n            }\n            else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* User must not provide more input after the first FINISH: */\n            if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* Start a new block or continue the current one.\n             */\n            if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n                var bstate = s.strategy === Z_HUFFMAN_ONLY\n                    ? deflate_huff(s, flush)\n                    : s.strategy === Z_RLE\n                        ? deflate_rle(s, flush)\n                        : configuration_table[s.level].func(s, flush);\n                if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n                    s.status = FINISH_STATE;\n                }\n                if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR next call, see above */\n                    }\n                    return Z_OK;\n                    /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n                     * of deflate should use the same flush parameter to make sure\n                     * that the flush is complete. So we don't have to output an\n                     * empty block here, this will be done at next call. This also\n                     * ensures that for a very small output buffer, we emit at most\n                     * one empty block.\n                     */\n                }\n                if (bstate === BS_BLOCK_DONE) {\n                    if (flush === Z_PARTIAL_FLUSH) {\n                        _tr_align$1(s);\n                    }\n                    else if (flush !== Z_BLOCK) {\n                        /* FULL_FLUSH or SYNC_FLUSH */\n                        _tr_stored_block$1(s, 0, 0, false);\n                        /* For a full flush, this empty block will be recognized\n                         * as a special marker by inflate_sync().\n                         */\n                        if (flush === Z_FULL_FLUSH) {\n                            /** * CLEAR_HASH(s); ** */\n                            /* forget history */\n                            zero$1(s.head); // Fill with NIL (= 0);\n                            if (s.lookahead === 0) {\n                                s.strstart = 0;\n                                s.block_start = 0;\n                                s.insert = 0;\n                            }\n                        }\n                    }\n                    flush_pending(strm);\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR at next call, see above */\n                        return Z_OK;\n                    }\n                }\n            } // Assert(strm->avail_out > 0, \"bug2\");\n            // if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n            if (flush !== Z_FINISH) {\n                return Z_OK;\n            }\n            if (s.wrap <= 0) {\n                return Z_STREAM_END;\n            }\n            /* Write the trailer */\n            if (s.wrap === 2) {\n                put_byte(s, strm.adler & 0xff);\n                put_byte(s, (strm.adler >> 8) & 0xff);\n                put_byte(s, (strm.adler >> 16) & 0xff);\n                put_byte(s, (strm.adler >> 24) & 0xff);\n                put_byte(s, strm.total_in & 0xff);\n                put_byte(s, (strm.total_in >> 8) & 0xff);\n                put_byte(s, (strm.total_in >> 16) & 0xff);\n                put_byte(s, (strm.total_in >> 24) & 0xff);\n            }\n            else {\n                putShortMSB(s, strm.adler >>> 16);\n                putShortMSB(s, strm.adler & 0xffff);\n            }\n            flush_pending(strm);\n            /* If avail_out is zero, the application will call deflate again\n             * to flush the rest.\n             */\n            if (s.wrap > 0) {\n                s.wrap = -s.wrap;\n            }\n            /* write the trailer only once! */\n            return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n        };\n        var deflateEnd = function deflateEnd(strm) {\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var status = strm.state.status;\n            if (status !== INIT_STATE &&\n                status !== EXTRA_STATE &&\n                status !== NAME_STATE &&\n                status !== COMMENT_STATE &&\n                status !== HCRC_STATE &&\n                status !== BUSY_STATE &&\n                status !== FINISH_STATE) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.state = null;\n            return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n        };\n        /* =========================================================================\n         * Initializes the compression dictionary from the given byte\n         * sequence without producing any compressed output.\n         */\n        var deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {\n            var dictLength = dictionary.length;\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            var wrap = s.wrap;\n            if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n                return Z_STREAM_ERROR;\n            }\n            /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n            if (wrap === 1) {\n                /* adler32(strm->adler, dictionary, dictLength); */\n                strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);\n            }\n            s.wrap = 0;\n            /* avoid computing Adler-32 in read_buf */\n            /* if dictionary would fill window, just replace the history */\n            if (dictLength >= s.w_size) {\n                if (wrap === 0) {\n                    /* already empty otherwise */\n                    /** * CLEAR_HASH(s); ** */\n                    zero$1(s.head); // Fill with NIL (= 0);\n                    s.strstart = 0;\n                    s.block_start = 0;\n                    s.insert = 0;\n                }\n                /* use the tail */\n                // dictionary = dictionary.slice(dictLength - s.w_size);\n                var tmpDict = new Uint8Array(s.w_size);\n                tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);\n                dictionary = tmpDict;\n                dictLength = s.w_size;\n            }\n            /* insert dictionary into window and hash */\n            var avail = strm.avail_in;\n            var next = strm.next_in;\n            var input = strm.input;\n            strm.avail_in = dictLength;\n            strm.next_in = 0;\n            strm.input = dictionary;\n            fill_window(s);\n            while (s.lookahead >= MIN_MATCH$1) {\n                var str = s.strstart;\n                var n = s.lookahead - (MIN_MATCH$1 - 1);\n                do {\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                    s.prev[str & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = str;\n                    str++;\n                } while (--n);\n                s.strstart = str;\n                s.lookahead = MIN_MATCH$1 - 1;\n                fill_window(s);\n            }\n            s.strstart += s.lookahead;\n            s.block_start = s.strstart;\n            s.insert = s.lookahead;\n            s.lookahead = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            strm.next_in = next;\n            strm.input = input;\n            strm.avail_in = avail;\n            s.wrap = wrap;\n            return Z_OK;\n        };\n        var deflateInit_1 = deflateInit;\n        var deflateInit2_1 = deflateInit2;\n        var deflateReset_1 = deflateReset;\n        var deflateResetKeep_1 = deflateResetKeep;\n        var deflateSetHeader_1 = deflateSetHeader;\n        var deflate_2 = deflate;\n        var deflateEnd_1 = deflateEnd;\n        var deflateSetDictionary_1 = deflateSetDictionary;\n        var deflateInfo = 'pako deflate (from Nodeca project)';\n        /* Not implemented\n      module.exports.deflateBound = deflateBound;\n      module.exports.deflateCopy = deflateCopy;\n      module.exports.deflateParams = deflateParams;\n      module.exports.deflatePending = deflatePending;\n      module.exports.deflatePrime = deflatePrime;\n      module.exports.deflateTune = deflateTune;\n      */\n        var deflate_1 = {\n            deflateInit: deflateInit_1,\n            deflateInit2: deflateInit2_1,\n            deflateReset: deflateReset_1,\n            deflateResetKeep: deflateResetKeep_1,\n            deflateSetHeader: deflateSetHeader_1,\n            deflate: deflate_2,\n            deflateEnd: deflateEnd_1,\n            deflateSetDictionary: deflateSetDictionary_1,\n            deflateInfo: deflateInfo,\n        };\n        // Join array of chunks to single array.\n        function flattenChunks(chunks) {\n            // calculate data length\n            var len = 0;\n            for (var i = 0, l = chunks.length; i < l; i++) {\n                len += chunks[i].length;\n            } // join chunks\n            var result = new Uint8Array(len);\n            for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {\n                var chunk = chunks[_i];\n                result.set(chunk, pos);\n                pos += chunk.length;\n            }\n            return result;\n        }\n        // String encode/decode helpers\n        //\n        // - apply(Array) can fail on Android 2.2\n        // - apply(Uint8Array) can fail on iOS 5.1 Safari\n        //\n        // Table with utf8 lengths (calculated by first byte of sequence)\n        // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n        // because max possible codepoint is 0x10ffff\n        var _utf8len = new Uint8Array(256);\n        for (var q = 0; q < 256; q++) {\n            _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;\n        }\n        _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n        // convert string to array (typed, when possible)\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        function ZStream() {\n            /* next input byte */\n            this.input = null; // JS specific, because we have no pointers\n            this.next_in = 0;\n            /* number of bytes available at input */\n            this.avail_in = 0;\n            /* total number of input bytes read so far */\n            this.total_in = 0;\n            /* next output byte should be put there */\n            this.output = null; // JS specific, because we have no pointers\n            this.next_out = 0;\n            /* remaining free space at output */\n            this.avail_out = 0;\n            /* total number of bytes output so far */\n            this.total_out = 0;\n            /* last error message, NULL if no error */\n            this.msg = '';\n            /* Z_NULL */\n            /* not visible by applications */\n            this.state = null;\n            /* best guess about the data type: binary or text */\n            this.data_type = 2;\n            /* Z_UNKNOWN */\n            /* adler32 value of the uncompressed data */\n            this.adler = 0;\n        }\n        var zstream = ZStream;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var toString = Object.prototype.toString;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH$1 = constants.Z_NO_FLUSH;\n        var Z_SYNC_FLUSH = constants.Z_SYNC_FLUSH;\n        var Z_FULL_FLUSH$1 = constants.Z_FULL_FLUSH;\n        var Z_FINISH$1 = constants.Z_FINISH;\n        var Z_OK$1 = constants.Z_OK;\n        var Z_STREAM_END$1 = constants.Z_STREAM_END;\n        var Z_DEFAULT_COMPRESSION$1 = constants.Z_DEFAULT_COMPRESSION;\n        var Z_DEFAULT_STRATEGY$1 = constants.Z_DEFAULT_STRATEGY;\n        var Z_DEFLATED$1 = constants.Z_DEFLATED;\n        /* =========================================================================== */\n        /**\n         * class Deflate\n         *\n         * Generic JS-style wrapper for zlib calls. If you don't need\n         * streaming behaviour - use more simple functions: [[deflate]],\n         * [[deflateRaw]] and [[gzip]].\n         * */\n        /* internal\n         * Deflate.chunks -> Array\n         *\n         * Chunks of output data, if [[Deflate#onData]] not overridden.\n         * */\n        /**\n         * Deflate.result -> Uint8Array\n         *\n         * Compressed result, generated by default [[Deflate#onData]]\n         * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n         * (call [[Deflate#push]] with `Z_FINISH` / `true` param).\n         * */\n        /**\n         * Deflate.err -> Number\n         *\n         * Error code after deflate finished. 0 (Z_OK) on success.\n         * You will not need it in real life, because deflate errors\n         * are possible only on wrong options or bad `onData` / `onEnd`\n         * custom handlers.\n         * */\n        /**\n         * Deflate.msg -> String\n         *\n         * Error message, if [[Deflate.err]] != 0\n         * */\n        /**\n         * new Deflate(options)\n         * - options (Object): zlib deflate options.\n         *\n         * Creates new deflator instance with specified params. Throws exception\n         * on bad params. Supported options:\n         *\n         * - `level`\n         * - `windowBits`\n         * - `memLevel`\n         * - `strategy`\n         * - `dictionary`\n         *\n         * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n         * for more information on these.\n         *\n         * Additional options, for internal needs:\n         *\n         * * `chunkSize` - size of generated data chunks (16K by default)\n         * * `raw` (Boolean) - do raw deflate\n         * * `gzip` (Boolean) - create gzip wrapper\n         * * `header` (Object) - custom header for gzip\n         * ** `text` (Boolean) - true if compressed data believed to be text\n         * ** `time` (Number) - modification time, unix timestamp\n         * ** `os` (Number) - operation system code\n         * ** `extra` (Array) - array of bytes with extra data (max 65536)\n         * ** `name` (String) - file name (binary string)\n         * ** `comment` (String) - comment (binary string)\n         * ** `hcrc` (Boolean) - true if header crc should be added\n         *\n         * ##### Example:\n         *\n         * ```javascript\n         * const pako = require('pako')\n         *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n         *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n         *\n         * const deflate = new pako.Deflate({ level: 3});\n         *\n         * deflate.push(chunk1, false);\n         * deflate.push(chunk2, true);  // true -> last chunk\n         *\n         * if (deflate.err) { throw new Error(deflate.err); }\n         *\n         * console.log(deflate.result);\n         * ```\n         * */\n        function Deflate() {\n            this.options = {\n                level: Z_DEFAULT_COMPRESSION$1,\n                method: Z_DEFLATED$1,\n                chunkSize: 16384,\n                windowBits: 15,\n                memLevel: 8,\n                strategy: Z_DEFAULT_STRATEGY$1,\n            };\n            var opt = this.options;\n            if (opt.raw && opt.windowBits > 0) {\n                opt.windowBits = -opt.windowBits;\n            }\n            else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {\n                opt.windowBits += 16;\n            }\n            this.err = 0; // error code, if happens (0 = Z_OK)\n            this.msg = ''; // error message\n            this.ended = false; // used to avoid multiple onEnd() calls\n            this.chunks = []; // chunks of compressed data\n            this.strm = new zstream();\n            this.strm.avail_out = 0;\n            var status = deflate_1.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);\n            if (status !== Z_OK$1) {\n                throw new Error(messages[status]);\n            }\n            if (opt.header) {\n                deflate_1.deflateSetHeader(this.strm, opt.header);\n            }\n            if (opt.dictionary) {\n                var dict; // Convert data if needed\n                if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n                    dict = new Uint8Array(opt.dictionary);\n                }\n                else {\n                    dict = opt.dictionary;\n                }\n                status = deflate_1.deflateSetDictionary(this.strm, dict);\n                if (status !== Z_OK$1) {\n                    throw new Error(messages[status]);\n                }\n                this._dict_set = true;\n            }\n        }\n        /**\n         * Deflate#push(data[, flush_mode]) -> Boolean\n         * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be\n         * converted to utf8 byte sequence.\n         * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n         * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n         *\n         * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n         * new compressed chunks. Returns `true` on success. The last data block must\n         * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending\n         * buffers and call [[Deflate#onEnd]].\n         *\n         * On fail call [[Deflate#onEnd]] with error code and return false.\n         *\n         * ##### Example\n         *\n         * ```javascript\n         * push(chunk, false); // push one of data chunks\n         * ...\n         * push(chunk, true);  // push last chunk\n         * ```\n         * */\n        Deflate.prototype.push = function (data, flush_mode) {\n            var strm = this.strm;\n            var chunkSize = this.options.chunkSize;\n            var status;\n            var _flush_mode;\n            if (this.ended) {\n                return false;\n            }\n            if (flush_mode === ~~flush_mode) {\n                _flush_mode = flush_mode;\n            }\n            else {\n                _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;\n            } // Convert data if needed\n            if (toString.call(data) === '[object ArrayBuffer]') {\n                strm.input = new Uint8Array(data);\n            }\n            else {\n                strm.input = data;\n            }\n            strm.next_in = 0;\n            strm.avail_in = strm.input.length;\n            for (;;) {\n                if (strm.avail_out === 0) {\n                    strm.output = new Uint8Array(chunkSize);\n                    strm.next_out = 0;\n                    strm.avail_out = chunkSize;\n                } // Make sure avail_out > 6 to avoid repeating markers\n                if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                status = deflate_1.deflate(strm, _flush_mode); // Ended => flush and finish\n                if (status === Z_STREAM_END$1) {\n                    if (strm.next_out > 0) {\n                        this.onData(strm.output.subarray(0, strm.next_out));\n                    }\n                    status = deflate_1.deflateEnd(this.strm);\n                    this.onEnd(status);\n                    this.ended = true;\n                    return status === Z_OK$1;\n                } // Flush if out buffer full\n                if (strm.avail_out === 0) {\n                    this.onData(strm.output);\n                    continue;\n                } // Flush if requested and has data\n                if (_flush_mode > 0 && strm.next_out > 0) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                if (strm.avail_in === 0) {\n                    break;\n                }\n            }\n            return true;\n        };\n        /**\n         * Deflate#onData(chunk) -> Void\n         * - chunk (Uint8Array): output data.\n         *\n         * By default, stores data blocks in `chunks[]` property and glue\n         * those in `onEnd`. Override this handler, if you need another behaviour.\n         * */\n        Deflate.prototype.onData = function (chunk) {\n            this.chunks.push(chunk);\n        };\n        /**\n         * Deflate#onEnd(status) -> Void\n         * - status (Number): deflate status. 0 (Z_OK) on success,\n         * other if not.\n         *\n         * Called once after you tell deflate that the input stream is\n         * complete (Z_FINISH). By default - join collected chunks,\n         * free memory and fill `results` / `err` properties.\n         * */\n        Deflate.prototype.onEnd = function (status) {\n            // On success - join\n            if (status === Z_OK$1) {\n                this.result = flattenChunks(this.chunks);\n            }\n            this.chunks = [];\n            this.err = status;\n            this.msg = this.strm.msg;\n        };\n        // https://github.com/nodeca/pako/blob/26dff4fb3472c5532b3bd8856421146d35ab7592/lib/utils/strings.js#L26\n        function string2buf(str) {\n            if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n                return new TextEncoder().encode(str);\n            }\n            var buf;\n            var c;\n            var c2;\n            var m_pos;\n            var i;\n            var str_len = str.length;\n            var buf_len = 0;\n            // count binary size\n            for (m_pos = 0; m_pos < str_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n            }\n            // allocate buffer\n            buf = new Uint8Array(buf_len);\n            // convert\n            for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                if (c < 0x80) {\n                    /* one byte */\n                    buf[i++] = c;\n                }\n                else if (c < 0x800) {\n                    /* two bytes */\n                    buf[i++] = 0xc0 | (c >>> 6);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else if (c < 0x10000) {\n                    /* three bytes */\n                    buf[i++] = 0xe0 | (c >>> 12);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else {\n                    /* four bytes */\n                    buf[i++] = 0xf0 | (c >>> 18);\n                    buf[i++] = 0x80 | ((c >>> 12) & 0x3f);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n            }\n            return buf;\n        }\n        return { Deflate: Deflate, constants: constants, string2buf: string2buf };\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { Segment } from './segment';\nexport var SEGMENT_DURATION_LIMIT = 30 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport var SEGMENT_BYTES_LIMIT = 60000;\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as many records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment bytes count reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\nexport function startSegmentCollection(lifeCycle, applicationId, sessionManager, viewContexts, httpRequest, worker) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(applicationId, sessionManager, viewContexts); }, httpRequest, worker);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, worker) {\n    var state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribePageExited = lifeCycle.subscribe(9 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n        flushSegment(pageExitEvent.reason);\n    }).unsubscribe;\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush(flushReason);\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* SegmentCollectionStatus.Stopped */,\n            };\n        }\n    }\n    function createNewSegment(creationReason, initialRecord) {\n        var context = getSegmentContext();\n        if (!context) {\n            return;\n        }\n        var segment = new Segment(worker, context, creationReason, initialRecord, function (compressedSegmentBytesCount) {\n            if (!segment.flushReason && compressedSegmentBytesCount > SEGMENT_BYTES_LIMIT) {\n                flushSegment('segment_bytes_limit');\n            }\n        }, function (data, rawSegmentBytesCount) {\n            var payload = buildReplayPayload(data, segment.metadata, rawSegmentBytesCount);\n            if (isPageExitReason(segment.flushReason)) {\n                httpRequest.sendOnExit(payload);\n            }\n            else {\n                httpRequest.send(payload);\n            }\n        });\n        state = {\n            status: 1 /* SegmentCollectionStatus.SegmentPending */,\n            segment: segment,\n            expirationTimeoutId: setTimeout(function () {\n                flushSegment('segment_duration_limit');\n            }, SEGMENT_DURATION_LIMIT),\n        };\n    }\n    return {\n        addRecord: function (record) {\n            switch (state.status) {\n                case 0 /* SegmentCollectionStatus.WaitingForInitialRecord */:\n                    createNewSegment(state.nextSegmentCreationReason, record);\n                    break;\n                case 1 /* SegmentCollectionStatus.SegmentPending */:\n                    state.segment.addRecord(record);\n                    break;\n            }\n        },\n        stop: function () {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewContexts) {\n    var session = sessionManager.findTrackedSession();\n    var viewContext = viewContexts.findView();\n    if (!session || !viewContext) {\n        return undefined;\n    }\n    return {\n        application: {\n            id: applicationId,\n        },\n        session: {\n            id: session.id,\n        },\n        view: {\n            id: viewContext.id,\n        },\n    };\n}\nexport function setSegmentBytesLimit(newSegmentBytesLimit) {\n    if (newSegmentBytesLimit === void 0) { newSegmentBytesLimit = 60000; }\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { assign } from '@datadog/browser-core';\nexport function buildReplayPayload(data, metadata, rawSegmentBytesCount) {\n    var formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), \"\".concat(metadata.session.id, \"-\").concat(metadata.start));\n    var metadataAndSegmentSizes = assign({\n        raw_segment_size: rawSegmentBytesCount,\n        compressed_segment_size: data.byteLength,\n    }, metadata);\n    var serializedMetadataAndSegmentSizes = JSON.stringify(metadataAndSegmentSizes);\n    formData.append('event', new Blob([serializedMetadataAndSegmentSizes], { type: 'application/json' }));\n    return { data: formData, bytesCount: data.byteLength };\n}\n//# sourceMappingURL=buildReplayPayload.js.map","import { addTelemetryError, display, includes, addEventListener } from '@datadog/browser-core';\nimport { createDeflateWorker } from './deflateWorker';\nvar state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(callback, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    switch (state.status) {\n        case 0 /* DeflateWorkerStatus.Nil */:\n            state = { status: 1 /* DeflateWorkerStatus.Loading */, callbacks: [callback] };\n            doStartDeflateWorker(createDeflateWorkerImpl);\n            break;\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.callbacks.push(callback);\n            break;\n        case 2 /* DeflateWorkerStatus.Error */:\n            callback();\n            break;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            callback(state.worker);\n            break;\n    }\n}\nexport function resetDeflateWorkerState() {\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker_1 = createDeflateWorkerImpl();\n        addEventListener(worker_1, 'error', onError);\n        addEventListener(worker_1, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(data.error);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(worker_1);\n            }\n        });\n        worker_1.postMessage({ action: 'init' });\n        return worker_1;\n    }\n    catch (error) {\n        onError(error);\n    }\n}\nfunction onInitialized(worker) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.callbacks.forEach(function (callback) { return callback(worker); });\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: worker };\n    }\n}\nfunction onError(error) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error('Session Replay recording failed to start: an error occurred while creating the Worker:', error);\n        if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n            display.error('Please make sure CSP is correctly configured ' +\n                'https://docs.datadoghq.com/real_user_monitoring/faq/content_security_policy');\n        }\n        else {\n            addTelemetryError(error);\n        }\n        state.callbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error);\n    }\n}\nfunction isMessageCspRelated(message) {\n    return (includes(message, 'Content Security Policy') ||\n        // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n        includes(message, \"requires 'TrustedScriptURL'\"));\n}\n//# sourceMappingURL=startDeflateWorker.js.map","/**\n * Test for Browser features used while recording\n */\nexport function isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' &&\n        typeof CSSSupportsRule === 'function' &&\n        typeof URL.createObjectURL === 'function' &&\n        'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=isBrowserSupported.js.map","import { getSessionReplayUrl } from '@datadog/browser-rum-core';\nimport { isBrowserSupported } from '../boot/isBrowserSupported';\nexport function getSessionReplayLink(configuration, sessionManager, viewContexts, isRecordingStarted) {\n    var session = sessionManager.findTrackedSession();\n    var errorType = getErrorType(session, isRecordingStarted);\n    var viewContext = viewContexts.findView();\n    return getSessionReplayUrl(configuration, {\n        viewContext: viewContext,\n        errorType: errorType,\n        session: session,\n    });\n}\nfunction getErrorType(session, isRecordingStarted) {\n    if (!isBrowserSupported()) {\n        return 'browser-not-supported';\n    }\n    if (!session) {\n        // possibilities:\n        // - rum sampled out\n        // - session expired (edge case)\n        return 'rum-not-tracked';\n    }\n    if (!session.sessionReplayAllowed) {\n        // possibilities\n        // - replay sampled out\n        return 'incorrect-session-plan';\n    }\n    if (!isRecordingStarted) {\n        return 'replay-not-started';\n    }\n}\n//# sourceMappingURL=getSessionReplayLink.js.map","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { startRecording } from '../boot/startRecording';\nimport { makeRecorderApi } from '../boot/recorderApi';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi);\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats } from '../domain/replayStats';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { startDeflateWorker } from '../domain/segmentCollection';\nimport { isBrowserSupported } from './isBrowserSupported';\nexport function makeRecorderApi(startRecordingImpl, startDeflateWorkerImpl) {\n    if (startDeflateWorkerImpl === void 0) { startDeflateWorkerImpl = startDeflateWorker; }\n    if (canUseEventBridge() || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n            getSessionReplayLink: function () { return undefined; },\n        };\n    }\n    var state = {\n        status: 0 /* RecorderStatus.Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* RecorderStatus.IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* RecorderStatus.Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getReplayStats: getReplayStats,\n        getSessionReplayLink: function (configuration, sessionManager, viewContexts) {\n            return getSessionReplayLink(configuration, sessionManager, viewContexts, state.status !== 0 /* RecorderStatus.Stopped */);\n        },\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts) {\n            lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n                if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.sessionReplayAllowed) {\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    return;\n                }\n                state = { status: 2 /* RecorderStatus.Starting */ };\n                runOnReadyState('interactive', function () {\n                    if (state.status !== 2 /* RecorderStatus.Starting */) {\n                        return;\n                    }\n                    startDeflateWorkerImpl(function (worker) {\n                        if (state.status !== 2 /* RecorderStatus.Starting */) {\n                            return;\n                        }\n                        if (!worker) {\n                            state = {\n                                status: 0 /* RecorderStatus.Stopped */,\n                            };\n                            return;\n                        }\n                        var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, worker).stop;\n                        state = {\n                            status: 3 /* RecorderStatus.Started */,\n                            stopRecording: stopRecording,\n                        };\n                    });\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* RecorderStatus.Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* RecorderStatus.Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* RecorderStatus.Stopped */,\n                };\n            };\n            if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () { return state.status === 3 /* RecorderStatus.Started */; },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { timeStampNow, createHttpRequest } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, worker, httpRequest) {\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, viewContexts, replayRequest, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n    }), stopRecording = _b.stop, takeSubsequentFullSnapshot = _b.takeSubsequentFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function () {\n        flushMutations();\n        addRecord({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        takeSubsequentFullSnapshot(view.startClocks.timeStamp);\n    }).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { noop, willSyntheticsInjectRum, assign, BoundedBuffer, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, checkUser, sanitizeUser, sanitize, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nexport function makeRumPublicApi(startRumImpl, recorderApi, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.ignoreInitIfSyntheticsWillInjectRum, ignoreInitIfSyntheticsWillInjectRum = _c === void 0 ? true : _c;\n    var isAlreadyInitialized = false;\n    var globalContextManager = createContextManager(\"global context\" /* CustomerDataType.GlobalContext */);\n    var userContextManager = createContextManager(\"user\" /* CustomerDataType.User */);\n    var getInternalContextStrategy = function () { return undefined; };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var stopSessionStrategy = noop;\n    var getSessionReplayLinkStrategy = function () { return undefined; };\n    var bufferApiCalls = new BoundedBuffer();\n    var addTimingStrategy = function (name, time) {\n        if (time === void 0) { time = timeStampNow(); }\n        bufferApiCalls.add(function () { return addTimingStrategy(name, time); });\n    };\n    var startViewStrategy = function (options, startClocks) {\n        if (startClocks === void 0) { startClocks = clocksNow(); }\n        bufferApiCalls.add(function () { return startViewStrategy(options, startClocks); });\n    };\n    var addActionStrategy = function (action, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    var addFeatureFlagEvaluationStrategy = function (key, value) {\n        bufferApiCalls.add(function () { return addFeatureFlagEvaluationStrategy(key, value); });\n    };\n    function initRum(initConfiguration) {\n        // This function should be available, regardless of initialization success.\n        getInitConfigurationStrategy = function () { return deepClone(initConfiguration); };\n        // If we are in a Synthetics test configured to automatically inject a RUM instance, we want to\n        // completely discard the customer application RUM instance by ignoring their init() call.  But,\n        // we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n        // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n        if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n            return;\n        }\n        var eventBridgeAvailable = canUseEventBridge();\n        if (eventBridgeAvailable) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        if (!canInitRum(initConfiguration)) {\n            return;\n        }\n        var configuration = validateAndBuildRumConfiguration(initConfiguration);\n        if (!configuration) {\n            return;\n        }\n        if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {\n            display.warn('No storage available for session. We will not send any data.');\n            return;\n        }\n        if (!configuration.trackViewsManually) {\n            doStartRum(initConfiguration, configuration);\n        }\n        else {\n            // drain beforeInitCalls by buffering them until we start RUM\n            // if we get a startView, drain re-buffered calls before continuing to drain beforeInitCalls\n            // in order to ensure that calls are processed in order\n            var beforeInitCalls = bufferApiCalls;\n            bufferApiCalls = new BoundedBuffer();\n            startViewStrategy = function (options) {\n                doStartRum(initConfiguration, configuration, options);\n            };\n            beforeInitCalls.drain();\n        }\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(initConfiguration, configuration, initialViewOptions) {\n        var startRumResults = startRumImpl(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions);\n        getSessionReplayLinkStrategy = function () {\n            return recorderApi.getSessionReplayLink(configuration, startRumResults.session, startRumResults.viewContexts);\n        };\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, addFeatureFlagEvaluationStrategy = startRumResults.addFeatureFlagEvaluation, getInternalContextStrategy = startRumResults.getInternalContext, stopSessionStrategy = startRumResults.stopSession);\n        bufferApiCalls.drain();\n        recorderApi.onRumStart(startRumResults.lifeCycle, configuration, startRumResults.session, startRumResults.viewContexts);\n    }\n    var startView = monitor(function (options) {\n        var sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        startViewStrategy(sanitizedOptions);\n    });\n    var rumPublicApi = makePublicApi({\n        init: monitor(initRum),\n        /** @deprecated: use setGlobalContextProperty instead */\n        addRumGlobalContext: monitor(globalContextManager.add),\n        setGlobalContextProperty: monitor(globalContextManager.setContextProperty),\n        /** @deprecated: use removeGlobalContextProperty instead */\n        removeRumGlobalContext: monitor(globalContextManager.remove),\n        removeGlobalContextProperty: monitor(globalContextManager.removeContextProperty),\n        /** @deprecated: use getGlobalContext instead */\n        getRumGlobalContext: monitor(globalContextManager.get),\n        getGlobalContext: monitor(globalContextManager.getContext),\n        /** @deprecated: use setGlobalContext instead */\n        setRumGlobalContext: monitor(globalContextManager.set),\n        setGlobalContext: monitor(globalContextManager.setContext),\n        clearGlobalContext: monitor(globalContextManager.clearContext),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        addAction: monitor(function (name, context) {\n            addActionStrategy({\n                name: sanitize(name),\n                context: sanitize(context),\n                startClocks: clocksNow(),\n                type: \"custom\" /* ActionType.CUSTOM */,\n            });\n        }),\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                addErrorStrategy({\n                    error: error,\n                    handlingStack: handlingStack,\n                    context: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            addTimingStrategy(sanitize(name), time);\n        }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(userContextManager.getContext),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n        }),\n        removeUserProperty: monitor(userContextManager.removeContextProperty),\n        /** @deprecated: renamed to clearUser */\n        removeUser: monitor(userContextManager.clearContext),\n        clearUser: monitor(userContextManager.clearContext),\n        startView: startView,\n        stopSession: monitor(function () {\n            stopSessionStrategy();\n        }),\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n        /**\n         * This feature is currently in beta. For more information see the full [feature flag tracking guide](https://docs.datadoghq.com/real_user_monitoring/feature_flag_tracking/).\n         */\n        addFeatureFlagEvaluation: monitor(function (key, value) {\n            addFeatureFlagEvaluationStrategy(sanitize(key), sanitize(value));\n        }),\n        getSessionReplayLink: monitor(function () { return getSessionReplayLinkStrategy(); }),\n    });\n    return rumPublicApi;\n    function canInitRum(initConfiguration) {\n        if (isAlreadyInitialized) {\n            if (!initConfiguration.silentMultipleInit) {\n                display.error('DD_RUM is already initialized.');\n            }\n            return false;\n        }\n        return true;\n    }\n    function overrideInitConfigurationForBridge(initConfiguration) {\n        return assign({}, initConfiguration, {\n            applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n            clientToken: 'empty',\n            sessionSampleRate: 100,\n        });\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","import { sendToExtension, createPageExitObservable, addTelemetryConfiguration, startTelemetry, canUseEventBridge, getEventBridge, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startForegroundContexts } from '../domain/contexts/foregroundContexts';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewContexts } from '../domain/contexts/viewContexts';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/rumEventsCollection/action/actionCollection';\nimport { startErrorCollection } from '../domain/rumEventsCollection/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/rumEventsCollection/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/rumEventsCollection/resource/resourceCollection';\nimport { startViewCollection } from '../domain/rumEventsCollection/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { serializeRumConfiguration } from '../domain/configuration';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nexport function startRum(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions) {\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) { return sendToExtension('rum', event); });\n    var telemetry = startRumTelemetry(configuration);\n    telemetry.setContextProvider(function () {\n        var _a, _b;\n        return ({\n            application: {\n                id: configuration.applicationId,\n            },\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n            view: {\n                id: (_b = viewContexts.findView()) === null || _b === void 0 ? void 0 : _b.id,\n            },\n            action: {\n                id: actionContexts.findActionId(),\n            },\n        });\n    });\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle);\n    var pageExitObservable = createPageExitObservable();\n    pageExitObservable.subscribe(function (event) {\n        lifeCycle.notify(9 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    var session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        var batch = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable);\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batch.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, domMutationObservable, function () { return buildCommonContext(globalContextManager, userContextManager, recorderApi); }, reportError), viewContexts = _a.viewContexts, foregroundContexts = _a.foregroundContexts, pageStateHistory = _a.pageStateHistory, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction;\n    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n    startLongTaskCollection(lifeCycle, session);\n    startResourceCollection(lifeCycle, configuration, session, pageStateHistory);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView;\n    var addError = startErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    startPerformanceCollection(lifeCycle, configuration);\n    var internalContext = startInternalContext(configuration.applicationId, session, viewContexts, actionContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n        session: session,\n        stopSession: function () { return session.expire(); },\n        getInternalContext: internalContext.get,\n    };\n}\nfunction startRumTelemetry(configuration) {\n    var telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, domMutationObservable, buildCommonContext, reportError) {\n    var viewContexts = startViewContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var foregroundContexts = startForegroundContexts();\n    var pageStateHistory = startPageStateHistory();\n    var _a = startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, buildCommonContext, reportError);\n    return {\n        viewContexts: viewContexts,\n        foregroundContexts: foregroundContexts,\n        pageStateHistory: pageStateHistory,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            viewContexts.stop();\n            foregroundContexts.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nexport function startLongTaskCollection(lifeCycle, sessionManager) {\n    lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType !== 'longtask') {\n                break;\n            }\n            var session = sessionManager.findTrackedSession(entry.startTime);\n            if (!session || !session.longTaskAllowed) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry.toJSON() },\n            });\n        }\n    });\n}\n//# sourceMappingURL=longTaskCollection.js.map","/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, viewContexts, actionContexts, urlContexts) {\n    return {\n        get: function (startTime) {\n            var viewContext = viewContexts.findView(startTime);\n            var urlContext = urlContexts.findUrl(startTime);\n            var session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                var actionId = actionContexts.findActionId(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionId ? { id: actionId } : undefined,\n                    view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map"],"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","TraceIdentifier","traceSampleRate","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","validateAndBuildRumConfiguration","initConfiguration","_a","_b","_c","_d","_e","_f","applicationId","sessionReplaySampleRate","premiumSampleRate","replaySampleRate","warn","tracingSampleRate","excludedActivityUrls","isArray","allowedTracingOrigins","service","tracingOptions_1","option","expectedItem","push","tracingOptions_2","legacyMatchOption","convertLegacyMatchOptionToTracingOption","validateAndBuildTracingOptions","baseConfiguration","trackUserInteractions","trackInteractions","trackFrustrations","version","actionNameAttribute","oldPlansBehavior","trackViewsManually","trackResources","trackLongTasks","subdomain","defaultPrivacyLevel","MASK_USER_INPUT","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","Set","add","buildCommonContext","globalContextManager","userContextManager","recorderApi","getContext","user","hasReplay","isRecording","getMutationObserverConstructor","constructor","browserWindow","Zone","getZoneJsOriginalValue","MutationObserver","patchedInstance","originalInstance","runOnReadyState","expectedReadyState","callback","document","readyState","eventName","addEventListener","once","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","path","exec","areInOrder","numbers","_i","arguments","i","computePerformanceResourceDetails","entry","validEntry","toValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","responseEnd","first_byte","connect","ssl","dns","hasRedirection","redirect","origin","start","end","duration","computeSize","decodedBodySize","isAllowedRequestUrl","isIntakeUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","Boolean","shadowRoot","isNodeShadowRoot","host","DOCUMENT_FRAGMENT_NODE","getParentNode","parentNode","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","timing","handleRumPerformanceEntries","forcedAttributes","getEntriesByType","navigationEntry","toJSON","relativePerformanceTiming","computeRelativePerformanceTiming","name","location","href","performanceEntries_1","getEntries","handlePerformanceEntryList_1","monitor","entries","mainEntries","experimentalEntries","type","observe","buffered","apply","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","timeStamp","sendTimingIfPointerIsNotCancelled","sendTiming","passive","capture","stop","event","delay","retrieveFirstInputTiming","result","key","numberKey","timingElement","rumAllowedPerformanceEntries","filter","loadEventEnd","isIncompleteNavigation","isForbiddenResource","notify","viewportObservable","viewport","initViewportObservable","observable","updateDimension","getViewportDimension","throttled","visual","visualViewport","width","scale","height","innerWidth","innerHeight","limitModification","object","modifiableFieldPaths","modifier","clone","fieldPath","fieldType","newValue","current","split","field","isValidObjectContaining","get","newType","set","sanitize","fields","isValidObject","Object","hasOwnProperty","call","modifiableFieldPathsByEvent","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","startRumAssembly","viewContexts","urlContexts","actionContexts","reportError","eventRateLimiters","createEventRateLimiter","eventRateLimiterThreshold","syntheticsContext","testId","resultId","test_id","result_id","injected","getSyntheticsContext","ciTestContext","testExecutionId","Cypress","env","test_execution_id","getCiTestContext","subscribe","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","commonContext","actionId","findActionId","rumContext","_dd","format_version","drift","plan","browser_sdk_version","application","id","date","source","view","referrer","action","indexOf","synthetics","ci_test","viewportDimension","unsubscribe","serverRumEvent","has_replay","usr","beforeSend","rateLimitReached","isLimitReached","shouldSend","MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS","MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS","foregroundPeriods","startForegroundContexts","hasFocus","addNewForegroundPeriod","onFocusChange","onBlurChange","stopForegroundTracking","isTrusted","stopBlurTracking","closeForegroundPeriod","isInForegroundAt","selectInForegroundPeriodsFor","currentForegroundPeriod","now","foregroundPeriod","eventStartTime","eventEndTime","filteredForegroundPeriods","earliestIndex","max","startDuration","endTime","endDuration","unshift","LifeCycle","VIEW_CONTEXT_TIME_OUT_DELAY","nextRequestIndex","startRequestCollection","tracer","traceFetch","input","Request","init","headers","keys","append","headers_1","Headers","header","traceXhr","xhr","setRequestHeader","startTracer","subscription","rawContext","state","requestIndex","getNextRequestIndex","method","startClocks","trackXhr","clonedResponse","response","readBytesFromStream","bytesLimit","POSITIVE_INFINITY","collectStreamBody","waitForResponseToComplete","responseType","trackFetch","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","subscriptions","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","instrumentMethod","before","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeoutId","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","every","isStopped","tryAppend","first","second","target","other","sqrt","pow","clientX","clientY","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","getActionNameFromElement","element","userProgrammaticAttribute","getActionNameFromElementProgrammatically","getActionNameFromElementForStrategies","priorityStrategies","fallbackStrategies","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","nodeName","labelledByAttribute","map","refElement","getElementById","options","MAX_PARENTS_TO_CONSIDER","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","replace","isContentEditable","text_1","innerText","removeTextFromElements","query","index","element_1","textToReplace","textContent","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","tagName","classList","className","getSelectorFromElement","targetElementSelector","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","predicate","childSelector","selectorGetters_1","elementSelector","selectorGetter","fullSelector","supportScopeSelector","parent","child","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","computeFrustration","clicks","rageClick","getUserActivity","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","CLICK_ACTION_MAX_DURATION","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","currentClickChain","history","reset","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onPointerUp","userActivity","listeners","localUserActivity_1","listener","listenActionEvents","pointerDownEvent","find","clickActionBase","rect","getBoundingClientRect","round","position","x","left","y","top","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","validate","viewEndedSubscription","endClocks","stopSubscription","startClickAction","findAll","rageClick_1","finalizeClicks","activityEndTime","historyEntry","relative","eventCountsSubscription","frustrationTypes","newActivityEndTime","close","remove","frustrationType","domEvents","clickAction","counts","events","processAction","foregroundContexts","autoActionProperties","isAutoAction","loading_time","count","long_task","resource","actionEvent","inForeground","in_foreground","startErrorCollection","featureFlagContexts","errorObservable","consoleError","message","stack","fingerprint","CONSOLE","handling","handlingStack","trackConsoleError","trackRuntimeError","cspViolation","intervention","subtype","REPORT","trackReportError","handling_stack","causes","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","originalError","processError","addError","stackTrace","Error","computeStackTrace","rawError","nonErrorPrefix","CUSTOM","doStartErrorCollection","trackFirstHiddenSingleton","matchRequestTiming","sameNameEntries","getEntriesByName","candidates","errorMargin","startResourceCollection","pageStateHistory","matchingTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","hasBeenTraced","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","indexingInfo","computeIndexingInfo","NO_RESOURCE_DURATION_FROZEN_STATE","requestCrossedFrozenState","pageState","computeRequestDuration","pageStateInfo","computePageStateInfo","resourceEvent","status_code","performanceEntry","requestInput","requestInit","processRequest","entries_1","processResourceEntry","RESOURCE_TYPES_1","isType","computeResourceKind","entryMetrics","computeEntryTracingInfo","size","resourceStart","discarded","resourceAllowed","RESOURCE_PAGE_STATES","page_states","page_was_discarded","String","wasDiscarded","trackFirstHidden","eventTarget","visibilityState","Infinity","TIMING_MAXIMUM_DELAY","KEEP_TRACKING_TIMINGS_AFTER_VIEW_DELAY","trackInitialViewTimings","setLoadEvent","scheduleViewUpdate","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","trackFirstContentfulPaintTiming","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","trackLargestContentfulPaintTiming","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","scheduleStop","trackViewMetrics","loadingType","viewStart","stopCLSTracking","viewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","trackLoadingTime","newLoadingTime","loadingTime","stopLoadingTimeTracking","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","trackViews","locationChangeObservable","areViewsTrackedAutomatically","initialViewOptions","locationChangeSubscription","currentView","startNewView","viewOptions","initialLocation","customTimings","documentVersion","sessionIsActive","triggerViewUpdate","leading","cancelScheduleViewUpdate","cancel","stopViewMetricsTracking","scheduleStopInitialViewTimingsTracking","viewId","trackViewEventCounts","scheduleStopEventCountsTracking","keepAliveIntervalId","currentEnd","isActive","addTiming","time","relativeTime","sanitized","sanitizeTiming","newView","pageExitEvent","reason","UNLOADING","PAGEHIDE","currentLocation","otherLocation","hash","correspondingId","oldLocation","newLocation","pathname","substr","getPathFromHash","renewViewOnLocationChange","startView","slice","startViewCollection","replayStats","getReplayStats","pageStatesEnabled","PAGE_STATES","viewEvent","document_version","replay_stats","cumulative_layout_shift","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","is_active","largest_contentful_paint","load_event","discardNegativeDuration","loading_type","time_spent","in_foreground_periods","custom_timings","processViewUpdate","RUM_SESSION_KEY","startRumSessionManager","sessionStoreStrategyType","rawTrackingType","trackingType","hasValidRumSession","sessionSampleRate","isTracked","isTypeTracked","computeSessionState","expireObservable","renewObservable","findActiveSession","sessionReplayAllowed","longTaskAllowed","expire","rumSessionType","startRumBatch","telemetryEventObservable","pageExitObservable","sessionExpireObservable","batch","replicaBatch","createRumBatch","rumEndpointBuilder","primaryBatch","primaryFlushController","flushController","replica","endpointBuilder","messagesLimit","batchMessagesLimit","batchBytesLimit","durationLimit","flushTimeout","messageBytesLimit","withReplicaApplicationId","flushObservable","replicated","upsert","makeRumBatch","URL_CONTEXT_TIME_OUT_DELAY","createLocationChangeObservable","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","onHashChange","stopHistoryTracking","onLocationChange","after","stopHashTracking","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","BYTES_COMPUTATION_THROTTLING_DELAY","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","MEASURES_PERIOD_DURATION","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","min","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","MAX_PAGE_STATE_ENTRIES","MAX_PAGE_STATE_ENTRIES_SELECTABLE","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","startPageStateHistory","maxPageStateEntriesSelectable","currentPageState","addPageState","getPageState","stopEventListeners","persisted","computePageState","nextPageState","closeActive","pageStateEntries","pageStateServerEntries","limit","relativeStartTime","getSessionReplayUrl","errorType","sessionId","parameters","rumConfiguration","site","getSiteDefaultSubdomain","RecordType","FullSnapshot","IncrementalSnapshot","Meta","Focus","ViewEnd","VisualViewport","FrustrationRecord","NodeType","Document","DocumentType","Text","CDATA","DocumentFragment","IncrementalSource","Mutation","MouseMove","MouseInteraction","Scroll","ViewportResize","Input","TouchMove","MediaInteraction","StyleSheetRule","MouseInteractionType","MouseUp","MouseDown","Click","ContextMenu","DblClick","Blur","TouchStart","TouchEnd","MediaInteractionType","Play","Pause","assembleIncrementalSnapshot","timestamp","NodePrivacyLevel","IGNORE","HIDDEN","ALLOW","MASK","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_ALLOW","PRIVACY_ATTR_VALUE_MASK","PRIVACY_ATTR_VALUE_MASK_USER_INPUT","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_ALLOW","PRIVACY_CLASS_MASK","PRIVACY_CLASS_MASK_USER_INPUT","PRIVACY_CLASS_HIDDEN","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","getNodePrivacyLevel","parentNodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","privAttr","inputElement","autocomplete","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","censorText","text","getTextContent","textNode","ignoreWhiteSpace","parentTagName","nodePrivacyLevel","isStyle","serializedNodeIds","WeakMap","hasSerializedNode","has","getSerializedNodeId","getElementInputValue","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","quote","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","from","cssRule","disabled","media","serializeAttribute","attributeValue","getCssRulesString","getCssRuleString","rule","isCSSImportRule","styleSheet","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","isSVG","el","SVGElement","attributes","rr_width","rr_height","safeAttrs","doc","formValue","optionElement","selected","stylesheet","styleSheets","_cssText","sheet","scrollTop","scrollLeft","checked","mediaElement","rr_mediaState","paused","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","serializeAttributes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","serializeDocument","isTouchEvent","changedTouches","getEventTarget","composed","composedPath","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","getScrollX","pageXOffset","getScrollY","pageYOffset","MOUSE_MOVE_OBSERVER_THRESHOLD","tryToComputeCoordinates","isFinite","SCROLL_OBSERVER_THRESHOLD","eventTypeToMouseInteraction","initInputObserver","cb","lastInputStateMap","onElementChange","inputState","isChecked","cbWithDedup","lastInputState","HTMLTextAreaElement","HTMLSelectElement","instrumentationStoppers","stopper","getPathToNestedCSSRule","currentRule","parentRule","index_1","parentStyleSheet","VISUAL_VIEWPORT_OBSERVER_THRESHOLD","MUTATION_PROCESS_MAX_DELAY","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","flush","addMutations","mutations","opts","requestIdleCallback","cancelIdleCallback","id_1","requestAnimationFrame","cancelAnimationFrame","timeout","initMutationObserver","mutationCallback","mutationBatch","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","Map","_loop_1","addedNodes","delete","mutations_1","sortedAddedAndMovedNodes","nodes","sort","a","b","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","adds","removes","nextSibling","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","observer","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","disconnect","shadowDomRemovedCallback","initObservers","o","updatePosition","mediaInteractionCb","focusCb","recordIds","getIdForEvent","initRecordIds","mutationHandler","mutationCb","mousemoveHandler","mousemoveCb","coordinates","timeOffset","trailing","mouseInteractionHandler","interaction","record","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","scrollPositions","initScrollObserver","scrollCb","viewportResizeHandler","initViewportResizeObserver","viewportResizeCb","inputHandler","inputCb","mediaInteractionHandler","styleSheetObserver","checkStyleSheetAndCallback","ownerNode","CSSStyleSheet","instrumentGroupingCSSRuleClass","cls","_this","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","initStyleSheetObserver","styleSheetCb","focusHandler","has_focus","visualViewportResizeHandler","cancelThrottle","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","frustrationCb","initFrustrationObserver","initShadowRootsController","controllerByShadowRoot","stopMutationObserver","stopInputObserver","emit","scrollPositionsByElement","scrollingElement","takeFullSnapshot","initialOffset","p","mouseInteractionRecord","positions","r","d","frustrationRecord","stopObservers","flushMutationsFromObservers","flushMutations","takeSubsequentFullSnapshot","statsPerView","MAX_STATS_HISTORY","getSegmentsCount","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","next","isFirst_1","_value","deleteOldestStats","workerURL","Segment","worker","creationReason","initialRecord","onWrote","onFlushed","metadata","creation_reason","has_full_snapshot","index_in_view","removeMessageListener","additionalBytesCount","rawBytesCount","compressedBytesCount","sendToExtension","segment","postMessage","JSON","stringify","flushReason","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","expirationTimeoutId","createNewSegment","compressedSegmentBytesCount","rawSegmentBytesCount","payload","formData","FormData","Blob","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","bytesCount","buildReplayPayload","sendOnExit","send","doStartSegmentCollection","computeSegmentContext","createDeflateWorker","URL","createObjectURL","workerCodeFn","Worker","fn","self","Z_FIXED","Z_BINARY","Z_TEXT","Z_UNKNOWN","zero","buf","len","STORED_BLOCK","STATIC_TREES","DYN_TREES","MIN_MATCH","MAX_MATCH","LENGTH_CODES","LITERALS","L_CODES","D_CODES","BL_CODES","HEAP_SIZE","MAX_BITS","Buf_size","MAX_BL_BITS","END_BLOCK","REP_3_6","REPZ_3_10","REPZ_11_138","extra_lbits","extra_dbits","extra_blbits","bl_order","DIST_CODE_LEN","static_ltree","static_dtree","_dist_code","_length_code","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","dist","put_short","w","pending_buf","pending","send_bits","bi_valid","bi_buf","send_code","c","tree","bi_reverse","code","res","bi_flush","gen_bitlen","desc","h","n","m","bits","xbits","f","stree","extra","base","overflow","bl_count","heap","heap_max","opt_len","static_len","gen_codes","next_code","tr_static_init","init_block","dyn_ltree","dyn_dtree","bl_tree","last_lit","matches","bi_windup","copy_block","subarray","smaller","depth","_n2","_m2","pqdownheap","k","v","j","heap_len","compress_block","ltree","dtree","lc","lx","d_buf","l_buf","build_tree","scan_tree","curlen","prevlen","nextlen","max_count","min_count","send_tree","build_bl_tree","max_blindex","l_desc","d_desc","bl_desc","send_all_trees","lcodes","dcodes","blcodes","rank","detect_data_type","black_mask","static_init_done","_tr_stored_block","stored_len","last","_tr_flush_block","opt_lenb","static_lenb","level","strm","data_type","trees","_tr_init","_tr_tally","lit_bufsize","_tr_align","adler32_1","adler","pos","s1","s2","crcTable","Uint32Array","table","makeTable","crc32_1","crc","t","messages","constants","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_TREES","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_ERRNO","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_DEFAULT_STRATEGY","Z_DEFLATED","_tr_init$1","_tr_stored_block$1","_tr_flush_block$1","_tr_tally$1","_tr_align$1","Z_FIXED$1","Z_UNKNOWN$1","MAX_MEM_LEVEL","MAX_WBITS","DEF_MEM_LEVEL","L_CODES$1","LITERALS$1","D_CODES$1","BL_CODES$1","HEAP_SIZE$1","MAX_BITS$1","MIN_MATCH$1","MAX_MATCH$1","MIN_LOOKAHEAD","PRESET_DICT","INIT_STATE","EXTRA_STATE","NAME_STATE","COMMENT_STATE","HCRC_STATE","BUSY_STATE","FINISH_STATE","BS_NEED_MORE","BS_BLOCK_DONE","BS_FINISH_STARTED","BS_FINISH_DONE","OS_CODE","err","errorCode","msg","zero$1","HASH","prev","hash_shift","hash_mask","flush_pending","avail_out","output","pending_out","next_out","total_out","flush_block_only","block_start","strstart","put_byte","putShortMSB","read_buf","avail_in","next_in","wrap","total_in","longest_match","cur_match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","w_size","_win","wmask","w_mask","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","more","_w_size","window_size","hash_size","head","insert","ins_h","deflate_fast","hash_head","bflush","match_length","max_lazy_match","deflate_slow","max_insert","prev_match","match_available","deflate_rle","deflate_huff","Config","good_length","max_lazy","nice_length","max_chain","func","configuration_table","max_block_size","pending_buf_size","max_start","lm_init","DeflateState","gzhead","gzindex","last_flush","w_bits","hash_bits","Uint16Array","deflateResetKeep","deflateReset","ret","deflateInit2","windowBits","memLevel","deflate","beg","val","old_flush","hcrc","os","charCodeAt","bstate","deflate_2","deflate_1","deflateInit","deflateSetHeader","deflateEnd","deflateSetDictionary","dictionary","dictLength","tmpDict","avail","deflateInfo","flattenChunks","chunks","l","_l","chunk","_utf8len","q","ZStream","zstream","Z_NO_FLUSH$1","Z_FULL_FLUSH$1","Z_FINISH$1","Z_OK$1","Z_STREAM_END$1","Z_DEFAULT_COMPRESSION$1","Z_DEFAULT_STRATEGY$1","Z_DEFLATED$1","Deflate","chunkSize","opt","raw","gzip","ended","dict","_dict_set","string2buf","TextEncoder","encode","c2","m_pos","str_len","buf_len","flush_mode","_flush_mode","onData","onEnd","makePakoDeflate","pushData","binaryData","reduce","total","startDeflateWorker","createDeflateWorkerImpl","callbacks","worker_1","onError","doStartDeflateWorker","Event","isBrowserSupported","NodeList","getSessionReplayLink","isRecordingStarted","getErrorType","startRecordingImpl","startDeflateWorkerImpl","onRumStart","startStrategy","stopStrategy","stopRecording","makeRecorderApi","replayRequest","sessionReplayEndpointBuilder","stopSegmentCollection","unsubscribeViewEnded","datadogRum","startRumImpl","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","getInternalContextStrategy","getInitConfigurationStrategy","stopSessionStrategy","getSessionReplayLinkStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","addErrorStrategy","providedError","addFeatureFlagEvaluationStrategy","doStartRum","startRumResults","addAction","addFeatureFlagEvaluation","getInternalContext","stopSession","drain","rumPublicApi","eventBridgeAvailable","clientToken","overrideInitConfigurationForBridge","silentMultipleInit","canInitRum","beforeInitCalls","addRumGlobalContext","setGlobalContextProperty","setContextProperty","removeRumGlobalContext","removeGlobalContextProperty","removeContextProperty","getRumGlobalContext","getGlobalContext","setRumGlobalContext","setGlobalContext","setContext","clearGlobalContext","clearContext","getInitConfiguration","setUser","newUser","getUser","setUserProperty","property","sanitizedProperty","removeUserProperty","removeUser","clearUser","startSessionReplayRecording","stopSessionReplayRecording","makeRumPublicApi","telemetry","bridge_1","startRumTelemetry","setContextProvider","computeBytesCountImpl","FEATURE_FLAGS","getFeatureFlagBytesCount","bytesCountCache","alreadyWarned","jsonStringify","computeBytesCountThrottled","currentContext","startFeatureFlagContexts","startRumSessionManagerStub","bridge","startRumEventBridge","batchFlushObservable","enabled","getBytesCount","hasFeatureFlagContext","messagesCount","startCustomerDataTelemetry","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","startRumEventCollection","baseSerializedConfiguration","premium_sample_rate","replay_sample_rate","session_replay_sample_rate","trace_sample_rate","action_name_attribute","use_allowed_tracing_origins","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","use_excluded_activity_urls","track_frustrations","track_views_manually","track_user_interactions","serializeRumConfiguration","startLongTaskCollection","internalContext","application_id","session_id","user_action","startInternalContext","getGlobalObject"],"sourceRoot":""}