{"version":3,"file":"js/899-98752458cf337ad8626f.chunk.js","mappings":"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","sources":["webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/boot/displayAlreadyInitializedError.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/connectivity/connectivity.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/context/contextManager.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/context/customerDataTracker.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/context/storeContextManager.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/eventRateLimiter/createEventRateLimiter.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionStoreStrategy.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/trackingConsent.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/domain/user/user.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/encoder.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/getGlobalObject.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/stackTrace/computeStackTrace.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/stackTrace/handlingStack.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/timer.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/flushController.js","webpack://hnry-rails/./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js"],"sourcesContent":["import { display } from '../tools/display';\nexport function displayAlreadyInitializedError(sdkName, initConfiguration) {\n    if (!initConfiguration.silentMultipleInit) {\n        display.error(\"\".concat(sdkName, \" is already initialized.\"));\n    }\n}\n//# sourceMappingURL=displayAlreadyInitializedError.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils/polyfills';\nimport { display } from '../tools/display';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"5.22.0\",\n        // This API method is intentionally not monitored, since the only thing executed is the\n        // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and\n        // we don't want to interfere with the user uncaught exceptions.\n        onReady: function (callback) {\n            callback();\n        },\n    }, stub);\n    // Add a \"hidden\" property to set debug mode. We define it that way to hide it\n    // as much as possible but of course it's not a real protection.\n    Object.defineProperty(publicApi, '_setDebug', {\n        get: function () {\n            return setDebugMode;\n        },\n        enumerable: false,\n    });\n    return publicApi;\n}\nexport function defineGlobal(global, name, api) {\n    var existingGlobalVariable = global[name];\n    if (existingGlobalVariable && !existingGlobalVariable.q && existingGlobalVariable.version) {\n        display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.');\n    }\n    global[name] = api;\n    if (existingGlobalVariable && existingGlobalVariable.q) {\n        existingGlobalVariable.q.forEach(function (fn) { return catchUserErrors(fn, 'onReady callback threw an error:')(); });\n    }\n}\n//# sourceMappingURL=init.js.map","import { monitor } from '../tools/monitor';\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\n// We want to use a real enum (i.e. not a const enum) here, to be able to iterate over it to automatically add _ddIsTrusted in e2e tests\n// eslint-disable-next-line no-restricted-syntax\nexport var DOM_EVENT;\n(function (DOM_EVENT) {\n    DOM_EVENT[\"BEFORE_UNLOAD\"] = \"beforeunload\";\n    DOM_EVENT[\"CLICK\"] = \"click\";\n    DOM_EVENT[\"DBL_CLICK\"] = \"dblclick\";\n    DOM_EVENT[\"KEY_DOWN\"] = \"keydown\";\n    DOM_EVENT[\"LOAD\"] = \"load\";\n    DOM_EVENT[\"POP_STATE\"] = \"popstate\";\n    DOM_EVENT[\"SCROLL\"] = \"scroll\";\n    DOM_EVENT[\"TOUCH_START\"] = \"touchstart\";\n    DOM_EVENT[\"TOUCH_END\"] = \"touchend\";\n    DOM_EVENT[\"TOUCH_MOVE\"] = \"touchmove\";\n    DOM_EVENT[\"VISIBILITY_CHANGE\"] = \"visibilitychange\";\n    DOM_EVENT[\"PAGE_SHOW\"] = \"pageshow\";\n    DOM_EVENT[\"FREEZE\"] = \"freeze\";\n    DOM_EVENT[\"RESUME\"] = \"resume\";\n    DOM_EVENT[\"DOM_CONTENT_LOADED\"] = \"DOMContentLoaded\";\n    DOM_EVENT[\"POINTER_DOWN\"] = \"pointerdown\";\n    DOM_EVENT[\"POINTER_UP\"] = \"pointerup\";\n    DOM_EVENT[\"POINTER_CANCEL\"] = \"pointercancel\";\n    DOM_EVENT[\"HASH_CHANGE\"] = \"hashchange\";\n    DOM_EVENT[\"PAGE_HIDE\"] = \"pagehide\";\n    DOM_EVENT[\"MOUSE_DOWN\"] = \"mousedown\";\n    DOM_EVENT[\"MOUSE_UP\"] = \"mouseup\";\n    DOM_EVENT[\"MOUSE_MOVE\"] = \"mousemove\";\n    DOM_EVENT[\"FOCUS\"] = \"focus\";\n    DOM_EVENT[\"BLUR\"] = \"blur\";\n    DOM_EVENT[\"CONTEXT_MENU\"] = \"contextmenu\";\n    DOM_EVENT[\"RESIZE\"] = \"resize\";\n    DOM_EVENT[\"CHANGE\"] = \"change\";\n    DOM_EVENT[\"INPUT\"] = \"input\";\n    DOM_EVENT[\"PLAY\"] = \"play\";\n    DOM_EVENT[\"PAUSE\"] = \"pause\";\n    DOM_EVENT[\"SECURITY_POLICY_VIOLATION\"] = \"securitypolicyviolation\";\n    DOM_EVENT[\"SELECTION_CHANGE\"] = \"selectionchange\";\n    DOM_EVENT[\"STORAGE\"] = \"storage\";\n})(DOM_EVENT || (DOM_EVENT = {}));\n/**\n * Add an event listener to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n */\nexport function addEventListener(configuration, eventTarget, eventName, listener, options) {\n    return addEventListeners(configuration, eventTarget, [eventName], listener, options);\n}\n/**\n * Add event listeners to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n *\n * * with `once: true`, the listener will be called at most once, even if different events are listened\n */\nexport function addEventListeners(configuration, eventTarget, eventNames, listener, _a) {\n    var _b = _a === void 0 ? {} : _a, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var listenerWithMonitor = monitor(function (event) {\n        if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {\n            return;\n        }\n        if (once) {\n            stop();\n        }\n        listener(event);\n    });\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');\n    eventNames.forEach(function (eventName) { return add.call(eventTarget, eventName, listenerWithMonitor, options); });\n    function stop() {\n        var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');\n        eventNames.forEach(function (eventName) { return remove.call(eventTarget, eventName, listenerWithMonitor, options); });\n    }\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, findCommaSeparatedValues, generateUUID } from '../tools/utils/stringUtils';\nexport function setCookie(name, value, expireDelay, options) {\n    var date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    var expires = \"expires=\".concat(date.toUTCString());\n    var sameSite = options && options.crossSite ? 'none' : 'strict';\n    var domain = options && options.domain ? \";domain=\".concat(options.domain) : '';\n    var secure = options && options.secure ? ';secure' : '';\n    var partitioned = options && options.partitioned ? ';partitioned' : '';\n    document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure).concat(partitioned);\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nvar initCookieParsed;\n/**\n * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)\n * to avoid accessing document.cookie multiple times.\n */\nexport function getInitCookie(name) {\n    if (!initCookieParsed) {\n        initCookieParsed = findCommaSeparatedValues(document.cookie);\n    }\n    return initCookieParsed.get(name);\n}\nexport function resetInitCookies() {\n    initCookieParsed = undefined;\n}\nexport function deleteCookie(name, options) {\n    setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n    if (document.cookie === undefined || document.cookie === null) {\n        return false;\n    }\n    try {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        var testCookieName = \"dd_cookie_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n        var isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n        deleteCookie(testCookieName, options);\n        return isCookieCorrectlySet;\n    }\n    catch (error) {\n        display.error(error);\n        return false;\n    }\n}\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nvar getCurrentSiteCache;\nexport function getCurrentSite() {\n    if (getCurrentSiteCache === undefined) {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        var testCookieName = \"dd_site_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        var domainLevels = window.location.hostname.split('.');\n        var candidateDomain = domainLevels.pop();\n        while (domainLevels.length && !getCookie(testCookieName)) {\n            candidateDomain = \"\".concat(domainLevels.pop(), \".\").concat(candidateDomain);\n            setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain });\n        }\n        deleteCookie(testCookieName, { domain: candidateDomain });\n        getCurrentSiteCache = candidateDomain;\n    }\n    return getCurrentSiteCache;\n}\n//# sourceMappingURL=cookie.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nvar fetchObservable;\nexport function initFetchObservable() {\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nfunction createFetchObservable() {\n    return new Observable(function (observable) {\n        if (!window.fetch) {\n            return;\n        }\n        var stop = instrumentMethod(window, 'fetch', function (call) { return beforeSend(call, observable); }, {\n            computeHandlingStack: true,\n        }).stop;\n        return stop;\n    });\n}\nfunction beforeSend(_a, observable) {\n    var parameters = _a.parameters, onPostCall = _a.onPostCall, handlingStack = _a.handlingStack;\n    var input = parameters[0], init = parameters[1];\n    var methodFromParams = init && init.method;\n    if (methodFromParams === undefined && input instanceof Request) {\n        methodFromParams = input.method;\n    }\n    var method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET';\n    var url = input instanceof Request ? input.url : normalizeUrl(String(input));\n    var startClocks = clocksNow();\n    var context = {\n        state: 'start',\n        init: init,\n        input: input,\n        method: method,\n        startClocks: startClocks,\n        url: url,\n        handlingStack: handlingStack,\n    };\n    observable.notify(context);\n    // Those properties can be changed by observable subscribers\n    parameters[0] = context.input;\n    parameters[1] = context.init;\n    onPostCall(function (responsePromise) { return afterSend(observable, responsePromise, context); });\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    var reportFetch = function (response) {\n        var context = startContext;\n        context.state = 'resolve';\n        if ('stack' in response || response instanceof Error) {\n            context.status = 0;\n            context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;\n            context.error = response;\n        }\n        else if ('status' in response) {\n            context.response = response;\n            context.responseType = response.type;\n            context.status = response.status;\n            context.isAborted = false;\n        }\n        observable.notify(context);\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { Observable } from '../tools/observable';\nimport { objectValues, includes } from '../tools/utils/polyfills';\nimport { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener';\nexport var PageExitReason = {\n    HIDDEN: 'visibility_hidden',\n    UNLOADING: 'before_unload',\n    PAGEHIDE: 'page_hide',\n    FROZEN: 'page_frozen',\n};\nexport function createPageExitObservable(configuration) {\n    return new Observable(function (observable) {\n        var stopListeners = addEventListeners(configuration, window, [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE], function (event) {\n            if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {\n                /**\n                 * Only event that guarantee to fire on mobile devices when the page transitions to background state\n                 * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n                 */\n                observable.notify({ reason: PageExitReason.HIDDEN });\n            }\n            else if (event.type === DOM_EVENT.FREEZE) {\n                /**\n                 * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n                 * Allow to collect events happening between hidden and frozen state.\n                 */\n                observable.notify({ reason: PageExitReason.FROZEN });\n            }\n        }, { capture: true }).stop;\n        var stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, function () {\n            observable.notify({ reason: PageExitReason.UNLOADING });\n        }).stop;\n        return function () {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n}\nexport function isPageExitReason(reason) {\n    return includes(objectValues(PageExitReason), reason);\n}\n//# sourceMappingURL=pageExitObservable.js.map","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nimport { shallowClone } from '../tools/utils/objectUtils';\nimport { addEventListener } from './addEventListener';\nvar xhrObservable;\nvar xhrContexts = new WeakMap();\nexport function initXhrObservable(configuration) {\n    if (!xhrObservable) {\n        xhrObservable = createXhrObservable(configuration);\n    }\n    return xhrObservable;\n}\nfunction createXhrObservable(configuration) {\n    return new Observable(function (observable) {\n        var stopInstrumentingStart = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr).stop;\n        var stopInstrumentingSend = instrumentMethod(XMLHttpRequest.prototype, 'send', function (call) {\n            sendXhr(call, configuration, observable);\n        }, { computeHandlingStack: true }).stop;\n        var stopInstrumentingAbort = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr).stop;\n        return function () {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n}\nfunction openXhr(_a) {\n    var xhr = _a.target, _b = _a.parameters, method = _b[0], url = _b[1];\n    xhrContexts.set(xhr, {\n        state: 'open',\n        method: String(method).toUpperCase(),\n        url: normalizeUrl(String(url)),\n    });\n}\nfunction sendXhr(_a, configuration, observable) {\n    var xhr = _a.target, handlingStack = _a.handlingStack;\n    var context = xhrContexts.get(xhr);\n    if (!context) {\n        return;\n    }\n    var startContext = context;\n    startContext.state = 'start';\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = xhr;\n    startContext.handlingStack = handlingStack;\n    var hasBeenReported = false;\n    var stopInstrumentingOnReadyStateChange = instrumentMethod(xhr, 'onreadystatechange', function () {\n        if (xhr.readyState === XMLHttpRequest.DONE) {\n            // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n            // application during a future event. For example, Angular is calling .abort() on\n            // completed requests during an onreadystatechange event, so the status becomes '0'\n            // before the request is collected.\n            onEnd();\n        }\n    }).stop;\n    var onEnd = function () {\n        unsubscribeLoadEndListener();\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        var completeContext = context;\n        completeContext.state = 'complete';\n        completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n        completeContext.status = xhr.status;\n        observable.notify(shallowClone(completeContext));\n    };\n    var unsubscribeLoadEndListener = addEventListener(configuration, xhr, 'loadend', onEnd).stop;\n    observable.notify(startContext);\n}\nfunction abortXhr(_a) {\n    var xhr = _a.target;\n    var context = xhrContexts.get(xhr);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_US1, INTAKE_SITE_FED_STAGING, PCI_INTAKE_HOST_US1 } from './intakeSites';\nexport function createEndpointBuilder(initConfiguration, trackType, configurationTags) {\n    var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType);\n    return {\n        build: function (api, payload) {\n            var parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\n        trackType: trackType,\n    };\n}\n/**\n * Create a function used to build a full endpoint url from provided parameters. The goal of this\n * function is to pre-compute some parts of the URL to avoid re-computing everything on every\n * request, as only parameters are changing.\n */\nfunction createEndpointUrlWithParametersBuilder(initConfiguration, trackType) {\n    var path = \"/api/v2/\".concat(trackType);\n    var proxy = initConfiguration.proxy;\n    if (typeof proxy === 'string') {\n        var normalizedProxyUrl_1 = normalizeUrl(proxy);\n        return function (parameters) { return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters))); };\n    }\n    if (typeof proxy === 'function') {\n        return function (parameters) { return proxy({ path: path, parameters: parameters }); };\n    }\n    var host = buildEndpointHost(trackType, initConfiguration);\n    return function (parameters) { return \"https://\".concat(host).concat(path, \"?\").concat(parameters); };\n}\nfunction buildEndpointHost(trackType, initConfiguration) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US1 : _a, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\n    if (trackType === 'logs' && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {\n        return PCI_INTAKE_HOST_US1;\n    }\n    if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n        return \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n    }\n    if (site === INTAKE_SITE_FED_STAGING) {\n        return \"http-intake.logs.\".concat(site);\n    }\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    return \"browser-intake-\".concat(domainParts.join('-'), \".\").concat(extension);\n}\n/**\n * Build parameters to be used for an intake request. Parameters should be re-built for each\n * request, as they change randomly.\n */\nfunction buildEndpointParameters(_a, trackType, configurationTags, api, _b) {\n    var clientToken = _a.clientToken, internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n    var retry = _b.retry, encoding = _b.encoding;\n    var tags = [\"sdk_version:\".concat(\"5.22.0\"), \"api:\".concat(api)].concat(configurationTags);\n    if (retry) {\n        tags.push(\"retry_count:\".concat(retry.count), \"retry_after:\".concat(retry.lastFailureStatus));\n    }\n    var parameters = [\n        'ddsource=browser',\n        \"ddtags=\".concat(encodeURIComponent(tags.join(','))),\n        \"dd-api-key=\".concat(clientToken),\n        \"dd-evp-origin-version=\".concat(encodeURIComponent(\"5.22.0\")),\n        'dd-evp-origin=browser',\n        \"dd-request-id=\".concat(generateUUID()),\n    ];\n    if (encoding) {\n        parameters.push(\"dd-evp-encoding=\".concat(encoding));\n    }\n    if (trackType === 'rum') {\n        parameters.push(\"batch_time=\".concat(timeStampNow()));\n    }\n    if (internalAnalyticsSubdomain) {\n        parameters.reverse();\n    }\n    return parameters.join('&');\n}\n//# sourceMappingURL=endpointBuilder.js.map","import { DOCS_ORIGIN, display } from '../../tools/display';\nexport var TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n    var env = configuration.env, service = configuration.service, version = configuration.version, datacenter = configuration.datacenter;\n    var tags = [];\n    if (env) {\n        tags.push(buildTag('env', env));\n    }\n    if (service) {\n        tags.push(buildTag('service', service));\n    }\n    if (version) {\n        tags.push(buildTag('version', version));\n    }\n    if (datacenter) {\n        tags.push(buildTag('datacenter', datacenter));\n    }\n    return tags;\n}\nvar FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/;\nexport function buildTag(key, rawValue) {\n    // See https://docs.datadoghq.com/getting_started/tagging/#defining-tags for tags syntax. Note\n    // that the backend may not follow the exact same rules, so we only want to display an informal\n    // warning.\n    var valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;\n    if (rawValue.length > valueSizeLimit || FORBIDDEN_CHARACTERS.test(rawValue)) {\n        display.warn(\"\".concat(key, \" value doesn't meet tag requirements and will be sanitized. More details: \").concat(DOCS_ORIGIN, \"/getting_started/tagging/#defining-tags\"));\n    }\n    // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted\n    // by forging a value containing commas.\n    var sanitizedValue = rawValue.replace(/,/g, '_');\n    return \"\".concat(key, \":\").concat(sanitizedValue);\n}\n//# sourceMappingURL=tags.js.map","import { objectValues, assign } from '../../tools/utils/polyfills';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1, PCI_INTAKE_HOST_US1 } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    var site = initConfiguration.site || INTAKE_SITE_US1;\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeUrlPrefixes = computeIntakeUrlPrefixes(endpointBuilders, site);\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeUrlPrefixes.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n        site: site,\n    }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    return {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n    };\n    intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.urlPrefix; }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\nfunction computeIntakeUrlPrefixes(endpointBuilders, site) {\n    var intakeUrlPrefixes = objectValues(endpointBuilders).map(function (builder) { return builder.urlPrefix; });\n    if (site === INTAKE_SITE_US1) {\n        intakeUrlPrefixes.push(\"https://\".concat(PCI_INTAKE_HOST_US1, \"/\"));\n    }\n    return intakeUrlPrefixes;\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { DOCS_ORIGIN, display } from '../../tools/display';\nimport { ONE_SECOND } from '../../tools/utils/timeUtils';\nimport { isPercentage } from '../../tools/utils/numberUtils';\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { objectHasValue } from '../../tools/utils/objectUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { TrackingConsent } from '../trackingConsent';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n};\nexport var TraceContextInjection = {\n    ALL: 'all',\n    SAMPLED: 'sampled',\n};\nfunction checkIfString(tag, tagName) {\n    if (tag !== undefined && tag !== null && typeof tag !== 'string') {\n        display.error(\"\".concat(tagName, \" must be defined as a string\"));\n        return false;\n    }\n    return true;\n}\nfunction isDatadogSite(site) {\n    return /(datadog|ddog|datad0g|dd0g)/.test(site);\n}\nexport function validateAndBuildConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    if (initConfiguration.sessionSampleRate !== undefined && !isPercentage(initConfiguration.sessionSampleRate)) {\n        display.error('Session Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n        display.error('Telemetry Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetryConfigurationSampleRate !== undefined &&\n        !isPercentage(initConfiguration.telemetryConfigurationSampleRate)) {\n        display.error('Telemetry Configuration Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetryUsageSampleRate !== undefined &&\n        !isPercentage(initConfiguration.telemetryUsageSampleRate)) {\n        display.error('Telemetry Usage Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (!checkIfString(initConfiguration.version, 'Version')) {\n        return;\n    }\n    if (!checkIfString(initConfiguration.env, 'Env')) {\n        return;\n    }\n    if (!checkIfString(initConfiguration.service, 'Service')) {\n        return;\n    }\n    if (initConfiguration.trackingConsent !== undefined &&\n        !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)) {\n        display.error('Tracking Consent should be either \"granted\" or \"not-granted\"');\n        return;\n    }\n    if (initConfiguration.site && !isDatadogSite(initConfiguration.site)) {\n        display.error(\"Site should be a valid Datadog site. Learn more here: \".concat(DOCS_ORIGIN, \"/getting_started/site/.\"));\n        return;\n    }\n    return assign({\n        beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n        sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),\n        sessionSampleRate: (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\n        telemetryUsageSampleRate: (_d = initConfiguration.telemetryUsageSampleRate) !== null && _d !== void 0 ? _d : 5,\n        service: initConfiguration.service || undefined,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\n        allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,\n        trackingConsent: (_e = initConfiguration.trackingConsent) !== null && _e !== void 0 ? _e : TrackingConsent.GRANTED,\n        storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,\n        /**\n         * beacon payload max queue size implementation is 64kb\n         * ensure that we leave room for logs, rum and potential other users\n         */\n        batchBytesLimit: 16 * ONE_KIBI_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxTelemetryEventsPerPage: 15,\n        /**\n         * flush automatically, aim to be lower than ALB connection timeout\n         * to maximize connection reuse.\n         */\n        flushTimeout: (30 * ONE_SECOND),\n        /**\n         * Logs intake limit\n         */\n        batchMessagesLimit: 50,\n        messageBytesLimit: 256 * ONE_KIBI_BYTE,\n    }, computeTransportConfiguration(initConfiguration));\n}\nexport function serializeConfiguration(initConfiguration) {\n    return {\n        session_sample_rate: initConfiguration.sessionSampleRate,\n        telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n        telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,\n        use_before_send: !!initConfiguration.beforeSend,\n        use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,\n        use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,\n        use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n        use_proxy: !!initConfiguration.proxy,\n        silent_multiple_init: initConfiguration.silentMultipleInit,\n        track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n        allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,\n        store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,\n        allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,\n        tracking_consent: initConfiguration.trackingConsent,\n    };\n}\n//# sourceMappingURL=configuration.js.map","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_FED_STAGING = 'dd0g-gov.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';\nexport var PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com';\n//# sourceMappingURL=intakeSites.js.map","export function getConnectivity() {\n    var _a;\n    var navigator = window.navigator;\n    return {\n        status: navigator.onLine ? 'connected' : 'not_connected',\n        interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,\n        effective_type: (_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType,\n    };\n}\n//# sourceMappingURL=connectivity.js.map","import { flattenErrorCauses, tryToGetFingerprint } from '../error/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { ConsoleApiName, globalConsole } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { find } from '../../tools/utils/polyfills';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { createHandlingStack, toStackTraceString, formatErrorMessage } from '../../tools/stackTrace/handlingStack';\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    var consoleObservables = apis.map(function (api) {\n        if (!consoleObservablesByApi[api]) {\n            consoleObservablesByApi[api] = createConsoleObservable(api);\n        }\n        return consoleObservablesByApi[api];\n    });\n    return mergeObservables.apply(void 0, consoleObservables);\n}\nexport function resetConsoleObservable() {\n    consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n    return new Observable(function (observable) {\n        var originalConsoleApi = globalConsole[api];\n        globalConsole[api] = function () {\n            var params = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                params[_i] = arguments[_i];\n            }\n            originalConsoleApi.apply(console, params);\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                observable.notify(buildConsoleLog(params, api, handlingStack));\n            });\n        };\n        return function () {\n            globalConsole[api] = originalConsoleApi;\n        };\n    });\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    var message = params.map(function (param) { return formatConsoleParameters(param); }).join(' ');\n    var stack;\n    var fingerprint;\n    var causes;\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, function (param) { return param instanceof Error; });\n        stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n        fingerprint = tryToGetFingerprint(firstErrorParam);\n        causes = firstErrorParam ? flattenErrorCauses(firstErrorParam, 'console') : undefined;\n    }\n    return {\n        api: api,\n        message: message,\n        stack: stack,\n        handlingStack: handlingStack,\n        fingerprint: fingerprint,\n        causes: causes,\n    };\n}\nfunction formatConsoleParameters(param) {\n    if (typeof param === 'string') {\n        return sanitize(param);\n    }\n    if (param instanceof Error) {\n        return formatErrorMessage(computeStackTrace(param));\n    }\n    return jsonStringify(sanitize(param), undefined, 2);\n}\n//# sourceMappingURL=consoleObservable.js.map","import { deepClone } from '../../tools/mergeInto';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { Observable } from '../../tools/observable';\nexport function createContextManager(customerDataTracker) {\n    var context = {};\n    var changeObservable = new Observable();\n    var contextManager = {\n        getContext: function () { return deepClone(context); },\n        setContext: function (newContext) {\n            if (getType(newContext) === 'object') {\n                context = sanitize(newContext);\n                customerDataTracker.updateCustomerData(context);\n            }\n            else {\n                contextManager.clearContext();\n            }\n            changeObservable.notify();\n        },\n        setContextProperty: function (key, property) {\n            context[key] = sanitize(property);\n            customerDataTracker.updateCustomerData(context);\n            changeObservable.notify();\n        },\n        removeContextProperty: function (key) {\n            delete context[key];\n            customerDataTracker.updateCustomerData(context);\n            changeObservable.notify();\n        },\n        clearContext: function () {\n            context = {};\n            customerDataTracker.resetCustomerData();\n            changeObservable.notify();\n        },\n        changeObservable: changeObservable,\n    };\n    return contextManager;\n}\n//# sourceMappingURL=contextManager.js.map","import { ONE_KIBI_BYTE, computeBytesCount } from '../../tools/utils/byteUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { DOCS_ORIGIN, display } from '../../tools/display';\nimport { isEmptyObject } from '../../tools/utils/objectUtils';\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;\n// We observed that the compression ratio is around 8 in general, but we also want to keep a margin\n// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB\n// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this\n// is a bit arbitrary.\nexport var CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createCustomerDataTrackerManager(compressionStatus) {\n    if (compressionStatus === void 0) { compressionStatus = 2 /* CustomerDataCompressionStatus.Disabled */; }\n    var customerDataTrackers = new Map();\n    var alreadyWarned = false;\n    function checkCustomerDataLimit(initialBytesCount) {\n        if (initialBytesCount === void 0) { initialBytesCount = 0; }\n        if (alreadyWarned || compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n            return;\n        }\n        var bytesCountLimit = compressionStatus === 2 /* CustomerDataCompressionStatus.Disabled */\n            ? CUSTOMER_DATA_BYTES_LIMIT\n            : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT;\n        var bytesCount = initialBytesCount;\n        customerDataTrackers.forEach(function (tracker) {\n            bytesCount += tracker.getBytesCount();\n        });\n        if (bytesCount > bytesCountLimit) {\n            displayCustomerDataLimitReachedWarning(bytesCountLimit);\n            alreadyWarned = true;\n        }\n    }\n    return {\n        /**\n         * Creates a detached tracker. The manager will not store a reference to that tracker, and the\n         * bytes count will be counted independently from other detached trackers.\n         *\n         * This is particularly useful when we don't know when the tracker will be unused, so we don't\n         * leak memory (ex: when used in Logger instances).\n         */\n        createDetachedTracker: function () {\n            var tracker = createCustomerDataTracker(function () { return checkCustomerDataLimit(tracker.getBytesCount()); });\n            return tracker;\n        },\n        /**\n         * Creates a tracker if it doesn't exist, and returns it.\n         */\n        getOrCreateTracker: function (type) {\n            if (!customerDataTrackers.has(type)) {\n                customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit));\n            }\n            return customerDataTrackers.get(type);\n        },\n        setCompressionStatus: function (newCompressionStatus) {\n            if (compressionStatus === 0 /* CustomerDataCompressionStatus.Unknown */) {\n                compressionStatus = newCompressionStatus;\n                checkCustomerDataLimit();\n            }\n        },\n        getCompressionStatus: function () { return compressionStatus; },\n        stop: function () {\n            customerDataTrackers.forEach(function (tracker) { return tracker.stop(); });\n            customerDataTrackers.clear();\n        },\n    };\n}\nexport function createCustomerDataTracker(checkCustomerDataLimit) {\n    var bytesCountCache = 0;\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call context APIs synchronously multiple times in a row\n    var _a = throttle(function (context) {\n        bytesCountCache = computeBytesCount(jsonStringify(context));\n        checkCustomerDataLimit();\n    }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a.throttled, cancelComputeBytesCount = _a.cancel;\n    var resetBytesCount = function () {\n        cancelComputeBytesCount();\n        bytesCountCache = 0;\n    };\n    return {\n        updateCustomerData: function (context) {\n            if (isEmptyObject(context)) {\n                resetBytesCount();\n            }\n            else {\n                computeBytesCountThrottled(context);\n            }\n        },\n        resetCustomerData: resetBytesCount,\n        getBytesCount: function () { return bytesCountCache; },\n        stop: function () {\n            cancelComputeBytesCount();\n        },\n    };\n}\nfunction displayCustomerDataLimitReachedWarning(bytesCountLimit) {\n    display.warn(\"Customer data exceeds the recommended \".concat(bytesCountLimit / ONE_KIBI_BYTE, \"KiB threshold. More details: \").concat(DOCS_ORIGIN, \"/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-threshold-warning\"));\n}\n//# sourceMappingURL=customerDataTracker.js.map","import { addEventListener, DOM_EVENT } from '../../browser/addEventListener';\nimport { combine } from '../../tools/mergeInto';\nvar CONTEXT_STORE_KEY_PREFIX = '_dd_c';\nvar storageListeners = [];\nexport function storeContextManager(configuration, contextManager, productKey, customerDataType) {\n    var storageKey = buildStorageKey(productKey, customerDataType);\n    storageListeners.push(addEventListener(configuration, window, DOM_EVENT.STORAGE, function (_a) {\n        var key = _a.key;\n        if (storageKey === key) {\n            synchronizeWithStorage();\n        }\n    }));\n    contextManager.changeObservable.subscribe(dumpToStorage);\n    contextManager.setContext(combine(getFromStorage(), contextManager.getContext()));\n    function synchronizeWithStorage() {\n        contextManager.setContext(getFromStorage());\n    }\n    function dumpToStorage() {\n        localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()));\n    }\n    function getFromStorage() {\n        var rawContext = localStorage.getItem(storageKey);\n        return rawContext !== null ? JSON.parse(rawContext) : {};\n    }\n}\nexport function buildStorageKey(productKey, customerDataType) {\n    return \"\".concat(CONTEXT_STORE_KEY_PREFIX, \"_\").concat(productKey, \"_\").concat(customerDataType);\n}\nexport function removeStorageListeners() {\n    storageListeners.map(function (listener) { return listener.stop(); });\n}\n//# sourceMappingURL=storeContextManager.js.map","import { sanitize } from '../../tools/serialisation/sanitize';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nexport var NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError(_a) {\n    var stackTrace = _a.stackTrace, originalError = _a.originalError, handlingStack = _a.handlingStack, startClocks = _a.startClocks, nonErrorPrefix = _a.nonErrorPrefix, source = _a.source, handling = _a.handling;\n    var isErrorInstance = originalError instanceof Error;\n    var message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);\n    var stack = hasUsableStack(isErrorInstance, stackTrace)\n        ? toStackTraceString(stackTrace)\n        : NO_ERROR_STACK_PRESENT_MESSAGE;\n    var causes = isErrorInstance ? flattenErrorCauses(originalError, source) : undefined;\n    var type = stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name;\n    var fingerprint = tryToGetFingerprint(originalError);\n    return {\n        startClocks: startClocks,\n        source: source,\n        handling: handling,\n        handlingStack: handlingStack,\n        originalError: originalError,\n        type: type,\n        message: message,\n        stack: stack,\n        causes: causes,\n        fingerprint: fingerprint,\n    };\n}\nfunction computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {\n    // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n    // TODO rework tracekit integration to avoid scattering error building logic\n    return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name)\n        ? stackTrace.message\n        : !isErrorInstance\n            ? \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(sanitize(originalError)))\n            : 'Empty message';\n}\nfunction hasUsableStack(isErrorInstance, stackTrace) {\n    if (stackTrace === undefined) {\n        return false;\n    }\n    if (isErrorInstance) {\n        return true;\n    }\n    // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]\n    // TODO rework tracekit integration to avoid generating those unusable stack\n    return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined);\n}\nexport function tryToGetFingerprint(originalError) {\n    return originalError instanceof Error && 'dd_fingerprint' in originalError\n        ? String(originalError.dd_fingerprint)\n        : undefined;\n}\nexport function getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function flattenErrorCauses(error, parentSource) {\n    var currentError = error;\n    var causes = [];\n    while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && causes.length < 10) {\n        var stackTrace = computeStackTrace(currentError.cause);\n        causes.push({\n            message: currentError.cause.message,\n            source: parentSource,\n            type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n            stack: stackTrace && toStackTraceString(stackTrace),\n        });\n        currentError = currentError.cause;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.js.map","export var ErrorSource = {\n    AGENT: 'agent',\n    CONSOLE: 'console',\n    CUSTOM: 'custom',\n    LOGGER: 'logger',\n    NETWORK: 'network',\n    SOURCE: 'source',\n    REPORT: 'report',\n};\n//# sourceMappingURL=error.types.js.map","import { instrumentMethod } from '../../tools/instrumentMethod';\nimport { clocksNow } from '../../tools/utils/timeUtils';\nimport { computeStackTrace, computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace';\nimport { computeRawError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError(errorObservable) {\n    var handleRuntimeError = function (stackTrace, originalError) {\n        var rawError = computeRawError({\n            stackTrace: stackTrace,\n            originalError: originalError,\n            startClocks: clocksNow(),\n            nonErrorPrefix: \"Uncaught\" /* NonErrorPrefix.UNCAUGHT */,\n            source: ErrorSource.SOURCE,\n            handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n        });\n        errorObservable.notify(rawError);\n    };\n    var stopInstrumentingOnError = instrumentOnError(handleRuntimeError).stop;\n    var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(handleRuntimeError).stop;\n    return {\n        stop: function () {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        },\n    };\n}\nexport function instrumentOnError(callback) {\n    return instrumentMethod(window, 'onerror', function (_a) {\n        var _b = _a.parameters, messageObj = _b[0], url = _b[1], line = _b[2], column = _b[3], errorObj = _b[4];\n        var stackTrace;\n        if (errorObj instanceof Error) {\n            stackTrace = computeStackTrace(errorObj);\n        }\n        else {\n            stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column);\n        }\n        callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);\n    });\n}\nexport function instrumentUnhandledRejection(callback) {\n    return instrumentMethod(window, 'onunhandledrejection', function (_a) {\n        var e = _a.parameters[0];\n        var reason = e.reason || 'Empty reason';\n        var stack = computeStackTrace(reason);\n        callback(stack, reason);\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    var eventCount = 0;\n    var allowNextEvent = false;\n    return {\n        isLimitReached: function () {\n            if (eventCount === 0) {\n                setTimeout(function () {\n                    eventCount = 0;\n                }, ONE_MINUTE);\n            }\n            eventCount += 1;\n            if (eventCount <= limit || allowNextEvent) {\n                allowNextEvent = false;\n                return false;\n            }\n            if (eventCount === limit + 1) {\n                allowNextEvent = true;\n                try {\n                    onLimitReached({\n                        message: \"Reached max number of \".concat(eventType, \"s by minute: \").concat(limit),\n                        source: ErrorSource.AGENT,\n                        startClocks: clocksNow(),\n                    });\n                }\n                finally {\n                    allowNextEvent = false;\n                }\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=createEventRateLimiter.js.map","import { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { addEventListener, DOM_EVENT } from '../../browser/addEventListener';\nimport { includes } from '../../tools/utils/polyfills';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nexport var RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(configuration, apis) {\n    var observables = [];\n    if (includes(apis, RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable(configuration));\n    }\n    var reportTypes = apis.filter(function (api) { return api !== RawReportType.cspViolation; });\n    if (reportTypes.length) {\n        observables.push(createReportObservable(reportTypes));\n    }\n    return mergeObservables.apply(void 0, observables);\n}\nfunction createReportObservable(reportTypes) {\n    return new Observable(function (observable) {\n        if (!window.ReportingObserver) {\n            return;\n        }\n        var handleReports = monitor(function (reports, _) {\n            return reports.forEach(function (report) {\n                observable.notify(buildRawReportFromReport(report));\n            });\n        });\n        var observer = new window.ReportingObserver(handleReports, {\n            types: reportTypes,\n            buffered: true,\n        });\n        observer.observe();\n        return function () {\n            observer.disconnect();\n        };\n    });\n}\nfunction createCspViolationReportObservable(configuration) {\n    return new Observable(function (observable) {\n        var stop = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, function (event) {\n            observable.notify(buildRawReportFromCspViolation(event));\n        }).stop;\n        return stop;\n    });\n}\nfunction buildRawReportFromReport(report) {\n    var type = report.type, body = report.body;\n    return {\n        type: type,\n        subtype: body.id,\n        message: \"\".concat(type, \": \").concat(body.message),\n        originalReport: report,\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    };\n}\nfunction buildRawReportFromCspViolation(event) {\n    var type = RawReportType.cspViolation;\n    var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n    return {\n        type: RawReportType.cspViolation,\n        subtype: event.effectiveDirective,\n        message: \"\".concat(type, \": \").concat(message),\n        stack: buildStack(event.effectiveDirective, event.originalPolicy\n            ? \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\")\n            : 'no policy', event.sourceFile, event.lineNumber, event.columnNumber),\n        originalReport: event,\n    };\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n    return sourceFile\n        ? toStackTraceString({\n            name: name,\n            message: message,\n            stack: [\n                {\n                    func: '?',\n                    url: sourceFile,\n                    line: lineNumber !== null && lineNumber !== void 0 ? lineNumber : undefined,\n                    column: columnNumber !== null && columnNumber !== void 0 ? columnNumber : undefined,\n                },\n            ],\n        })\n        : undefined;\n}\n//# sourceMappingURL=reportObservable.js.map","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\n//# sourceMappingURL=sessionConstants.js.map","import { Observable } from '../../tools/observable';\nimport { ValueHistory } from '../../tools/valueHistory';\nimport { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { DOM_EVENT, addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { clearInterval, setInterval } from '../../tools/timer';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nexport var VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeSessionState, trackingConsentState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    // TODO - Improve configuration type and remove assertion\n    var sessionStore = startSessionStore(configuration.sessionStoreStrategyType, productKey, computeSessionState);\n    stopCallbacks.push(function () { return sessionStore.stop(); });\n    var sessionContextHistory = new ValueHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n        renewObservable.notify();\n    });\n    sessionStore.expireObservable.subscribe(function () {\n        expireObservable.notify();\n        sessionContextHistory.closeActive(relativeNow());\n    });\n    // We expand/renew session unconditionally as tracking consent is always granted when the session\n    // manager is started.\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n    trackingConsentState.observable.subscribe(function () {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n        else {\n            sessionStore.expire();\n        }\n    });\n    trackActivity(configuration, function () {\n        if (trackingConsentState.isGranted()) {\n            sessionStore.expandOrRenewSession();\n        }\n    });\n    trackVisibility(configuration, function () { return sessionStore.expandSession(); });\n    trackResume(configuration, function () { return sessionStore.restartSession(); });\n    function buildSessionContext() {\n        return {\n            id: sessionStore.getSession().id,\n            trackingType: sessionStore.getSession()[productKey],\n            isReplayForced: !!sessionStore.getSession().forcedReplay,\n        };\n    }\n    return {\n        findSession: function (startTime, options) { return sessionContextHistory.find(startTime, options); },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,\n        expire: sessionStore.expire,\n        updateSessionState: sessionStore.updateSessionState,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(configuration, expandOrRenewSession) {\n    var stop = addEventListeners(configuration, window, [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL], expandOrRenewSession, { capture: true, passive: true }).stop;\n    stopCallbacks.push(stop);\n}\nfunction trackVisibility(configuration, expandSession) {\n    var expandSessionWhenVisible = function () {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    };\n    var stop = addEventListener(configuration, document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible).stop;\n    stopCallbacks.push(stop);\n    var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n    stopCallbacks.push(function () {\n        clearInterval(visibilityCheckInterval);\n    });\n}\nfunction trackResume(configuration, cb) {\n    var stop = addEventListener(configuration, window, DOM_EVENT.RESUME, cb, { capture: true }).stop;\n    stopCallbacks.push(stop);\n}\n//# sourceMappingURL=sessionManager.js.map","export var SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants';\nvar SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport var EXPIRED = '1';\nexport function getExpiredSessionState() {\n    return {\n        isExpired: EXPIRED,\n    };\n}\nexport function isSessionInNotStartedState(session) {\n    return isEmptyObject(session);\n}\nexport function isSessionStarted(session) {\n    return !isSessionInNotStartedState(session);\n}\nexport function isSessionInExpiredState(session) {\n    return session.isExpired !== undefined || !isActiveSession(session);\n}\n// An active session is a session in either `Tracked` or `NotTracked` state\nfunction isActiveSession(sessionState) {\n    // created and expire can be undefined for versions which was not storing them\n    // these checks could be removed when older versions will not be available/live anymore\n    return ((sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&\n        (sessionState.expire === undefined || dateNow() < Number(sessionState.expire)));\n}\nexport function expandSessionState(session) {\n    session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n    return objectEntries(session)\n        .map(function (_a) {\n        var key = _a[0], value = _a[1];\n        return \"\".concat(key, \"=\").concat(value);\n    })\n        .join(SESSION_ENTRY_SEPARATOR);\n}\nexport function toSessionState(sessionString) {\n    var session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {\n            var matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                var key = matches[1], value = matches[2];\n                session[key] = value;\n            }\n        });\n    }\n    return session;\n}\nfunction isValidSessionString(sessionString) {\n    return (!!sessionString &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\n//# sourceMappingURL=sessionState.js.map","import { getInitCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionStarted } from './sessionState';\nexport var OLD_SESSION_COOKIE_NAME = '_dd';\nexport var OLD_RUM_COOKIE_NAME = '_dd_r';\nexport var OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport var RUM_SESSION_KEY = 'rum';\nexport var LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(cookieStoreStrategy) {\n    var sessionString = getInitCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        var oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME);\n        var oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME);\n        var oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME);\n        var session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        if (isSessionStarted(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { isChromium } from '../../../tools/utils/browserDetection';\nimport { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from '../sessionConstants';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n    var cookieOptions = buildCookieOptions(initConfiguration);\n    return areCookiesAuthorized(cookieOptions) ? { type: 'Cookie', cookieOptions: cookieOptions } : undefined;\n}\nexport function initCookieStrategy(cookieOptions) {\n    var cookieStore = {\n        /**\n         * Lock strategy allows mitigating issues due to concurrent access to cookie.\n         * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.\n         */\n        isLockEnabled: isChromium(),\n        persistSession: persistSessionCookie(cookieOptions),\n        retrieveSession: retrieveSessionCookie,\n        expireSession: function () { return expireSessionCookie(cookieOptions); },\n    };\n    tryOldCookiesMigration(cookieStore);\n    return cookieStore;\n}\nfunction persistSessionCookie(options) {\n    return function (session) {\n        setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n    };\n}\nfunction expireSessionCookie(options) {\n    setCookie(SESSION_STORE_KEY, toSessionString(getExpiredSessionState()), SESSION_TIME_OUT_DELAY, options);\n}\nfunction retrieveSessionCookie() {\n    var sessionString = getCookie(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nexport function buildCookieOptions(initConfiguration) {\n    var cookieOptions = {};\n    cookieOptions.secure =\n        !!initConfiguration.useSecureSessionCookie ||\n            !!initConfiguration.usePartitionedCrossSiteSessionCookie ||\n            !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.crossSite =\n        !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nvar LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n    try {\n        var id = generateUUID();\n        var testKey = \"\".concat(LOCAL_STORAGE_TEST_KEY).concat(id);\n        localStorage.setItem(testKey, id);\n        var retrievedId = localStorage.getItem(testKey);\n        localStorage.removeItem(testKey);\n        return id === retrievedId ? { type: 'LocalStorage' } : undefined;\n    }\n    catch (e) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy() {\n    return {\n        isLockEnabled: false,\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        expireSession: expireSessionFromLocalStorage,\n    };\n}\nfunction persistInLocalStorage(sessionState) {\n    localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n    var sessionString = localStorage.getItem(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction expireSessionFromLocalStorage() {\n    persistInLocalStorage(getExpiredSessionState());\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var LOCK_RETRY_DELAY = 10;\nexport var LOCK_MAX_TRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries) {\n    var _a;\n    if (numberOfRetries === void 0) { numberOfRetries = 0; }\n    var isLockEnabled = sessionStoreStrategy.isLockEnabled, persistSession = sessionStoreStrategy.persistSession, expireSession = sessionStoreStrategy.expireSession;\n    var persistWithLock = function (session) { return persistSession(assign({}, session, { lock: currentLock })); };\n    var retrieveStore = function () {\n        var session = sessionStoreStrategy.retrieveSession();\n        var lock = session.lock;\n        if (session.lock) {\n            delete session.lock;\n        }\n        return {\n            session: session,\n            lock: lock,\n        };\n    };\n    if (!ongoingOperations) {\n        ongoingOperations = operations;\n    }\n    if (operations !== ongoingOperations) {\n        bufferedOperations.push(operations);\n        return;\n    }\n    if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {\n        next(sessionStoreStrategy);\n        return;\n    }\n    var currentLock;\n    var currentStore = retrieveStore();\n    if (isLockEnabled) {\n        // if someone has lock, retry later\n        if (currentStore.lock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n        // acquire lock\n        currentLock = generateUUID();\n        persistWithLock(currentStore.session);\n        // if lock is not acquired, retry later\n        currentStore = retrieveStore();\n        if (currentStore.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    var processedSession = operations.process(currentStore.session);\n    if (isLockEnabled) {\n        // if lock corrupted after process, retry later\n        currentStore = retrieveStore();\n        if (currentStore.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    if (processedSession) {\n        if (isSessionInExpiredState(processedSession)) {\n            expireSession();\n        }\n        else {\n            expandSessionState(processedSession);\n            isLockEnabled ? persistWithLock(processedSession) : persistSession(processedSession);\n        }\n    }\n    if (isLockEnabled) {\n        // correctly handle lock around expiration would require to handle this case properly at several levels\n        // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n        if (!(processedSession && isSessionInExpiredState(processedSession))) {\n            // if lock corrupted after persist, retry later\n            currentStore = retrieveStore();\n            if (currentStore.lock !== currentLock) {\n                retryLater(operations, sessionStoreStrategy, numberOfRetries);\n                return;\n            }\n            persistSession(currentStore.session);\n            processedSession = currentStore.session;\n        }\n    }\n    // call after even if session is not persisted in order to perform operations on\n    // up-to-date session state value => the value could have been modified by another tab\n    (_a = operations.after) === null || _a === void 0 ? void 0 : _a.call(operations, processedSession || currentStore.session);\n    next(sessionStoreStrategy);\n}\nfunction retryLater(operations, sessionStore, currentNumberOfRetries) {\n    setTimeout(function () {\n        processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);\n    }, LOCK_RETRY_DELAY);\n}\nfunction next(sessionStore) {\n    ongoingOperations = undefined;\n    var nextOperations = bufferedOperations.shift();\n    if (nextOperations) {\n        processSessionStoreOperations(nextOperations, sessionStore);\n    }\n}\n//# sourceMappingURL=sessionStoreOperations.js.map","import { clearInterval, setInterval } from '../../tools/timer';\nimport { Observable } from '../../tools/observable';\nimport { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { getExpiredSessionState, isSessionInExpiredState, isSessionInNotStartedState, isSessionStarted, } from './sessionState';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\n/**\n * Every second, the storage will be polled to check for any change that can occur\n * to the session state in another browser tab, or another window.\n * This value has been determined from our previous cookie-only implementation.\n */\nexport var STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Checks if cookies are available as the preferred storage\n * Else, checks if LocalStorage is allowed and available\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    var sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n    if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n        sessionStoreStrategyType = selectLocalStorageStrategy();\n    }\n    return sessionStoreStrategyType;\n}\n/**\n * Different session concepts:\n * - tracked, the session has an id and is updated along the user navigation\n * - not tracked, the session does not have an id but it is updated along the user navigation\n * - inactive, no session in store or session expired, waiting for a renew session\n */\nexport function startSessionStore(sessionStoreStrategyType, productKey, computeSessionState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    var sessionStateUpdateObservable = new Observable();\n    var sessionStoreStrategy = sessionStoreStrategyType.type === 'Cookie'\n        ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy();\n    var expireSession = sessionStoreStrategy.expireSession;\n    var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n    var sessionCache;\n    startSession();\n    var _a = throttle(function () {\n        processSessionStoreOperations({\n            process: function (sessionState) {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return;\n                }\n                var synchronizedSession = synchronizeSession(sessionState);\n                expandOrRenewSessionState(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (sessionState) {\n                if (isSessionStarted(sessionState) && !hasSessionInCache()) {\n                    renewSessionInCache(sessionState);\n                }\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }, STORAGE_POLL_DELAY), throttledExpandOrRenewSession = _a.throttled, cancelExpandOrRenewSession = _a.cancel;\n    function expandSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) { return (hasSessionInCache() ? synchronizeSession(sessionState) : undefined); },\n        }, sessionStoreStrategy);\n    }\n    /**\n     * allows two behaviors:\n     * - if the session is active, synchronize the session cache without updating the session store\n     * - if the session is not active, clear the session store and expire the session cache\n     */\n    function watchSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) { return (isSessionInExpiredState(sessionState) ? getExpiredSessionState() : undefined); },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    function synchronizeSession(sessionState) {\n        if (isSessionInExpiredState(sessionState)) {\n            sessionState = getExpiredSessionState();\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(sessionState)) {\n                expireSessionInCache();\n            }\n            else {\n                sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState });\n                sessionCache = sessionState;\n            }\n        }\n        return sessionState;\n    }\n    function startSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) {\n                if (isSessionInNotStartedState(sessionState)) {\n                    return getExpiredSessionState();\n                }\n            },\n            after: function (sessionState) {\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\n    function expandOrRenewSessionState(sessionState) {\n        if (isSessionInNotStartedState(sessionState)) {\n            return false;\n        }\n        var _a = computeSessionState(sessionState[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\n        sessionState[productKey] = trackingType;\n        delete sessionState.isExpired;\n        if (isTracked && !sessionState.id) {\n            sessionState.id = generateUUID();\n            sessionState.created = String(dateNow());\n        }\n    }\n    function hasSessionInCache() {\n        return sessionCache[productKey] !== undefined;\n    }\n    function isSessionInCacheOutdated(sessionState) {\n        return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];\n    }\n    function expireSessionInCache() {\n        sessionCache = getExpiredSessionState();\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function updateSessionState(partialSessionState) {\n        processSessionStoreOperations({\n            process: function (sessionState) { return assign({}, sessionState, partialSessionState); },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    return {\n        expandOrRenewSession: throttledExpandOrRenewSession,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        sessionStateUpdateObservable: sessionStateUpdateObservable,\n        restartSession: startSession,\n        expire: function () {\n            cancelExpandOrRenewSession();\n            expireSession();\n            synchronizeSession(getExpiredSessionState());\n        },\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n        updateSessionState: updateSessionState,\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { getInitCookie } from '../../browser/cookie';\nexport var SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    var value = window._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","export var TelemetryType = {\n    log: 'log',\n    configuration: 'configuration',\n    usage: 'usage',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/error';\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/utils/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { sendToExtension } from '../../tools/sendToExtension';\nimport { startsWith, arrayFrom, includes, assign } from '../../tools/utils/polyfills';\nimport { performDraw } from '../../tools/utils/numberUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { combine } from '../../tools/mergeInto';\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace';\nimport { getConnectivity } from '../connectivity';\nimport { BoundedBuffer } from '../../tools/boundedBuffer';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nvar ALLOWED_FRAME_URLS = [\n    'https://www.datadoghq-browser-agent.com',\n    'https://www.datad0g-browser-agent.com',\n    'https://d3uc069fcn7uxw.cloudfront.net',\n    'https://d20xtzwzcl0ceb.cloudfront.net',\n    'http://localhost',\n    '<anonymous>',\n];\nvar TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\n// eslint-disable-next-line local-rules/disallow-side-effects\nvar preStartTelemetryBuffer = new BoundedBuffer();\nvar onRawTelemetryEventCollected = function (event) {\n    preStartTelemetryBuffer.add(function () { return onRawTelemetryEventCollected(event); });\n};\nexport function startTelemetry(telemetryService, configuration) {\n    var _a;\n    var contextProvider;\n    var observable = new Observable();\n    var alreadySentEvents = new Set();\n    var telemetryEnabled = !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n    var telemetryEnabledPerType = (_a = {},\n        _a[TelemetryType.log] = telemetryEnabled,\n        _a[TelemetryType.configuration] = telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),\n        _a[TelemetryType.usage] = telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),\n        _a);\n    var runtimeEnvInfo = getRuntimeEnvInfo();\n    onRawTelemetryEventCollected = function (rawEvent) {\n        var stringifiedEvent = jsonStringify(rawEvent);\n        if (telemetryEnabledPerType[rawEvent.type] &&\n            alreadySentEvents.size < configuration.maxTelemetryEventsPerPage &&\n            !alreadySentEvents.has(stringifiedEvent)) {\n            var event_1 = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo);\n            observable.notify(event_1);\n            sendToExtension('telemetry', event_1);\n            alreadySentEvents.add(stringifiedEvent);\n        }\n    };\n    startMonitorErrorCollection(addTelemetryError);\n    function toTelemetryEvent(telemetryService, event, runtimeEnvInfo) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: telemetryService,\n            version: \"5.22.0\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: combine(event, {\n                runtime_env: runtimeEnvInfo,\n                connectivity: getConnectivity(),\n            }),\n            experimental_features: arrayFrom(getExperimentalFeatures()),\n        }, contextProvider !== undefined ? contextProvider() : {});\n    }\n    return {\n        setContextProvider: function (provider) {\n            contextProvider = provider;\n        },\n        observable: observable,\n        enabled: telemetryEnabled,\n    };\n}\nfunction getRuntimeEnvInfo() {\n    return {\n        is_local_file: window.location.protocol === 'file:',\n        is_worker: 'WorkerGlobalScope' in self,\n    };\n}\nexport function startFakeTelemetry() {\n    var events = [];\n    onRawTelemetryEventCollected = function (event) {\n        events.push(event);\n    };\n    return events;\n}\n// need to be called after telemetry context is provided and observers are registered\nexport function drainPreStartTelemetry() {\n    preStartTelemetryBuffer.drain();\n}\nexport function resetTelemetry() {\n    preStartTelemetryBuffer = new BoundedBuffer();\n    onRawTelemetryEventCollected = function (event) {\n        preStartTelemetryBuffer.add(function () { return onRawTelemetryEventCollected(event); });\n    };\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nexport function isTelemetryReplicationAllowed(configuration) {\n    return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n    displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n    onRawTelemetryEventCollected(assign({\n        type: TelemetryType.log,\n        message: message,\n        status: \"debug\" /* StatusType.debug */,\n    }, context));\n}\nexport function addTelemetryError(e, context) {\n    onRawTelemetryEventCollected(assign({\n        type: TelemetryType.log,\n        status: \"error\" /* StatusType.error */,\n    }, formatError(e), context));\n}\nexport function addTelemetryConfiguration(configuration) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.configuration,\n        configuration: configuration,\n    });\n}\nexport function addTelemetryUsage(usage) {\n    onRawTelemetryEventCollected({\n        type: TelemetryType.usage,\n        usage: usage,\n    });\n}\nexport function formatError(e) {\n    if (e instanceof Error) {\n        var stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(scrubCustomerFrames(stackTrace)),\n            },\n            message: stackTrace.message,\n        };\n    }\n    return {\n        error: {\n            stack: NO_ERROR_STACK_PRESENT_MESSAGE,\n        },\n        message: \"\".concat(\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */, \" \").concat(jsonStringify(e)),\n    };\n}\nexport function scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter(function (frame) { return !frame.url || ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) { return startsWith(frame.url, allowedFrameUrl); }); });\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { Observable } from '../tools/observable';\nexport var TrackingConsent = {\n    GRANTED: 'granted',\n    NOT_GRANTED: 'not-granted',\n};\nexport function createTrackingConsentState(currentConsent) {\n    var observable = new Observable();\n    return {\n        tryToInit: function (trackingConsent) {\n            if (!currentConsent) {\n                currentConsent = trackingConsent;\n            }\n        },\n        update: function (trackingConsent) {\n            currentConsent = trackingConsent;\n            observable.notify();\n        },\n        isGranted: function () {\n            return currentConsent === TrackingConsent.GRANTED;\n        },\n        observable: observable,\n    };\n}\n//# sourceMappingURL=trackingConsent.js.map","import { display } from '../../tools/display';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { assign } from '../../tools/utils/polyfills';\n/**\n * Clone input data and ensure known user properties (id, name, email)\n * are strings, as defined here:\n * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n */\nexport function sanitizeUser(newUser) {\n    // We shallow clone only to prevent mutation of user data.\n    var user = assign({}, newUser);\n    var keys = ['id', 'name', 'email'];\n    keys.forEach(function (key) {\n        if (key in user) {\n            user[key] = String(user[key]);\n        }\n    });\n    return user;\n}\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser) {\n    var isValid = getType(newUser) === 'object';\n    if (!isValid) {\n        display.error('Unsupported user:', newUser);\n    }\n    return isValid;\n}\n//# sourceMappingURL=user.js.map","var AbstractLifeCycle = /** @class */ (function () {\n    function AbstractLifeCycle() {\n        this.callbacks = {};\n    }\n    AbstractLifeCycle.prototype.notify = function (eventType, data) {\n        var eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach(function (callback) { return callback(data); });\n        }\n    };\n    AbstractLifeCycle.prototype.subscribe = function (eventType, callback) {\n        var _this = this;\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: function () {\n                _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) { return callback !== other; });\n            },\n        };\n    };\n    return AbstractLifeCycle;\n}());\nexport { AbstractLifeCycle };\n//# sourceMappingURL=abstractLifeCycle.js.map","import { removeItem } from './utils/arrayUtils';\nvar BUFFER_LIMIT = 500;\nvar BoundedBuffer = /** @class */ (function () {\n    function BoundedBuffer() {\n        this.buffer = [];\n    }\n    BoundedBuffer.prototype.add = function (callback) {\n        var length = this.buffer.push(callback);\n        if (length > BUFFER_LIMIT) {\n            this.buffer.splice(0, 1);\n        }\n    };\n    BoundedBuffer.prototype.remove = function (callback) {\n        removeItem(this.buffer, callback);\n    };\n    BoundedBuffer.prototype.drain = function (arg) {\n        this.buffer.forEach(function (callback) { return callback(arg); });\n        this.buffer.length = 0;\n    };\n    return BoundedBuffer;\n}());\nexport { BoundedBuffer };\n//# sourceMappingURL=boundedBuffer.js.map","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        try {\n            return fn.apply(void 0, args);\n        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","/* eslint-disable local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport var ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\n/**\n * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove\n * \"console.*\" references. This causes some issue as we expect `console.*` to be defined.\n * As a workaround, let's use a variable alias, so those expressions won't be taken into account by\n * simple static analysis.\n *\n * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/\n * [2]: https://github.com/terser/terser#compress-options (look for drop_console)\n */\nexport var globalConsole = console;\nexport var originalConsoleMethods = {};\nObject.keys(ConsoleApiName).forEach(function (name) {\n    originalConsoleMethods[name] = globalConsole[name];\n});\nvar PREFIX = 'Datadog Browser SDK:';\nexport var display = {\n    debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),\n    log: originalConsoleMethods.log.bind(globalConsole, PREFIX),\n    info: originalConsoleMethods.info.bind(globalConsole, PREFIX),\n    warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),\n    error: originalConsoleMethods.error.bind(globalConsole, PREFIX),\n};\nexport var DOCS_ORIGIN = 'https://docs.datadoghq.com';\n//# sourceMappingURL=display.js.map","import { computeBytesCount } from './utils/byteUtils';\nexport function createIdentityEncoder() {\n    var output = '';\n    var outputBytesCount = 0;\n    return {\n        isAsync: false,\n        get isEmpty() {\n            return !output;\n        },\n        write: function (data, callback) {\n            var additionalEncodedBytesCount = computeBytesCount(data);\n            outputBytesCount += additionalEncodedBytesCount;\n            output += data;\n            if (callback) {\n                callback(additionalEncodedBytesCount);\n            }\n        },\n        finish: function (callback) {\n            callback(this.finishSync());\n        },\n        finishSync: function () {\n            var result = {\n                output: output,\n                outputBytesCount: outputBytesCount,\n                rawBytesCount: outputBytesCount,\n                pendingData: '',\n            };\n            output = '';\n            outputBytesCount = 0;\n            return result;\n        },\n        estimateEncodedBytesCount: function (data) {\n            return data.length;\n        },\n    };\n}\n//# sourceMappingURL=encoder.js.map","/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\nimport { objectHasValue } from './utils/objectUtils';\n// eslint-disable-next-line no-restricted-syntax\nexport var ExperimentalFeature;\n(function (ExperimentalFeature) {\n    ExperimentalFeature[\"WRITABLE_RESOURCE_GRAPHQL\"] = \"writable_resource_graphql\";\n    ExperimentalFeature[\"CUSTOM_VITALS\"] = \"custom_vitals\";\n    ExperimentalFeature[\"TOLERANT_RESOURCE_TIMINGS\"] = \"tolerant_resource_timings\";\n    ExperimentalFeature[\"REMOTE_CONFIGURATION\"] = \"remote_configuration\";\n    ExperimentalFeature[\"PLUGINS\"] = \"plugins\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nvar enabledExperimentalFeatures = new Set();\nexport function initFeatureFlags(enableExperimentalFeatures) {\n    if (Array.isArray(enableExperimentalFeatures)) {\n        addExperimentalFeatures(enableExperimentalFeatures.filter(function (flag) {\n            return objectHasValue(ExperimentalFeature, flag);\n        }));\n    }\n}\nexport function addExperimentalFeatures(enabledFeatures) {\n    enabledFeatures.forEach(function (flag) {\n        enabledExperimentalFeatures.add(flag);\n    });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n    return enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n    enabledExperimentalFeatures.clear();\n}\nexport function getExperimentalFeatures() {\n    return enabledExperimentalFeatures;\n}\n//# sourceMappingURL=experimentalFeatures.js.map","/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject() {\n    if (typeof globalThis === 'object') {\n        return globalThis;\n    }\n    Object.defineProperty(Object.prototype, '_dd_temp_', {\n        get: function () {\n            return this;\n        },\n        configurable: true,\n    });\n    // @ts-ignore _dd_temp is defined using defineProperty\n    var globalObject = _dd_temp_;\n    // @ts-ignore _dd_temp is defined using defineProperty\n    delete Object.prototype._dd_temp_;\n    if (typeof globalObject !== 'object') {\n        // on safari _dd_temp_ is available on window but not globally\n        // fallback on other browser globals check\n        if (typeof self === 'object') {\n            globalObject = self;\n        }\n        else if (typeof window === 'object') {\n            globalObject = window;\n        }\n        else {\n            globalObject = {};\n        }\n    }\n    return globalObject;\n}\n//# sourceMappingURL=getGlobalObject.js.map","import { getGlobalObject } from './getGlobalObject';\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n    var browserWindow = getGlobalObject();\n    var original;\n    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n        original = target[browserWindow.Zone.__symbol__(name)];\n    }\n    if (!original) {\n        original = target[name];\n    }\n    return original;\n}\n//# sourceMappingURL=getZoneJsOriginalValue.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nimport { arrayFrom, startsWith } from './utils/polyfills';\nimport { createHandlingStack } from './stackTrace/handlingStack';\n/**\n * Instruments a method on a object, calling the given callback before the original method is\n * invoked. The callback receives an object with information about the method call.\n *\n * This function makes sure that we are \"good citizens\" regarding third party instrumentations: when\n * removing the instrumentation, the original method is usually restored, but if a third party\n * instrumentation was set after ours, we keep it in place and just replace our instrumentation with\n * a noop.\n *\n * Note: it is generally better to instrument methods that are \"owned\" by the object instead of ones\n * that are inherited from the prototype chain. Example:\n * * do:    `instrumentMethod(Array.prototype, 'push', ...)`\n * * don't: `instrumentMethod([], 'push', ...)`\n *\n * This method is also used to set event handler properties (ex: window.onerror = ...), as it has\n * the same requirements as instrumenting a method:\n * * if the event handler is already set by a third party, we need to call it and not just blindly\n * override it.\n * * if the event handler is set by a third party after us, we need to keep it in place when\n * removing ours.\n *\n * @example\n *\n *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {\n *    console.log('Before calling fetch on', target, 'with parameters', parameters)\n *\n *    onPostCall((result) => {\n *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)\n *    })\n *  })\n */\nexport function instrumentMethod(targetPrototype, method, onPreCall, _a) {\n    var _b = _a === void 0 ? {} : _a, computeHandlingStack = _b.computeHandlingStack;\n    var original = targetPrototype[method];\n    if (typeof original !== 'function') {\n        if (startsWith(method, 'on')) {\n            original = noop;\n        }\n        else {\n            return { stop: noop };\n        }\n    }\n    var stopped = false;\n    var instrumentation = function () {\n        if (stopped) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n            return original.apply(this, arguments);\n        }\n        var parameters = arrayFrom(arguments);\n        var postCallCallback;\n        callMonitored(onPreCall, null, [\n            {\n                target: this,\n                parameters: parameters,\n                onPostCall: function (callback) {\n                    postCallCallback = callback;\n                },\n                handlingStack: computeHandlingStack ? createHandlingStack() : undefined,\n            },\n        ]);\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        var result = original.apply(this, parameters);\n        if (postCallCallback) {\n            callMonitored(postCallCallback, null, [result]);\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return result;\n    };\n    targetPrototype[method] = instrumentation;\n    return {\n        stop: function () {\n            stopped = true;\n            // If the instrumentation has been removed by a third party, keep the last one\n            if (targetPrototype[method] === instrumentation) {\n                targetPrototype[method] = original;\n            }\n        },\n    };\n}\nexport function instrumentSetter(targetPrototype, property, after) {\n    var originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    var stoppedInstrumentation = noop;\n    var instrumentation = function (target, value) {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(function () {\n            if (instrumentation !== stoppedInstrumentation) {\n                after(target, value);\n            }\n        }, 0);\n    };\n    var instrumentationWrapper = function (value) {\n        originalDescriptor.set.call(this, value);\n        instrumentation(this, value);\n    };\n    Object.defineProperty(targetPrototype, property, {\n        set: instrumentationWrapper,\n    });\n    return {\n        stop: function () {\n            var _a;\n            if (((_a = Object.getOwnPropertyDescriptor(targetPrototype, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n                Object.defineProperty(targetPrototype, property, originalDescriptor);\n            }\n            instrumentation = stoppedInstrumentation;\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { getType } from './utils/typeUtils';\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker) {\n    if (circularReferenceChecker === void 0) { circularReferenceChecker = createCircularReferenceChecker(); }\n    // ignore the source if it is undefined\n    if (source === undefined) {\n        return destination;\n    }\n    if (typeof source !== 'object' || source === null) {\n        // primitive values - just return source\n        return source;\n    }\n    else if (source instanceof Date) {\n        return new Date(source.getTime());\n    }\n    else if (source instanceof RegExp) {\n        var flags = source.flags ||\n            // old browsers compatibility\n            [\n                source.global ? 'g' : '',\n                source.ignoreCase ? 'i' : '',\n                source.multiline ? 'm' : '',\n                source.sticky ? 'y' : '',\n                source.unicode ? 'u' : '',\n            ].join('');\n        return new RegExp(source.source, flags);\n    }\n    if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n        // remove circular references\n        return undefined;\n    }\n    else if (Array.isArray(source)) {\n        var merged_1 = Array.isArray(destination) ? destination : [];\n        for (var i = 0; i < source.length; ++i) {\n            merged_1[i] = mergeInto(merged_1[i], source[i], circularReferenceChecker);\n        }\n        return merged_1;\n    }\n    var merged = getType(destination) === 'object' ? destination : {};\n    for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n            merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);\n        }\n    }\n    return merged;\n}\n/**\n * A simplistic implementation of a deep clone algorithm.\n * Caveats:\n * - It doesn't maintain prototype chains - don't use with instances of custom classes.\n * - It doesn't handle Map and Set\n */\nexport function deepClone(value) {\n    return mergeInto(undefined, value);\n}\nexport function combine() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    var destination;\n    for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {\n        var source = sources_1[_a];\n        // Ignore any undefined or null sources.\n        if (source === undefined || source === null) {\n            continue;\n        }\n        destination = mergeInto(destination, source);\n    }\n    return destination;\n}\nfunction createCircularReferenceChecker() {\n    if (typeof WeakSet !== 'undefined') {\n        var set_1 = new WeakSet();\n        return {\n            hasAlreadyBeenSeen: function (value) {\n                var has = set_1.has(value);\n                if (!has) {\n                    set_1.add(value);\n                }\n                return has;\n            },\n        };\n    }\n    var array = [];\n    return {\n        hasAlreadyBeenSeen: function (value) {\n            var has = array.indexOf(value) >= 0;\n            if (!has) {\n                array.push(value);\n            }\n            return has;\n        },\n    };\n}\n//# sourceMappingURL=mergeInto.js.map","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { display } from './display';\nvar onMonitorErrorCollected;\nvar debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n    onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n    debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n    onMonitorErrorCollected = undefined;\n    debugMode = false;\n}\nexport function monitored(_, __, descriptor) {\n    var originalMethod = descriptor.value;\n    descriptor.value = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        displayIfDebugEnabled(e);\n        if (onMonitorErrorCollected) {\n            try {\n                onMonitorErrorCollected(e);\n            }\n            catch (e) {\n                displayIfDebugEnabled(e);\n            }\n        }\n    }\n}\nexport function displayIfDebugEnabled() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    if (debugMode) {\n        display.error.apply(display, __spreadArray(['[MONITOR]'], args, false));\n    }\n}\n//# sourceMappingURL=monitor.js.map","var Observable = /** @class */ (function () {\n    function Observable(onFirstSubscribe) {\n        this.onFirstSubscribe = onFirstSubscribe;\n        this.observers = [];\n    }\n    Observable.prototype.subscribe = function (f) {\n        var _this = this;\n        if (!this.observers.length && this.onFirstSubscribe) {\n            this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined;\n        }\n        this.observers.push(f);\n        return {\n            unsubscribe: function () {\n                _this.observers = _this.observers.filter(function (other) { return f !== other; });\n                if (!_this.observers.length && _this.onLastUnsubscribe) {\n                    _this.onLastUnsubscribe();\n                }\n            },\n        };\n    };\n    Observable.prototype.notify = function (data) {\n        this.observers.forEach(function (observer) { return observer(data); });\n    };\n    return Observable;\n}());\nexport { Observable };\nexport function mergeObservables() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    return new Observable(function (globalObservable) {\n        var subscriptions = observables.map(function (observable) {\n            return observable.subscribe(function (data) { return globalObservable.notify(data); });\n        });\n        return function () { return subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); }); };\n    });\n}\n//# sourceMappingURL=observable.js.map","import { monitor } from './monitor';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n    var reader = stream.getReader();\n    var chunks = [];\n    var readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor(function (result) {\n            if (result.done) {\n                onDone();\n                return;\n            }\n            if (options.collectStreamBody) {\n                chunks.push(result.value);\n            }\n            readBytesCount += result.value.length;\n            if (readBytesCount > options.bytesLimit) {\n                onDone();\n            }\n            else {\n                readMore();\n            }\n        }), monitor(function (error) { return callback(error); }));\n    }\n    function onDone() {\n        reader.cancel().catch(\n        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n        // as an unhandled rejection\n        noop);\n        var bytes;\n        var limitExceeded;\n        if (options.collectStreamBody) {\n            var completeBuffer_1;\n            if (chunks.length === 1) {\n                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n                // use it directly.\n                completeBuffer_1 = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer_1 = new Uint8Array(readBytesCount);\n                var offset_1 = 0;\n                chunks.forEach(function (chunk) {\n                    completeBuffer_1.set(chunk, offset_1);\n                    offset_1 += chunk.length;\n                });\n            }\n            bytes = completeBuffer_1.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer_1.length > options.bytesLimit;\n        }\n        callback(undefined, bytes, limitExceeded);\n    }\n}\n//# sourceMappingURL=readBytesFromStream.js.map","export function sendToExtension(type, payload) {\n    var callback = window.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type: type, payload: payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.js.map","import { noop } from '../utils/functionUtils';\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n    if (typeof value !== 'object' || value === null) {\n        return JSON.stringify(value);\n    }\n    // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n    // subclasses.\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    var restoreValueToJson = detachToJsonMethod(value);\n    try {\n        return JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        return '<error: unable to serialize object>';\n    }\n    finally {\n        restoreObjectPrototypeToJson();\n        restoreArrayPrototypeToJson();\n        restoreValuePrototypeToJson();\n        restoreValueToJson();\n    }\n}\nexport function detachToJsonMethod(value) {\n    var object = value;\n    var objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return function () {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\n//# sourceMappingURL=jsonStringify.js.map","import { display } from '../display';\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { detachToJsonMethod } from './jsonStringify';\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nvar SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nvar JSON_PATH_ROOT_ELEMENT = '$';\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nvar KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount) {\n    var _a;\n    if (maxCharacterCount === void 0) { maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT; }\n    // Unbind any toJSON function we may have on [] or {} prototypes\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    var containerQueue = [];\n    var visitedObjectsWithPath = new WeakMap();\n    var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n    var accumulatedCharacterCount = ((_a = JSON.stringify(sanitizedData)) === null || _a === void 0 ? void 0 : _a.length) || 0;\n    if (accumulatedCharacterCount > maxCharacterCount) {\n        warnOverCharacterLimit(maxCharacterCount, 'discarded', source);\n        return undefined;\n    }\n    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n        var containerToProcess = containerQueue.shift();\n        var separatorLength = 0; // 0 for the first element, 1 for subsequent elements\n        // Arrays and Objects have to be handled distinctly to ensure\n        // we do not pick up non-numerical properties from Arrays\n        if (Array.isArray(containerToProcess.source)) {\n            for (var key = 0; key < containerToProcess.source.length; key++) {\n                var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                if (targetData !== undefined) {\n                    accumulatedCharacterCount += JSON.stringify(targetData).length;\n                }\n                else {\n                    // When an element of an Array (targetData) is undefined, it is serialized as null:\n                    // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n                    accumulatedCharacterCount += 4;\n                }\n                accumulatedCharacterCount += separatorLength;\n                separatorLength = 1;\n                if (accumulatedCharacterCount > maxCharacterCount) {\n                    warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                    break;\n                }\n                ;\n                containerToProcess.target[key] = targetData;\n            }\n        }\n        else {\n            for (var key in containerToProcess.source) {\n                if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n                    var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                    // When a property of an object has an undefined value, it will be dropped during serialization:\n                    // JSON.stringify({a:undefined}) => '{}'\n                    if (targetData !== undefined) {\n                        accumulatedCharacterCount +=\n                            JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;\n                        separatorLength = 1;\n                    }\n                    if (accumulatedCharacterCount > maxCharacterCount) {\n                        warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                        break;\n                    }\n                    ;\n                    containerToProcess.target[key] = targetData;\n                }\n            }\n        }\n    }\n    // Rebind detached toJSON functions\n    restoreObjectPrototypeToJson();\n    restoreArrayPrototypeToJson();\n    return sanitizedData;\n}\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {\n    // Start by handling toJSON, as we want to sanitize its output\n    var sourceToSanitize = tryToApplyToJSON(source);\n    if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n        return sanitizePrimitivesAndFunctions(sourceToSanitize);\n    }\n    var sanitizedSource = sanitizeObjects(sourceToSanitize);\n    if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n        return sanitizedSource;\n    }\n    // Handle potential cyclic references\n    // We need to use source as sourceToSanitize could be a reference to a new object\n    // At this stage, we know the source is an object type\n    var sourceAsObject = source;\n    if (visitedObjectsWithPath.has(sourceAsObject)) {\n        return \"[Reference seen at \".concat(visitedObjectsWithPath.get(sourceAsObject), \"]\");\n    }\n    // Add processed source to queue\n    var currentPath = key !== undefined ? \"\".concat(parentPath, \".\").concat(key) : parentPath;\n    var target = Array.isArray(sourceToSanitize) ? [] : {};\n    visitedObjectsWithPath.set(sourceAsObject, currentPath);\n    queue.push({ source: sourceToSanitize, target: target, path: currentPath });\n    return target;\n}\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value) {\n    // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n    if (typeof value === 'bigint') {\n        return \"[BigInt] \".concat(value.toString());\n    }\n    // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n    // so it won't prevent stringify from serializing later\n    if (typeof value === 'function') {\n        return \"[Function] \".concat(value.name || 'unknown');\n    }\n    // JSON.stringify() does not serialize symbols.\n    if (typeof value === 'symbol') {\n        return \"[Symbol] \".concat(value.description || value.toString());\n    }\n    return value;\n}\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their\n * properties enumerated if any.\n *\n */\nfunction sanitizeObjects(value) {\n    try {\n        // Handle events - Keep a simple implementation to avoid breaking changes\n        if (value instanceof Event) {\n            return {\n                isTrusted: value.isTrusted,\n            };\n        }\n        // Handle all remaining object types in a generic way\n        var result = Object.prototype.toString.call(value);\n        var match = result.match(/\\[object (.*)\\]/);\n        if (match && match[1]) {\n            return \"[\".concat(match[1], \"]\");\n        }\n    }\n    catch (_a) {\n        // If the previous serialization attempts failed, and we cannot convert using\n        // Object.prototype.toString, declare the value unserializable\n    }\n    return '[Unserializable]';\n}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n    var object = value;\n    if (object && typeof object.toJSON === 'function') {\n        try {\n            return object.toJSON();\n        }\n        catch (_a) {\n            // If toJSON fails, we continue by trying to serialize the value manually\n        }\n    }\n    return value;\n}\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount, changeType, source) {\n    display.warn(\"The data provided has been \".concat(changeType, \" as it is over the limit of \").concat(maxCharacterCount, \" characters:\"), source);\n}\n//# sourceMappingURL=sanitize.js.map","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\nimport { startsWith } from '../utils/polyfills';\nvar UNKNOWN_FUNCTION = '?';\nexport function computeStackTrace(ex) {\n    var stack = [];\n    var stackProperty = tryToGetString(ex, 'stack');\n    var exString = String(ex);\n    if (stackProperty && startsWith(stackProperty, exString)) {\n        stackProperty = stackProperty.slice(exString.length);\n    }\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);\n            if (stackFrame) {\n                if (!stackFrame.func && stackFrame.line) {\n                    stackFrame.func = UNKNOWN_FUNCTION;\n                }\n                stack.push(stackFrame);\n            }\n        });\n    }\n    return {\n        message: tryToGetString(ex, 'message'),\n        name: tryToGetString(ex, 'name'),\n        stack: stack,\n    };\n}\nvar fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nvar filePosition = '(?::(\\\\d+))';\nvar CHROME_LINE_RE = new RegExp(\"^\\\\s*at (.*?) ?\\\\(\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"?\\\\)?\\\\s*$\"), 'i');\nvar CHROME_EVAL_RE = new RegExp(\"\\\\((\\\\S*)\".concat(filePosition).concat(filePosition, \"\\\\)\"));\nfunction parseChromeLine(line) {\n    var parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    var submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = submatch[1]; // url\n        parts[3] = submatch[2]; // line\n        parts[4] = submatch[3]; // column\n    }\n    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nvar CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\"^\\\\s*at ?\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"??\\\\s*$\"), 'i');\nfunction parseChromeAnonymousLine(line) {\n    var parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[3] ? +parts[3] : undefined,\n        func: UNKNOWN_FUNCTION,\n        line: parts[2] ? +parts[2] : undefined,\n        url: parts[1],\n    };\n}\nvar WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    var parts = WINJS_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: +parts[3],\n        url: parts[2],\n    };\n}\nvar GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    var parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    var submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    var value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\nexport function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {\n    var stack = [{ url: url, column: column, line: line }];\n    var _a = tryToParseMessage(messageObj), name = _a.name, message = _a.message;\n    return {\n        name: name,\n        message: message,\n        stack: stack,\n    };\n}\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/;\nfunction tryToParseMessage(messageObj) {\n    var _a;\n    var name;\n    var message;\n    if ({}.toString.call(messageObj) === '[object String]') {\n        ;\n        _a = ERROR_TYPES_RE.exec(messageObj), name = _a[1], message = _a[2];\n    }\n    return { name: name, message: message };\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { callMonitored } from '../monitor';\nimport { noop } from '../utils/functionUtils';\nimport { computeStackTrace } from './computeStackTrace';\n/**\n * Creates a stacktrace without SDK internal frames.\n * Constraints:\n * - Has to be called at the utmost position of the call stack.\n * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack() {\n    /**\n     * Skip the two internal frames:\n     * - SDK API (console.error, ...)\n     * - this function\n     * in order to keep only the user calls\n     */\n    var internalFramesToSkip = 2;\n    var error = new Error();\n    var formattedStack;\n    // IE needs to throw the error to fill in the stack trace\n    if (!error.stack) {\n        try {\n            throw error;\n        }\n        catch (e) {\n            noop();\n        }\n    }\n    callMonitored(function () {\n        var stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\nexport function toStackTraceString(stack) {\n    var result = formatErrorMessage(stack);\n    stack.stack.forEach(function (frame) {\n        var func = frame.func === '?' ? '<anonymous>' : frame.func;\n        var args = frame.args && frame.args.length > 0 ? \"(\".concat(frame.args.join(', '), \")\") : '';\n        var line = frame.line ? \":\".concat(frame.line) : '';\n        var column = frame.line && frame.column ? \":\".concat(frame.column) : '';\n        result += \"\\n  at \".concat(func).concat(args, \" @ \").concat(frame.url).concat(line).concat(column);\n    });\n    return result;\n}\nexport function formatErrorMessage(stack) {\n    return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n//# sourceMappingURL=handlingStack.js.map","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';\nimport { monitor } from './monitor';\nimport { getGlobalObject } from './getGlobalObject';\nexport function setTimeout(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay);\n}\nexport function clearTimeout(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);\n}\nexport function setInterval(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId);\n}\n//# sourceMappingURL=timer.js.map","import { arrayFrom } from './polyfills';\nexport function removeDuplicates(array) {\n    var set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    return arrayFrom(set);\n}\nexport function removeItem(array, item) {\n    var index = array.indexOf(item);\n    if (index >= 0) {\n        array.splice(index, 1);\n    }\n}\n//# sourceMappingURL=arrayUtils.js.map","export function isIE() {\n    return detectBrowserCached() === 0 /* Browser.IE */;\n}\nexport function isChromium() {\n    return detectBrowserCached() === 1 /* Browser.CHROMIUM */;\n}\nexport function isSafari() {\n    return detectBrowserCached() === 2 /* Browser.SAFARI */;\n}\nvar browserCache;\nfunction detectBrowserCached() {\n    return browserCache !== null && browserCache !== void 0 ? browserCache : (browserCache = detectBrowser());\n}\n// Exported only for tests\nexport function detectBrowser(browserWindow) {\n    var _a;\n    if (browserWindow === void 0) { browserWindow = window; }\n    var userAgent = browserWindow.navigator.userAgent;\n    if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) {\n        return 1 /* Browser.CHROMIUM */;\n    }\n    if (\n    // navigator.vendor is deprecated, but it is the most resilient way we found to detect\n    // \"Apple maintained browsers\" (AKA Safari). If one day it gets removed, we still have the\n    // useragent test as a semi-working fallback.\n    ((_a = browserWindow.navigator.vendor) === null || _a === void 0 ? void 0 : _a.indexOf('Apple')) === 0 ||\n        (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))) {\n        return 2 /* Browser.SAFARI */;\n    }\n    if (browserWindow.document.documentMode) {\n        return 0 /* Browser.IE */;\n    }\n    return 3 /* Browser.OTHER */;\n}\n//# sourceMappingURL=browserDetection.js.map","export var ONE_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n    // Accurate bytes count computations can degrade performances when there is a lot of events to process\n    if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n        return candidate.length;\n    }\n    if (window.TextEncoder !== undefined) {\n        return new TextEncoder().encode(candidate).length;\n    }\n    return new Blob([candidate]).size;\n}\nexport function concatBuffers(buffers) {\n    var length = buffers.reduce(function (total, buffer) { return total + buffer.length; }, 0);\n    var result = new Uint8Array(length);\n    var offset = 0;\n    for (var _i = 0, buffers_1 = buffers; _i < buffers_1.length; _i++) {\n        var buffer = buffers_1[_i];\n        result.set(buffer, offset);\n        offset += buffer.length;\n    }\n    return result;\n}\n//# sourceMappingURL=byteUtils.js.map","import { setTimeout, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n    var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    var inWaitPeriod = false;\n    var pendingExecutionWithParameters;\n    var pendingTimeoutId;\n    return {\n        throttled: function () {\n            var parameters = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                parameters[_i] = arguments[_i];\n            }\n            if (inWaitPeriod) {\n                pendingExecutionWithParameters = parameters;\n                return;\n            }\n            if (needLeadingExecution) {\n                fn.apply(void 0, parameters);\n            }\n            else {\n                pendingExecutionWithParameters = parameters;\n            }\n            inWaitPeriod = true;\n            pendingTimeoutId = setTimeout(function () {\n                if (needTrailingExecution && pendingExecutionWithParameters) {\n                    fn.apply(void 0, pendingExecutionWithParameters);\n                }\n                inWaitPeriod = false;\n                pendingExecutionWithParameters = undefined;\n            }, wait);\n        },\n        cancel: function () {\n            clearTimeout(pendingTimeoutId);\n            inWaitPeriod = false;\n            pendingExecutionWithParameters = undefined;\n        },\n    };\n}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() { }\n//# sourceMappingURL=functionUtils.js.map","/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n    return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n    return +num.toFixed(decimals);\n}\nexport function isPercentage(value) {\n    return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n    return typeof value === 'number';\n}\n//# sourceMappingURL=numberUtils.js.map","import { assign } from './polyfills';\nexport function shallowClone(object) {\n    return assign({}, object);\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some(function (key) { return object[key] === value; });\n}\nexport function isEmptyObject(object) {\n    return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n    var newObject = {};\n    for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {\n        var key = _a[_i];\n        newObject[key] = fn(object[key]);\n    }\n    return newObject;\n}\n//# sourceMappingURL=objectUtils.js.map","export function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\n}\nexport function arrayFrom(arrayLike) {\n    if (Array.from) {\n        return Array.from(arrayLike);\n    }\n    var array = [];\n    if (arrayLike instanceof Set) {\n        arrayLike.forEach(function (item) { return array.push(item); });\n    }\n    else {\n        for (var i = 0; i < arrayLike.length; i++) {\n            array.push(arrayLike[i]);\n        }\n    }\n    return array;\n}\nexport function find(array, predicate) {\n    for (var i = 0; i < array.length; i += 1) {\n        var item = array[i];\n        if (predicate(item, i)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function findLast(array, predicate) {\n    for (var i = array.length - 1; i >= 0; i -= 1) {\n        var item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\nexport function objectValues(object) {\n    return Object.keys(object).map(function (key) { return object[key]; });\n}\nexport function objectEntries(object) {\n    return Object.keys(object).map(function (key) { return [key, object[key]]; });\n}\nexport function startsWith(candidate, search) {\n    return candidate.slice(0, search.length) === search;\n}\nexport function endsWith(candidate, search) {\n    return candidate.slice(-search.length) === search;\n}\nexport function assign(target) {\n    var toAssign = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        toAssign[_i - 1] = arguments[_i];\n    }\n    toAssign.forEach(function (source) {\n        for (var key in source) {\n            if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n            }\n        }\n    });\n    return target;\n}\n//# sourceMappingURL=polyfills.js.map","export function isServerError(status) {\n    return status >= 500;\n}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (e) {\n        // clone can throw if the response has already been used by another instrumentation or is disturbed\n        return;\n    }\n}\n//# sourceMappingURL=responseUtils.js.map","/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder) {\n    return placeholder\n        ? // eslint-disable-next-line  no-bitwise\n            (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)\n        : \"\".concat(1e7, \"-\").concat(1e3, \"-\").concat(4e3, \"-\").concat(8e3, \"-\").concat(1e11).replace(/[018]/g, generateUUID);\n}\nvar COMMA_SEPARATED_KEY_VALUE = /([\\w-]+)\\s*=\\s*([^;]+)/g;\nexport function findCommaSeparatedValue(rawString, name) {\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        var match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            if (match[1] === name) {\n                return match[2];\n            }\n        }\n        else {\n            break;\n        }\n    }\n}\nexport function findCommaSeparatedValues(rawString) {\n    var result = new Map();\n    COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        var match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);\n        if (match) {\n            result.set(match[1], match[2]);\n        }\n        else {\n            break;\n        }\n    }\n    return result;\n}\nexport function safeTruncate(candidate, length, suffix) {\n    if (suffix === void 0) { suffix = ''; }\n    var lastChar = candidate.charCodeAt(length - 1);\n    var isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    var correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength) {\n        return candidate;\n    }\n    return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\n//# sourceMappingURL=stringUtils.js.map","import { isNumber, round } from './numberUtils';\nexport var ONE_SECOND = 1000;\nexport var ONE_MINUTE = 60 * ONE_SECOND;\nexport var ONE_HOUR = 60 * ONE_MINUTE;\nexport var ONE_DAY = 24 * ONE_HOUR;\nexport var ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nexport function timeStampToClocks(timeStamp) {\n    return { relative: getRelativeTime(timeStamp), timeStamp: timeStamp };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var correctedOrigin = (dateNow() - performance.now());\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        return Math.round(addDuration(correctedOrigin, relativeTime));\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now()));\n}\nexport function toServerDuration(duration) {\n    if (!isNumber(duration)) {\n        return duration;\n    }\n    return round(duration * 1e6, 0);\n}\nexport function dateNow() {\n    // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n    // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n    // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n    // case ourselves.\n    // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n    return new Date().getTime();\n}\nexport function timeStampNow() {\n    return dateNow();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { relative: relativeNow(), timeStamp: timeStampNow() };\n}\nexport function clocksOrigin() {\n    return { relative: 0, timeStamp: getNavigationStart() };\n}\nexport function elapsed(start, end) {\n    return (end - start);\n}\nexport function addDuration(a, b) {\n    return a + b;\n}\n/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\nexport function getRelativeTime(timestamp) {\n    return (timestamp - getNavigationStart());\n}\nexport function getTimeStamp(relativeTime) {\n    return Math.round(addDuration(getNavigationStart(), relativeTime));\n}\nexport function looksLikeRelativeTime(time) {\n    return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nvar navigationStart;\nfunction getNavigationStart() {\n    if (navigationStart === undefined) {\n        navigationStart = performance.timing.navigationStart;\n    }\n    return navigationStart;\n}\nexport function resetNavigationStart() {\n    navigationStart = undefined;\n}\n//# sourceMappingURL=timeUtils.js.map","/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value) {\n    if (value === null) {\n        return 'null';\n    }\n    if (Array.isArray(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n//# sourceMappingURL=typeUtils.js.map","import { jsonStringify } from '../serialisation/jsonStringify';\nexport function normalizeUrl(url) {\n    return buildUrl(url, location.href).href;\n}\nexport function isValidUrl(url) {\n    try {\n        return !!buildUrl(url);\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getPathName(url) {\n    var pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function buildUrl(url, base) {\n    var supportedURL = getSupportedUrl();\n    if (supportedURL) {\n        try {\n            return base !== undefined ? new supportedURL(url, base) : new supportedURL(url);\n        }\n        catch (error) {\n            throw new Error(\"Failed to construct URL: \".concat(String(error), \" \").concat(jsonStringify({ url: url, base: base })));\n        }\n    }\n    if (base === undefined && !/:/.test(url)) {\n        throw new Error(\"Invalid URL: '\".concat(url, \"'\"));\n    }\n    var doc = document;\n    var anchorElement = doc.createElement('a');\n    if (base !== undefined) {\n        doc = document.implementation.createHTMLDocument('');\n        var baseElement = doc.createElement('base');\n        baseElement.href = base;\n        doc.head.appendChild(baseElement);\n        doc.body.appendChild(anchorElement);\n    }\n    anchorElement.href = url;\n    return anchorElement;\n}\nvar originalURL = URL;\nvar isURLSupported;\nfunction getSupportedUrl() {\n    if (isURLSupported === undefined) {\n        try {\n            var url = new originalURL('http://test/path');\n            isURLSupported = url.href === 'http://test/path';\n        }\n        catch (_a) {\n            isURLSupported = false;\n        }\n    }\n    return isURLSupported ? originalURL : undefined;\n}\n//# sourceMappingURL=urlPolyfill.js.map","import { setInterval, clearInterval } from './timer';\nimport { removeItem } from './utils/arrayUtils';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of values spans. This whole class assumes that values are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ValueHistory = /** @class */ (function () {\n    function ValueHistory(expireDelay, maxEntries) {\n        var _this = this;\n        this.expireDelay = expireDelay;\n        this.maxEntries = maxEntries;\n        this.entries = [];\n        this.clearOldValuesInterval = setInterval(function () { return _this.clearOldValues(); }, CLEAR_OLD_VALUES_INTERVAL);\n    }\n    /**\n     * Add a value to the history associated with a start time. Returns a reference to this newly\n     * added entry that can be removed or closed.\n     */\n    ValueHistory.prototype.add = function (value, startTime) {\n        var _this = this;\n        var entry = {\n            value: value,\n            startTime: startTime,\n            endTime: END_OF_TIMES,\n            remove: function () {\n                removeItem(_this.entries, entry);\n            },\n            close: function (endTime) {\n                entry.endTime = endTime;\n            },\n        };\n        if (this.maxEntries && this.entries.length >= this.maxEntries) {\n            this.entries.pop();\n        }\n        this.entries.unshift(entry);\n        return entry;\n    };\n    /**\n     * Return the latest value that was active during `startTime`, or the currently active value\n     * if no `startTime` is provided. This method assumes that entries are not overlapping.\n     *\n     * If `option.returnInactive` is true, returns the value at `startTime` (active or not).\n     */\n    ValueHistory.prototype.find = function (startTime, options) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        if (options === void 0) { options = { returnInactive: false }; }\n        for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {\n            var entry = _a[_i];\n            if (entry.startTime <= startTime) {\n                if (options.returnInactive || startTime <= entry.endTime) {\n                    return entry.value;\n                }\n                break;\n            }\n        }\n    };\n    /**\n     * Helper function to close the currently active value, if any. This method assumes that entries\n     * are not overlapping.\n     */\n    ValueHistory.prototype.closeActive = function (endTime) {\n        var latestEntry = this.entries[0];\n        if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n            latestEntry.close(endTime);\n        }\n    };\n    /**\n     * Return all values with an active period overlapping with the duration,\n     * or all values that were active during `startTime` if no duration is provided,\n     * or all currently active values if no `startTime` is provided.\n     */\n    ValueHistory.prototype.findAll = function (startTime, duration) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        if (duration === void 0) { duration = 0; }\n        var endTime = addDuration(startTime, duration);\n        return this.entries\n            .filter(function (entry) { return entry.startTime <= endTime && startTime <= entry.endTime; })\n            .map(function (entry) { return entry.value; });\n    };\n    /**\n     * Remove all entries from this collection.\n     */\n    ValueHistory.prototype.reset = function () {\n        this.entries = [];\n    };\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    ValueHistory.prototype.stop = function () {\n        clearInterval(this.clearOldValuesInterval);\n    };\n    ValueHistory.prototype.clearOldValues = function () {\n        var oldTimeThreshold = relativeNow() - this.expireDelay;\n        while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n            this.entries.pop();\n        }\n    };\n    return ValueHistory;\n}());\nexport { ValueHistory };\n//# sourceMappingURL=valueHistory.js.map","import { endsWith, includes } from '../tools/utils/polyfills';\nimport { getGlobalObject } from '../tools/getGlobalObject';\nexport function getEventBridge() {\n    var eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getCapabilities: function () {\n            var _a;\n            return JSON.parse(((_a = eventBridgeGlobal.getCapabilities) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal)) || '[]');\n        },\n        getPrivacyLevel: function () {\n            var _a;\n            return (_a = eventBridgeGlobal.getPrivacyLevel) === null || _a === void 0 ? void 0 : _a.call(eventBridgeGlobal);\n        },\n        getAllowedWebViewHosts: function () {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send: function (eventType, event, viewId) {\n            var view = viewId ? { id: viewId } : undefined;\n            eventBridgeGlobal.send(JSON.stringify({ eventType: eventType, event: event, view: view }));\n        },\n    };\n}\nexport function bridgeSupports(capability) {\n    var bridge = getEventBridge();\n    return !!bridge && includes(bridge.getCapabilities(), capability);\n}\nexport function canUseEventBridge(currentHost) {\n    var _a;\n    if (currentHost === void 0) { currentHost = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname; }\n    var bridge = getEventBridge();\n    return (!!bridge &&\n        bridge\n            .getAllowedWebViewHosts()\n            .some(function (allowedHost) { return currentHost === allowedHost || endsWith(currentHost, \".\".concat(allowedHost)); }));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { setTimeout } from '../tools/timer';\nimport { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { isServerError } from '../tools/utils/responseUtils';\nimport { ErrorSource } from '../domain/error/error.types';\nexport var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport var MAX_ONGOING_REQUESTS = 32;\nexport var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;\nexport var MAX_BACKOFF_TIME = ONE_MINUTE;\nexport var INITIAL_BACKOFF_TIME = ONE_SECOND;\nexport function sendWithRetryStrategy(payload, state, sendStrategy, trackType, reportError) {\n    if (state.transportStatus === 0 /* TransportStatus.UP */ &&\n        state.queuedPayloads.size() === 0 &&\n        state.bandwidthMonitor.canHandle(payload)) {\n        send(payload, state, sendStrategy, {\n            onSuccess: function () { return retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, trackType, reportError); },\n            onFailure: function () {\n                state.queuedPayloads.enqueue(payload);\n                scheduleRetry(state, sendStrategy, trackType, reportError);\n            },\n        });\n    }\n    else {\n        state.queuedPayloads.enqueue(payload);\n    }\n}\nfunction scheduleRetry(state, sendStrategy, trackType, reportError) {\n    if (state.transportStatus !== 2 /* TransportStatus.DOWN */) {\n        return;\n    }\n    setTimeout(function () {\n        var payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, {\n            onSuccess: function () {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, trackType, reportError);\n            },\n            onFailure: function () {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, trackType, reportError);\n            },\n        });\n    }, state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, _a) {\n    var onSuccess = _a.onSuccess, onFailure = _a.onFailure;\n    state.bandwidthMonitor.add(payload);\n    sendStrategy(payload, function (response) {\n        state.bandwidthMonitor.remove(payload);\n        if (!shouldRetryRequest(response)) {\n            state.transportStatus = 0 /* TransportStatus.UP */;\n            onSuccess();\n        }\n        else {\n            // do not consider transport down if another ongoing request could succeed\n            state.transportStatus =\n                state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 /* TransportStatus.FAILURE_DETECTED */ : 2 /* TransportStatus.DOWN */;\n            payload.retry = {\n                count: payload.retry ? payload.retry.count + 1 : 1,\n                lastFailureStatus: response.status,\n            };\n            onFailure();\n        }\n    });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError) {\n    if (reason === 0 /* RetryReason.AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n        reportError({\n            message: \"Reached max \".concat(trackType, \" events size queued for upload: \").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, \"MiB\"),\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n        });\n        state.queueFullReported = true;\n    }\n    var previousQueue = state.queuedPayloads;\n    state.queuedPayloads = newPayloadQueue();\n    while (previousQueue.size() > 0) {\n        sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, trackType, reportError);\n    }\n}\nfunction shouldRetryRequest(response) {\n    return (response.type !== 'opaque' &&\n        ((response.status === 0 && !navigator.onLine) ||\n            response.status === 408 ||\n            response.status === 429 ||\n            isServerError(response.status)));\n}\nexport function newRetryState() {\n    return {\n        transportStatus: 0 /* TransportStatus.UP */,\n        currentBackoffTime: INITIAL_BACKOFF_TIME,\n        bandwidthMonitor: newBandwidthMonitor(),\n        queuedPayloads: newPayloadQueue(),\n        queueFullReported: false,\n    };\n}\nfunction newPayloadQueue() {\n    var queue = [];\n    return {\n        bytesCount: 0,\n        enqueue: function (payload) {\n            if (this.isFull()) {\n                return;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\n        },\n        first: function () {\n            return queue[0];\n        },\n        dequeue: function () {\n            var payload = queue.shift();\n            if (payload) {\n                this.bytesCount -= payload.bytesCount;\n            }\n            return payload;\n        },\n        size: function () {\n            return queue.length;\n        },\n        isFull: function () {\n            return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n        },\n    };\n}\nfunction newBandwidthMonitor() {\n    return {\n        ongoingRequestCount: 0,\n        ongoingByteCount: 0,\n        canHandle: function (payload) {\n            return (this.ongoingRequestCount === 0 ||\n                (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n                    this.ongoingRequestCount < MAX_ONGOING_REQUESTS));\n        },\n        add: function (payload) {\n            this.ongoingRequestCount += 1;\n            this.ongoingByteCount += payload.bytesCount;\n        },\n        remove: function (payload) {\n            this.ongoingRequestCount -= 1;\n            this.ongoingByteCount -= payload.bytesCount;\n        },\n    };\n}\n//# sourceMappingURL=sendWithRetryStrategy.js.map","import { addTelemetryError } from '../domain/telemetry';\nimport { monitor } from '../tools/monitor';\nimport { addEventListener } from '../browser/addEventListener';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(configuration, endpointBuilder, bytesLimit, reportError) {\n    var retryState = newRetryState();\n    var sendStrategyForRetry = function (payload, onResponse) {\n        return fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse);\n    };\n    return {\n        send: function (payload) {\n            sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.trackType, reportError);\n        },\n        /**\n         * Since fetch keepalive behaves like regular fetch on Firefox,\n         * keep using sendBeaconStrategy on exit\n         */\n        sendOnExit: function (payload) {\n            sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload);\n        },\n    };\n}\nfunction sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload) {\n    var canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            var beaconUrl = endpointBuilder.build('beacon', payload);\n            var isQueued = navigator.sendBeacon(beaconUrl, payload.data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    var xhrUrl = endpointBuilder.build('xhr', payload);\n    sendXHR(configuration, xhrUrl, payload.data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse) {\n    var canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        var fetchUrl = endpointBuilder.build('fetch', payload);\n        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(monitor(function (response) { return onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type }); }), monitor(function () {\n            var xhrUrl = endpointBuilder.build('xhr', payload);\n            // failed to queue the request\n            sendXHR(configuration, xhrUrl, payload.data, onResponse);\n        }));\n    }\n    else {\n        var xhrUrl = endpointBuilder.build('xhr', payload);\n        sendXHR(configuration, xhrUrl, payload.data, onResponse);\n    }\n}\nfunction isKeepAliveSupported() {\n    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n    try {\n        return window.Request && 'keepalive' in new Request('http://a');\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function sendXHR(configuration, url, data, onResponse) {\n    var request = new XMLHttpRequest();\n    request.open('POST', url, true);\n    if (data instanceof Blob) {\n        // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header\n        // automatically, so the intake request ends up being rejected with an HTTP status 415\n        // Defining the header manually fixes this issue.\n        request.setRequestHeader('Content-Type', data.type);\n    }\n    addEventListener(configuration, request, 'loadend', function () {\n        onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: request.status });\n    }, {\n        // prevent multiple onResponse callbacks\n        // if the xhr instance is reused by a third party\n        once: true,\n    });\n    request.send(data);\n}\n//# sourceMappingURL=httpRequest.js.map","import { DOCS_ORIGIN, display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageExitObservable';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nvar Batch = /** @class */ (function () {\n    function Batch(encoder, request, flushController, messageBytesLimit) {\n        var _this = this;\n        this.encoder = encoder;\n        this.request = request;\n        this.flushController = flushController;\n        this.messageBytesLimit = messageBytesLimit;\n        this.upsertBuffer = {};\n        this.flushSubscription = this.flushController.flushObservable.subscribe(function (event) { return _this.flush(event); });\n    }\n    Batch.prototype.add = function (message) {\n        this.addOrUpdate(message);\n    };\n    Batch.prototype.upsert = function (message, key) {\n        this.addOrUpdate(message, key);\n    };\n    Batch.prototype.stop = function () {\n        this.flushSubscription.unsubscribe();\n    };\n    Batch.prototype.flush = function (event) {\n        var upsertMessages = objectValues(this.upsertBuffer).join('\\n');\n        this.upsertBuffer = {};\n        var isPageExit = isPageExitReason(event.reason);\n        var send = isPageExit ? this.request.sendOnExit : this.request.send;\n        if (isPageExit &&\n            // Note: checking that the encoder is async is not strictly needed, but it's an optimization:\n            // if the encoder is async we need to send two requests in some cases (one for encoded data\n            // and the other for non-encoded data). But if it's not async, we don't have to worry about\n            // it and always send a single request.\n            this.encoder.isAsync) {\n            var encoderResult = this.encoder.finishSync();\n            // Send encoded messages\n            if (encoderResult.outputBytesCount) {\n                send(formatPayloadFromEncoder(encoderResult));\n            }\n            // Send messages that are not yet encoded at this point\n            var pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\\n');\n            if (pendingMessages) {\n                send({\n                    data: pendingMessages,\n                    bytesCount: computeBytesCount(pendingMessages),\n                });\n            }\n        }\n        else {\n            if (upsertMessages) {\n                this.encoder.write(this.encoder.isEmpty ? upsertMessages : \"\\n\".concat(upsertMessages));\n            }\n            this.encoder.finish(function (encoderResult) {\n                send(formatPayloadFromEncoder(encoderResult));\n            });\n        }\n    };\n    Batch.prototype.addOrUpdate = function (message, key) {\n        var serializedMessage = jsonStringify(message);\n        var estimatedMessageBytesCount = this.encoder.estimateEncodedBytesCount(serializedMessage);\n        if (estimatedMessageBytesCount >= this.messageBytesLimit) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.messageBytesLimit, \"KB. More details: \").concat(DOCS_ORIGIN, \"/real_user_monitoring/browser/troubleshooting/#technical-limitations\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        this.push(serializedMessage, estimatedMessageBytesCount, key);\n    };\n    Batch.prototype.push = function (serializedMessage, estimatedMessageBytesCount, key) {\n        var _this = this;\n        this.flushController.notifyBeforeAddMessage(estimatedMessageBytesCount);\n        if (key !== undefined) {\n            this.upsertBuffer[key] = serializedMessage;\n            this.flushController.notifyAfterAddMessage();\n        }\n        else {\n            this.encoder.write(this.encoder.isEmpty ? serializedMessage : \"\\n\".concat(serializedMessage), function (realMessageBytesCount) {\n                _this.flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount);\n            });\n        }\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesCount = this.encoder.estimateEncodedBytesCount(removedMessage);\n        this.flushController.notifyAfterRemoveMessage(messageBytesCount);\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    return Batch;\n}());\nexport { Batch };\nfunction formatPayloadFromEncoder(encoderResult) {\n    var data;\n    if (typeof encoderResult.output === 'string') {\n        data = encoderResult.output;\n    }\n    else {\n        data = new Blob([encoderResult.output], {\n            // This will set the 'Content-Type: text/plain' header. Reasoning:\n            // * The intake rejects the request if there is no content type.\n            // * The browser will issue CORS preflight requests if we set it to 'application/json', which\n            // could induce higher intake load (and maybe has other impacts).\n            // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by\n            // new lines.\n            type: 'text/plain',\n        });\n    }\n    return {\n        data: data,\n        bytesCount: encoderResult.outputBytesCount,\n        encoding: encoderResult.encoding,\n    };\n}\n//# sourceMappingURL=batch.js.map","import { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController(_a) {\n    var messagesLimit = _a.messagesLimit, bytesLimit = _a.bytesLimit, durationLimit = _a.durationLimit, pageExitObservable = _a.pageExitObservable, sessionExpireObservable = _a.sessionExpireObservable;\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) { return flush(event.reason); });\n    var sessionExpireSubscription = sessionExpireObservable.subscribe(function () { return flush('session_expire'); });\n    var flushObservable = new Observable(function () { return function () {\n        pageExitSubscription.unsubscribe();\n        sessionExpireSubscription.unsubscribe();\n    }; });\n    var currentBytesCount = 0;\n    var currentMessagesCount = 0;\n    function flush(flushReason) {\n        if (currentMessagesCount === 0) {\n            return;\n        }\n        var messagesCount = currentMessagesCount;\n        var bytesCount = currentBytesCount;\n        currentMessagesCount = 0;\n        currentBytesCount = 0;\n        cancelDurationLimitTimeout();\n        flushObservable.notify({\n            reason: flushReason,\n            messagesCount: messagesCount,\n            bytesCount: bytesCount,\n        });\n    }\n    var durationLimitTimeoutId;\n    function scheduleDurationLimitTimeout() {\n        if (durationLimitTimeoutId === undefined) {\n            durationLimitTimeoutId = setTimeout(function () {\n                flush('duration_limit');\n            }, durationLimit);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable: flushObservable,\n        get messagesCount() {\n            return currentMessagesCount;\n        },\n        /**\n         * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right before adding the message, so no flush\n         * event can happen after `notifyBeforeAddMessage` and before adding the message.\n         *\n         * @param estimatedMessageBytesCount: an estimation of the message bytes count once it is\n         * actually added.\n         */\n        notifyBeforeAddMessage: function (estimatedMessageBytesCount) {\n            if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n            // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n            // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n            // to notify when a flush is needed (for example on page exit).\n            currentMessagesCount += 1;\n            currentBytesCount += estimatedMessageBytesCount;\n            scheduleDurationLimitTimeout();\n        },\n        /**\n         * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n         *\n         * This function can be called asynchronously after the message was added, but in this case it\n         * should not be called if a flush event occurred in between.\n         *\n         * @param messageBytesCountDiff: the difference between the estimated message bytes count and\n         * its actual bytes count once added to the pool.\n         */\n        notifyAfterAddMessage: function (messageBytesCountDiff) {\n            if (messageBytesCountDiff === void 0) { messageBytesCountDiff = 0; }\n            currentBytesCount += messageBytesCountDiff;\n            if (currentMessagesCount >= messagesLimit) {\n                flush('messages_limit');\n            }\n            else if (currentBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n        },\n        /**\n         * Notifies that a message was removed from a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right after removing the message, so no flush\n         * event can happen after removing the message and before `notifyAfterRemoveMessage`.\n         *\n         * @param messageBytesCount: the message bytes count that was added to the pool. Should\n         * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and\n         * `notifyAfterAddMessage`.\n         */\n        notifyAfterRemoveMessage: function (messageBytesCount) {\n            currentBytesCount -= messageBytesCount;\n            currentMessagesCount -= 1;\n            if (currentMessagesCount === 0) {\n                cancelDurationLimitTimeout();\n            }\n        },\n    };\n}\n//# sourceMappingURL=flushController.js.map","import { Batch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nimport { createFlushController } from './flushController';\nexport function startBatchWithReplica(configuration, primary, replica, reportError, pageExitObservable, sessionExpireObservable) {\n    var primaryBatch = createBatch(configuration, primary);\n    var replicaBatch = replica && createBatch(configuration, replica);\n    function createBatch(configuration, _a) {\n        var endpoint = _a.endpoint, encoder = _a.encoder;\n        return new Batch(encoder, createHttpRequest(configuration, endpoint, configuration.batchBytesLimit, reportError), createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageExitObservable: pageExitObservable,\n            sessionExpireObservable: sessionExpireObservable,\n        }), configuration.messageBytesLimit);\n    }\n    return {\n        flushObservable: primaryBatch.flushController.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message);\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key);\n            }\n        },\n        stop: function () {\n            primaryBatch.stop();\n            replicaBatch === null || replicaBatch === void 0 ? void 0 : replicaBatch.stop();\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map"],"names":["displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","error","concat","makePublicApi","stub","publicApi","version","onReady","callback","Object","defineProperty","get","enumerable","defineGlobal","global","name","api","existingGlobalVariable","q","warn","forEach","fn","DOM_EVENT","addEventListener","configuration","eventTarget","eventName","listener","options","addEventListeners","eventNames","_a","_b","once","capture","passive","listenerWithMonitor","event","isTrusted","__ddIsTrusted","allowUntrustedEvents","stop","add","remove","call","initCookieParsed","getCurrentSiteCache","setCookie","value","expireDelay","date","Date","setTime","getTime","expires","toUTCString","sameSite","crossSite","domain","secure","partitioned","document","cookie","getCookie","getInitCookie","deleteCookie","areCookiesAuthorized","undefined","testCookieName","testCookieValue","isCookieCorrectlySet","getCurrentSite","domainLevels","window","location","hostname","split","candidateDomain","pop","length","fetchObservable","initFetchObservable","observable","fetch","parameters","onPostCall","handlingStack","input","init","methodFromParams","method","Request","String","toUpperCase","url","startClocks","context","state","notify","responsePromise","startContext","reportFetch","response","Error","status","isAborted","DOMException","code","ABORT_ERR","responseType","type","then","afterSend","beforeSend","computeHandlingStack","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","createPageExitObservable","stopListeners","VISIBILITY_CHANGE","FREEZE","visibilityState","reason","stopBeforeUnloadListener","BEFORE_UNLOAD","isPageExitReason","xhrObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","prototype","openXhr","stopInstrumentingSend","xhr","target","hasBeenReported","stopInstrumentingOnReadyStateChange","readyState","DONE","onEnd","unsubscribeLoadEndListener","completeContext","duration","timeStamp","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","set","createEndpointBuilder","trackType","configurationTags","buildUrlWithParameters","path","proxy","normalizedProxyUrl_1","encodeURIComponent","host","site","internalAnalyticsSubdomain","usePciIntake","domainParts","extension","join","buildEndpointHost","createEndpointUrlWithParametersBuilder","build","payload","clientToken","retry","encoding","tags","push","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","TAG_SIZE_LIMIT","FORBIDDEN_CHARACTERS","buildTag","key","rawValue","valueSizeLimit","test","display","sanitizedValue","replace","computeTransportConfiguration","env","service","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeUrlPrefixes","map","builder","computeIntakeUrlPrefixes","replicaConfiguration","replica","replicaEndpointBuilders","apply","applicationId","computeReplicaConfiguration","isIntakeUrl","some","intakeEndpoint","indexOf","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","TraceContextInjection","ALL","SAMPLED","checkIfString","tag","tagName","validateAndBuildConfiguration","_c","_d","_e","sessionSampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","telemetryUsageSampleRate","trackingConsent","catchUserErrors","sessionStoreStrategyType","GRANTED","storeContextsAcrossPages","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","serializeConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","telemetry_usage_sample_rate","use_before_send","use_cross_site_session_cookie","useCrossSiteSessionCookie","use_partitioned_cross_site_session_cookie","usePartitionedCrossSiteSessionCookie","use_secure_session_cookie","useSecureSessionCookie","use_proxy","silent_multiple_init","track_session_across_subdomains","trackSessionAcrossSubdomains","allow_fallback_to_local_storage","allowFallbackToLocalStorage","store_contexts_across_pages","allow_untrusted_events","tracking_consent","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_US1_FED","PCI_INTAKE_HOST_US1","getConnectivity","navigator","onLine","interfaces","connection","effective_type","effectiveType","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","_i","arguments","console","stack","fingerprint","causes","message","param","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","createContextManager","customerDataTracker","changeObservable","contextManager","getContext","setContext","newContext","updateCustomerData","clearContext","setContextProperty","property","removeContextProperty","resetCustomerData","CUSTOMER_DATA_BYTES_LIMIT","CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT","BYTES_COMPUTATION_THROTTLING_DELAY","createCustomerDataTrackerManager","compressionStatus","customerDataTrackers","Map","alreadyWarned","checkCustomerDataLimit","initialBytesCount","bytesCountLimit","bytesCount","tracker","getBytesCount","displayCustomerDataLimitReachedWarning","createDetachedTracker","createCustomerDataTracker","getOrCreateTracker","has","setCompressionStatus","newCompressionStatus","getCompressionStatus","clear","bytesCountCache","computeBytesCountThrottled","throttled","cancelComputeBytesCount","cancel","resetBytesCount","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","productKey","customerDataType","storageKey","buildStorageKey","getFromStorage","rawContext","localStorage","getItem","JSON","parse","STORAGE","subscribe","setItem","stringify","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","nonErrorPrefix","source","handling","isErrorInstance","computeMessage","hasUsableStack","flattenErrorCauses","tryToGetFingerprint","dd_fingerprint","getFileFromStackTraceString","exec","parentSource","currentError","cause","ErrorSource","AGENT","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","trackRuntimeError","errorObservable","handleRuntimeError","rawError","stopInstrumentingOnError","messageObj","line","column","errorObj","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","createEventRateLimiter","eventType","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","RawReportType","intervention","deprecation","cspViolation","initReportObservable","observables","SECURITY_POLICY_VIOLATION","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","originalReport","buildRawReportFromCspViolation","createCspViolationReportObservable","reportTypes","filter","ReportingObserver","handleReports","reports","_","report","body","id","buildRawReportFromReport","observer","types","buffered","observe","disconnect","createReportObservable","func","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","computeSessionState","trackingConsentState","renewObservable","expireObservable","sessionStore","sessionContextHistory","buildSessionContext","getSession","trackingType","isReplayForced","forcedReplay","closeActive","expandOrRenewSession","relative","isGranted","expire","CLICK","TOUCH_START","KEY_DOWN","SCROLL","trackActivity","expandSession","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","cb","RESUME","trackResume","restartSession","findSession","startTime","find","sessionStateUpdateObservable","updateSessionState","SESSION_STORE_KEY","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","EXPIRED","getExpiredSessionState","isExpired","isSessionInNotStartedState","session","isSessionStarted","isSessionInExpiredState","sessionState","created","Number","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","entry","matches","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","selectCookieStrategy","cookieOptions","buildCookieOptions","initCookieStrategy","cookieStore","isLockEnabled","persistSession","retrieveSession","retrieveSessionCookie","expireSession","expireSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","LOCAL_STORAGE_TEST_KEY","persistInLocalStorage","retrieveSessionFromLocalStorage","expireSessionFromLocalStorage","ongoingOperations","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","bufferedOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","persistWithLock","lock","currentLock","retrieveStore","next","currentStore","retryLater","processedSession","process","after","currentNumberOfRetries","nextOperations","shift","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","testKey","retrievedId","removeItem","e","selectLocalStorageStrategy","startSessionStore","sessionCache","watchSessionTimeoutId","synchronizeSession","startSession","synchronizedSession","isTracked","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","throttledExpandOrRenewSession","cancelExpandOrRenewSession","isSessionInCacheOutdated","previousState","newState","partialSessionState","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getSyntheticsTestId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsResultId","_DATADOG_SYNTHETICS_RESULT_ID","TelemetryType","log","usage","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","preStartTelemetryBuffer","onRawTelemetryEventCollected","startTelemetry","telemetryService","contextProvider","alreadySentEvents","Set","telemetryEnabled","telemetryEnabledPerType","runtimeEnvInfo","is_local_file","protocol","is_worker","self","rawEvent","stringifiedEvent","jsonStringify","size","event_1","_dd","format_version","telemetry","runtime_env","connectivity","experimental_features","toTelemetryEvent","sendToExtension","addTelemetryError","setContextProvider","provider","enabled","drainPreStartTelemetry","drain","isTelemetryReplicationAllowed","addTelemetryDebug","debug","computeStackTrace","kind","scrubCustomerFrames","formatError","addTelemetryConfiguration","addTelemetryUsage","frame","allowedFrameUrl","TrackingConsent","NOT_GRANTED","createTrackingConsentState","currentConsent","tryToInit","update","sanitizeUser","newUser","user","checkUser","isValid","AbstractLifeCycle","this","callbacks","data","eventCallbacks","_this","unsubscribe","other","BoundedBuffer","buffer","splice","arg","errorMsg","args","err","ConsoleApiName","info","globalConsole","originalConsoleMethods","keys","PREFIX","bind","DOCS_ORIGIN","createIdentityEncoder","output","outputBytesCount","isAsync","isEmpty","write","additionalEncodedBytesCount","finish","finishSync","result","rawBytesCount","pendingData","estimateEncodedBytesCount","ExperimentalFeature","enabledExperimentalFeatures","initFeatureFlags","enableExperimentalFeatures","Array","isArray","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","getGlobalObject","globalThis","configurable","globalObject","_dd_temp_","getZoneJsOriginalValue","original","browserWindow","Zone","__symbol__","instrumentMethod","targetPrototype","onPreCall","stopped","instrumentation","postCallCallback","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","stoppedInstrumentation","instrumentationWrapper","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","array","createCircularReferenceChecker","RegExp","flags","ignoreCase","multiline","sticky","unicode","merged_1","i","merged","hasOwnProperty","deepClone","combine","sources","sources_1","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","l","slice","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","monitored","__","descriptor","originalMethod","monitor","callMonitored","displayIfDebugEnabled","Observable","onFirstSubscribe","observers","f","onLastUnsubscribe","mergeObservables","globalObservable","subscriptions","subscription","readBytesFromStream","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer_1","Uint8Array","offset_1","chunk","bytesLimit","readMore","read","done","__ddBrowserSdkExtensionCallback","replacer","space","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","object","objectToJson","toJSON","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","JSON_PATH_ROOT_ELEMENT","KEY_DECORATION_LENGTH","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","sanitizedData","sanitizeProcessor","accumulatedCharacterCount","containerToProcess","separatorLength","targetData","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","toString","description","sanitizePrimitivesAndFunctions","sanitizedSource","Event","match","sanitizeObjects","sourceAsObject","currentPath","changeType","UNKNOWN_FUNCTION","ex","stackProperty","tryToGetString","exString","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","fileUrl","filePosition","candidate","computeStackTraceFromOnErrorMessage","ERROR_TYPES_RE","tryToParseMessage","createHandlingStack","formattedStack","toStackTraceString","formatErrorMessage","setTimeout","delay","clearTimeout","timeoutId","setInterval","clearInterval","removeDuplicates","item","index","isIE","detectBrowserCached","isChromium","isSafari","browserCache","userAgent","chrome","vendor","documentMode","detectBrowser","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","TextEncoder","encode","Blob","concatBuffers","buffers","reduce","total","offset","buffers_1","throttle","wait","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","noop","performDraw","threshold","Math","random","round","num","decimals","toFixed","isPercentage","isNumber","shallowClone","objectHasValue","isEmptyObject","mapValues","newObject","includes","search","arrayFrom","arrayLike","predicate","findLast","list","objectValues","objectEntries","startsWith","endsWith","assign","toAssign","isServerError","tryToClone","clone","generateUUID","placeholder","parseInt","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","findCommaSeparatedValues","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","navigationStart","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","getCorrectedTimeStamp","timeStampToClocks","getRelativeTime","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","addDuration","getTimeStamp","currentDrift","toServerDuration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","a","b","timestamp","looksLikeRelativeTime","time","timing","getType","normalizeUrl","buildUrl","href","isValidUrl","getPathName","pathname","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","URL","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","ValueHistory","maxEntries","entries","clearOldValuesInterval","clearOldValues","endTime","close","unshift","returnInactive","latestEntry","findAll","reset","oldTimeThreshold","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","getPrivacyLevel","getAllowedWebViewHosts","send","viewId","view","bridgeSupports","capability","bridge","canUseEventBridge","currentHost","allowedHost","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","sendStrategy","reportError","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","first","dequeue","currentBackoffTime","min","shouldRetryRequest","ongoingRequestCount","isFull","queueFullReported","previousQueue","newPayloadQueue","createHttpRequest","endpointBuilder","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","canUseKeepAlive","isKeepAliveSupported","fetchUrl","keepalive","mode","xhrUrl","sendXHR","fetchKeepAliveStrategy","sendOnExit","canUseBeacon","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","request","open","setRequestHeader","Batch","encoder","flushController","upsertBuffer","flushSubscription","flushObservable","flush","addOrUpdate","upsert","upsertMessages","isPageExit","encoderResult","formatPayloadFromEncoder","pendingMessages","serializedMessage","estimatedMessageBytesCount","hasMessageFor","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","removedMessage","messageBytesCount","notifyAfterRemoveMessage","createFlushController","durationLimitTimeoutId","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","pageExitSubscription","sessionExpireSubscription","currentBytesCount","currentMessagesCount","flushReason","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","startBatchWithReplica","primary","primaryBatch","createBatch","replicaBatch","endpoint","replicated","transformMessage"],"sourceRoot":""}