{"version":3,"file":"js/2199.js","mappings":"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","sources":["webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/boot/init.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/addEventListener.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/pageExitObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/runOnReadyState.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/configuration/intakeSites.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/connectivity/connectivity.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/error/error.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/error/error.types.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/telemetry/rawTelemetryEvent.types.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/telemetry/telemetry.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/boundedBuffer.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/catchUserErrors.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/display.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/experimentalFeatures.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/getGlobalObject.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/getZoneJsOriginalValue.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/instrumentMethod.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/mergeInto.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/monitor.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/observable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/requestIdleCallback.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/sendToExtension.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/serialisation/jsonStringify.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/serialisation/sanitize.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/stackTrace/computeStackTrace.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/stackTrace/handlingStack.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/timer.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/arrayUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/browserDetection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/byteUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/functionUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/numberUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/objectUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/polyfills.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/responseUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/timeUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/typeUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/urlPolyfill.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/eventBridge.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/sendWithRetryStrategy.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/httpRequest.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/context/customerDataTracker.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/context/contextManager.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/trackingConsent.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/context/storeContextManager.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/encoder.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/user/user.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/boot/displayAlreadyInitializedError.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/utils/stringUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/vital/vitalCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/plugins.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/fetchObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/cookie.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/synthetics/syntheticsWorkerValues.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/storeStrategies/sessionStoreStrategy.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionConstants.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionStateValidation.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionState.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/oldCookiesMigration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/storeStrategies/sessionInCookie.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/storeStrategies/sessionInLocalStorage.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionStoreOperations.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionStore.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/configuration/endpointBuilder.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/configuration/tags.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/configuration/transportConfiguration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/configuration/configuration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/matchOption.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/crypto.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/identifier.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/tracer.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/sampler.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/configuration/configuration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/configuration/remoteConfiguration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/boot/preStartRum.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/boot/rumPublicApi.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/commonContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/domMutationObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/eventRateLimiter/createEventRateLimiter.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/limitModification.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/assembly.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/syntheticsContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/lifeCycle.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/abstractLifeCycle.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/valueHistory.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/viewHistory.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/browser/xhrObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/resource/resourceUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/requestCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/readBytesFromStream.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/discardNegativeDuration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/trackEventCounts.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/performanceObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/firstInputPolyfill.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/waitPageActivityEnd.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/htmlDomUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/privacy.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/getActionNameFromElement.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/getSelectorFromElement.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/clickChain.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/listenActionEvents.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/computeFrustration.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/interactionSelectorCache.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/trackClickActions.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/action/actionCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/console/consoleObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/report/reportObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/error/errorCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/error/trackConsoleError.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/error/trackRuntimeError.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/error/trackReportError.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/tools/taskQueue.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/resource/matchRequestResourceEntry.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/getDocumentTraceId.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/performanceUtils.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/resource/retrieveInitialDocumentResourceTiming.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/resource/resourceCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackFirstContentfulPaint.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackLargestContentfulPaint.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackFirstHidden.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackInitialViewMetrics.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackNavigationTimings.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackFirstInput.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackCumulativeLayoutShift.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/interactionCountPolyfill.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackInteractionToNextPaint.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/scroll.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/viewportObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackScrollMetrics.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackCommonViewMetrics.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewMetrics/trackLoadingTime.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/trackViews.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/viewCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/view/trackViewEventCounts.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/domain/session/sessionManager.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/rumSessionManager.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/batch.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/flushController.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/transport/startRumBatch.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-core/src/transport/startBatchWithReplica.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/urlContexts.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/locationChangeObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/featureFlagContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/startCustomerDataTelemetry.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/pageStateHistory.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/cookieObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/ciVisibilityContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/boot/startRum.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/transport/startRumEventBridge.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/browser/windowOpenObservable.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/displayContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/longAnimationFrame/longAnimationFrameCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/longTask/longTaskCollection.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/internalContext.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum-core/src/domain/getSessionReplayUrl.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/domain/replayStats.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/domain/deflate/deflateEncoder.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/domain/deflate/deflateWorker.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/boot/isBrowserSupported.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/boot/postStartStrategy.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/domain/getSessionReplayLink.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/entries/main.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/boot/recorderApi.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/boot/preStartStrategy.ts","webpack://nocodenodeweb/./node_modules/@datadog/browser-rum/src/boot/lazyLoadRecorder.ts"],"sourcesContent":["import { catchUserErrors } from '../tools/catchUserErrors'\nimport { setDebugMode } from '../tools/monitor'\nimport { display } from '../tools/display'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nexport interface PublicApi {\n  /**\n   * Version of the Logs browser SDK\n   */\n  version: string\n\n  /**\n   * [For CDN async setup] Early RUM API calls must be wrapped in the `window.DD_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.\n   *\n   * See [CDN async setup](https://docs.datadoghq.com/real_user_monitoring/browser/#cdn-async) for further information.\n   */\n  onReady: (callback: () => void) => void\n}\n\nexport function makePublicApi<T extends PublicApi>(stub: Omit<T, keyof PublicApi>): T {\n  const publicApi = {\n    version: __BUILD_ENV__SDK_VERSION__,\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(callback: () => void) {\n      callback()\n    },\n    ...stub,\n  }\n\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() {\n      return setDebugMode\n    },\n    enumerable: false,\n  })\n\n  return publicApi as T\n}\n\nexport function defineGlobal<Global, Name extends keyof Global>(global: Global, name: Name, api: Global[Name]) {\n  const existingGlobalVariable = global[name] as { q?: Array<() => void>; version?: string } | undefined\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((fn) => catchUserErrors(fn, 'onReady callback threw an error:')())\n  }\n}\n","import { monitor } from '../tools/monitor'\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'\nimport type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'\n\nexport type TrustableEvent<E extends Event = Event> = E & { __ddIsTrusted?: boolean }\n\nexport const enum DOM_EVENT {\n  BEFORE_UNLOAD = 'beforeunload',\n  CLICK = 'click',\n  DBL_CLICK = 'dblclick',\n  KEY_DOWN = 'keydown',\n  LOAD = 'load',\n  POP_STATE = 'popstate',\n  SCROLL = 'scroll',\n  TOUCH_START = 'touchstart',\n  TOUCH_END = 'touchend',\n  TOUCH_MOVE = 'touchmove',\n  VISIBILITY_CHANGE = 'visibilitychange',\n  PAGE_SHOW = 'pageshow',\n  FREEZE = 'freeze',\n  RESUME = 'resume',\n  DOM_CONTENT_LOADED = 'DOMContentLoaded',\n  POINTER_DOWN = 'pointerdown',\n  POINTER_UP = 'pointerup',\n  POINTER_CANCEL = 'pointercancel',\n  HASH_CHANGE = 'hashchange',\n  PAGE_HIDE = 'pagehide',\n  MOUSE_DOWN = 'mousedown',\n  MOUSE_UP = 'mouseup',\n  MOUSE_MOVE = 'mousemove',\n  FOCUS = 'focus',\n  BLUR = 'blur',\n  CONTEXT_MENU = 'contextmenu',\n  RESIZE = 'resize',\n  CHANGE = 'change',\n  INPUT = 'input',\n  PLAY = 'play',\n  PAUSE = 'pause',\n  SECURITY_POLICY_VIOLATION = 'securitypolicyviolation',\n  SELECTION_CHANGE = 'selectionchange',\n  STORAGE = 'storage',\n}\n\ninterface AddEventListenerOptions {\n  once?: boolean\n  capture?: boolean\n  passive?: boolean\n}\n\ntype EventMapFor<T> = T extends Window\n  ? WindowEventMap & {\n      // TS 4.9.5 does not support `freeze` and `resume` events yet\n      freeze: Event\n      resume: Event\n      // TS 4.9.5 does not define `visibilitychange` on Window (only Document)\n      visibilitychange: Event\n    }\n  : T extends Document\n    ? DocumentEventMap\n    : T extends HTMLElement\n      ? HTMLElementEventMap\n      : T extends VisualViewport\n        ? VisualViewportEventMap\n        : T extends ShadowRoot\n          ? // ShadowRootEventMap is not yet defined in our supported TS version. Instead, use\n            // GlobalEventHandlersEventMap which is more than enough as we only need to listen for events bubbling\n            // through the ShadowRoot like \"change\" or \"input\"\n            GlobalEventHandlersEventMap\n          : T extends XMLHttpRequest\n            ? XMLHttpRequestEventMap\n            : T extends Performance\n              ? PerformanceEventMap\n              : T extends Worker\n                ? WorkerEventMap\n                : T extends CookieStore\n                  ? CookieStoreEventMap\n                  : Record<never, never>\n\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<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(\n  configuration: { allowUntrustedEvents?: boolean | undefined },\n  eventTarget: Target,\n  eventName: EventName,\n  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,\n  options?: AddEventListenerOptions\n) {\n  return addEventListeners(configuration, eventTarget, [eventName], listener, options)\n}\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<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(\n  configuration: { allowUntrustedEvents?: boolean | undefined },\n  eventTarget: Target,\n  eventNames: EventName[],\n  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,\n  { once, capture, passive }: AddEventListenerOptions = {}\n) {\n  const listenerWithMonitor = monitor((event: TrustableEvent) => {\n    if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {\n      return\n    }\n    if (once) {\n      stop()\n    }\n    listener(event as unknown as EventMapFor<Target>[EventName] & { type: EventName })\n  })\n\n  const options = passive ? { capture, passive } : capture\n\n  // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)\n  const listenerTarget =\n    window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget\n\n  const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener')\n  eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options))\n\n  function stop() {\n    const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')\n    eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))\n  }\n\n  return {\n    stop,\n  }\n}\n","import { Observable } from '../tools/observable'\nimport { objectValues } from '../tools/utils/polyfills'\nimport type { Configuration } from '../domain/configuration'\nimport { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'\n\nexport const PageExitReason = {\n  HIDDEN: 'visibility_hidden',\n  UNLOADING: 'before_unload',\n  PAGEHIDE: 'page_hide',\n  FROZEN: 'page_frozen',\n} as const\n\nexport type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason]\n\nexport interface PageExitEvent {\n  reason: PageExitReason\n}\n\nexport function createPageExitObservable(configuration: Configuration): Observable<PageExitEvent> {\n  return new Observable<PageExitEvent>((observable) => {\n    const { stop: stopListeners } = addEventListeners(\n      configuration,\n      window,\n      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],\n      (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        } 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      },\n      { capture: true }\n    )\n\n    const stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {\n      observable.notify({ reason: PageExitReason.UNLOADING })\n    }).stop\n\n    return () => {\n      stopListeners()\n      stopBeforeUnloadListener()\n    }\n  })\n}\n\nexport function isPageExitReason(reason: string): reason is PageExitReason {\n  return objectValues(PageExitReason).includes(reason as PageExitReason)\n}\n","import type { Configuration } from '../domain/configuration'\nimport { noop } from '../tools/utils/functionUtils'\nimport { DOM_EVENT, addEventListener } from './addEventListener'\n\nexport function runOnReadyState(\n  configuration: Configuration,\n  expectedReadyState: 'complete' | 'interactive',\n  callback: () => void\n): { stop: () => void } {\n  if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n    callback()\n    return { stop: noop }\n  }\n  const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED\n  return addEventListener(configuration, window, eventName, callback, { once: true })\n}\n\nexport function asyncRunOnReadyState(\n  configuration: Configuration,\n  expectedReadyState: 'complete' | 'interactive'\n): Promise<void> {\n  return new Promise((resolve) => {\n    runOnReadyState(configuration, expectedReadyState, resolve)\n  })\n}\n","export type Site =\n  | 'datadoghq.com'\n  | 'us3.datadoghq.com'\n  | 'us5.datadoghq.com'\n  | 'datadoghq.eu'\n  | 'ddog-gov.com'\n  | 'ap1.datadoghq.com'\n\nexport const INTAKE_SITE_STAGING: Site = 'datad0g.com' as Site\nexport const INTAKE_SITE_FED_STAGING: Site = 'dd0g-gov.com' as Site\nexport const INTAKE_SITE_US1: Site = 'datadoghq.com'\nexport const INTAKE_SITE_EU1: Site = 'datadoghq.eu'\nexport const INTAKE_SITE_US1_FED: Site = 'ddog-gov.com'\n\nexport const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com'\nexport const INTAKE_URL_PARAMETERS = ['ddsource', 'ddtags']\n","export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'\nexport type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'\n\ninterface BrowserNavigator extends Navigator {\n  connection?: NetworkInformation\n}\n\nexport interface NetworkInformation {\n  type?: NetworkInterface\n  effectiveType?: EffectiveType\n}\n\nexport interface Connectivity {\n  status: 'connected' | 'not_connected'\n  interfaces?: NetworkInterface[]\n  effective_type?: EffectiveType\n  [key: string]: unknown\n}\n\nexport function getConnectivity(): Connectivity {\n  const navigator = window.navigator as BrowserNavigator\n  return {\n    status: navigator.onLine ? 'connected' : 'not_connected',\n    interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,\n    effective_type: navigator.connection?.effectiveType,\n  }\n}\n","import { sanitize } from '../../tools/serialisation/sanitize'\nimport type { ClocksState } from '../../tools/utils/timeUtils'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack'\nimport type { ErrorSource, ErrorHandling, RawError, RawErrorCause, ErrorWithCause, NonErrorPrefix } from './error.types'\n\nexport const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'\n\ntype RawErrorParams = {\n  stackTrace?: StackTrace\n  originalError: unknown\n\n  handlingStack?: string\n  componentStack?: string\n  startClocks: ClocksState\n  nonErrorPrefix: NonErrorPrefix\n  source: ErrorSource\n  handling: ErrorHandling\n}\n\nexport function computeRawError({\n  stackTrace,\n  originalError,\n  handlingStack,\n  componentStack,\n  startClocks,\n  nonErrorPrefix,\n  source,\n  handling,\n}: RawErrorParams): RawError {\n  const isErrorInstance = isError(originalError)\n\n  const message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError)\n  const stack = hasUsableStack(isErrorInstance, stackTrace)\n    ? toStackTraceString(stackTrace)\n    : NO_ERROR_STACK_PRESENT_MESSAGE\n  const causes = isErrorInstance ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined\n  const type = stackTrace ? stackTrace.name : undefined\n  const fingerprint = tryToGetFingerprint(originalError)\n\n  return {\n    startClocks,\n    source,\n    handling,\n    handlingStack,\n    componentStack,\n    originalError,\n    type,\n    message,\n    stack,\n    causes,\n    fingerprint,\n  }\n}\n\nfunction computeMessage(\n  stackTrace: StackTrace | undefined,\n  isErrorInstance: boolean,\n  nonErrorPrefix: NonErrorPrefix,\n  originalError: unknown\n) {\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?.message && stackTrace?.name\n    ? stackTrace.message\n    : !isErrorInstance\n      ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`\n      : 'Empty message'\n}\n\nfunction hasUsableStack(isErrorInstance: boolean, stackTrace?: StackTrace): stackTrace is 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}\n\nexport function tryToGetFingerprint(originalError: unknown) {\n  return isError(originalError) && 'dd_fingerprint' in originalError ? String(originalError.dd_fingerprint) : undefined\n}\n\nexport function getFileFromStackTraceString(stack: string) {\n  return /@ (.+)/.exec(stack)?.[1]\n}\n\nexport function isError(error: unknown): error is Error {\n  return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'\n}\n\nexport function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {\n  let currentError = error\n  const causes: RawErrorCause[] = []\n  while (isError(currentError?.cause) && causes.length < 10) {\n    const stackTrace = computeStackTrace(currentError.cause)\n    causes.push({\n      message: currentError.cause.message,\n      source: parentSource,\n      type: stackTrace?.name,\n      stack: stackTrace && toStackTraceString(stackTrace),\n    })\n    currentError = currentError.cause\n  }\n  return causes.length ? causes : undefined\n}\n","import type { ClocksState } from '../../tools/utils/timeUtils'\n\n// TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be\n// `unknown`[2].\n//\n// Because we still support TS 3.8, we need to declare our own type. We can remove it once we drop\n// support for TS v4.7 and before. The 'cause' property defined by TS needs to be omitted because\n// we define it with a type `unknown` which is incompatible with TS 4.6 and 4.7.\n//\n// [1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-6/#target-es2022\n// [2]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#lib-d-ts-updates\nexport interface ErrorWithCause extends Omit<Error, 'cause'> {\n  cause?: unknown\n}\n\nexport type RawErrorCause = {\n  message: string\n  source: string\n  type?: string\n  stack?: string\n}\n\nexport type Csp = {\n  disposition: 'enforce' | 'report'\n}\n\nexport interface RawError {\n  startClocks: ClocksState\n  message: string\n  type?: string\n  stack?: string\n  source: ErrorSource\n  originalError?: unknown\n  handling?: ErrorHandling\n  handlingStack?: string\n  componentStack?: string\n  causes?: RawErrorCause[]\n  fingerprint?: string\n  csp?: Csp\n}\n\nexport const ErrorSource = {\n  AGENT: 'agent',\n  CONSOLE: 'console',\n  CUSTOM: 'custom',\n  LOGGER: 'logger',\n  NETWORK: 'network',\n  SOURCE: 'source',\n  REPORT: 'report',\n} as const\n\nexport const enum NonErrorPrefix {\n  UNCAUGHT = 'Uncaught',\n  PROVIDED = 'Provided',\n}\n\nexport const enum ErrorHandling {\n  HANDLED = 'handled',\n  UNHANDLED = 'unhandled',\n}\n\nexport type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource]\n","import type { TelemetryEvent, TelemetryConfigurationEvent, TelemetryUsageEvent } from './telemetryEvent.types'\n\nexport const TelemetryType = {\n  log: 'log',\n  configuration: 'configuration',\n  usage: 'usage',\n} as const\n\nexport const enum StatusType {\n  debug = 'debug',\n  error = 'error',\n}\n\nexport interface RuntimeEnvInfo {\n  is_local_file: boolean\n  is_worker: boolean\n}\n\nexport type RawTelemetryEvent = TelemetryEvent['telemetry']\nexport type RawTelemetryConfiguration = TelemetryConfigurationEvent['telemetry']['configuration']\nexport type RawTelemetryUsage = TelemetryUsageEvent['telemetry']['usage']\n","import type { Context } from '../../tools/serialisation/context'\nimport { ConsoleApiName } from '../../tools/display'\nimport { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error'\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack'\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures'\nimport type { Configuration } from '../configuration'\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 { performDraw } from '../../tools/utils/numberUtils'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport { combine } from '../../tools/mergeInto'\nimport { NonErrorPrefix } from '../error/error.types'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { getConnectivity } from '../connectivity'\nimport { createBoundedBuffer } from '../../tools/boundedBuffer'\nimport type { TelemetryEvent } from './telemetryEvent.types'\nimport type {\n  RawTelemetryConfiguration,\n  RawTelemetryEvent,\n  RuntimeEnvInfo,\n  RawTelemetryUsage,\n} from './rawTelemetryEvent.types'\nimport { StatusType, TelemetryType } from './rawTelemetryEvent.types'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\ndeclare const __BUILD_ENV__SDK_SETUP__: string\n\nconst 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]\n\nexport const enum TelemetryService {\n  LOGS = 'browser-logs-sdk',\n  RUM = 'browser-rum-sdk',\n}\n\nexport interface Telemetry {\n  setContextProvider: (provider: () => Context) => void\n  observable: Observable<TelemetryEvent & Context>\n  enabled: boolean\n}\n\nconst TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED]\n\n// eslint-disable-next-line local-rules/disallow-side-effects\nlet preStartTelemetryBuffer = createBoundedBuffer()\nlet onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {\n  preStartTelemetryBuffer.add(() => onRawTelemetryEventCollected(event))\n}\n\nexport function startTelemetry(telemetryService: TelemetryService, configuration: Configuration): Telemetry {\n  let contextProvider: () => Context\n  const observable = new Observable<TelemetryEvent & Context>()\n  const alreadySentEvents = new Set<string>()\n\n  const telemetryEnabled =\n    !TELEMETRY_EXCLUDED_SITES.includes(configuration.site) && performDraw(configuration.telemetrySampleRate)\n\n  const telemetryEnabledPerType = {\n    [TelemetryType.log]: telemetryEnabled,\n    [TelemetryType.configuration]: telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),\n    [TelemetryType.usage]: telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),\n  }\n\n  const runtimeEnvInfo = getRuntimeEnvInfo()\n  onRawTelemetryEventCollected = (rawEvent: RawTelemetryEvent) => {\n    const stringifiedEvent = jsonStringify(rawEvent)!\n    if (\n      telemetryEnabledPerType[rawEvent.type!] &&\n      alreadySentEvents.size < configuration.maxTelemetryEventsPerPage &&\n      !alreadySentEvents.has(stringifiedEvent)\n    ) {\n      const event = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo)\n      observable.notify(event)\n      sendToExtension('telemetry', event)\n      alreadySentEvents.add(stringifiedEvent)\n    }\n  }\n  startMonitorErrorCollection(addTelemetryError)\n\n  function toTelemetryEvent(\n    telemetryService: TelemetryService,\n    event: RawTelemetryEvent,\n    runtimeEnvInfo: RuntimeEnvInfo\n  ): TelemetryEvent & Context {\n    return combine(\n      {\n        type: 'telemetry' as const,\n        date: timeStampNow(),\n        service: telemetryService,\n        version: __BUILD_ENV__SDK_VERSION__,\n        source: 'browser' as const,\n        _dd: {\n          format_version: 2 as const,\n        },\n        telemetry: combine(event, {\n          runtime_env: runtimeEnvInfo,\n          connectivity: getConnectivity(),\n          sdk_setup: __BUILD_ENV__SDK_SETUP__,\n        }),\n        experimental_features: Array.from(getExperimentalFeatures()),\n      },\n      contextProvider !== undefined ? contextProvider() : {}\n    ) as TelemetryEvent & Context\n  }\n\n  return {\n    setContextProvider: (provider: () => Context) => {\n      contextProvider = provider\n    },\n    observable,\n    enabled: telemetryEnabled,\n  }\n}\nfunction getRuntimeEnvInfo(): RuntimeEnvInfo {\n  return {\n    is_local_file: window.location.protocol === 'file:',\n    is_worker: 'WorkerGlobalScope' in self,\n  }\n}\n\nexport function startFakeTelemetry() {\n  const events: RawTelemetryEvent[] = []\n\n  onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {\n    events.push(event)\n  }\n\n  return events\n}\n\n// need to be called after telemetry context is provided and observers are registered\nexport function drainPreStartTelemetry() {\n  preStartTelemetryBuffer.drain()\n}\n\nexport function resetTelemetry() {\n  preStartTelemetryBuffer = createBoundedBuffer()\n  onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {\n    preStartTelemetryBuffer.add(() => onRawTelemetryEventCollected(event))\n  }\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: Configuration) {\n  return configuration.site === INTAKE_SITE_STAGING\n}\n\nexport function addTelemetryDebug(message: string, context?: Context) {\n  displayIfDebugEnabled(ConsoleApiName.debug, message, context)\n  onRawTelemetryEventCollected({\n    type: TelemetryType.log,\n    message,\n    status: StatusType.debug,\n    ...context,\n  })\n}\n\nexport function addTelemetryError(e: unknown, context?: Context) {\n  onRawTelemetryEventCollected({\n    type: TelemetryType.log,\n    status: StatusType.error,\n    ...formatError(e),\n    ...context,\n  })\n}\n\nexport function addTelemetryConfiguration(configuration: RawTelemetryConfiguration) {\n  onRawTelemetryEventCollected({\n    type: TelemetryType.configuration,\n    configuration,\n  })\n}\n\nexport function addTelemetryUsage(usage: RawTelemetryUsage) {\n  onRawTelemetryEventCollected({\n    type: TelemetryType.usage,\n    usage,\n  })\n}\n\nexport function formatError(e: unknown) {\n  if (isError(e)) {\n    const 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: `${NonErrorPrefix.UNCAUGHT} ${jsonStringify(e)!}`,\n  }\n}\n\nexport function scrubCustomerFrames(stackTrace: StackTrace) {\n  stackTrace.stack = stackTrace.stack.filter(\n    (frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => frame.url!.startsWith(allowedFrameUrl))\n  )\n  return stackTrace\n}\n","import { removeItem } from './utils/arrayUtils'\n\nconst BUFFER_LIMIT = 500\n\nexport interface BoundedBuffer<T = void> {\n  add: (callback: (arg: T) => void) => void\n  remove: (callback: (arg: T) => void) => void\n  drain: (arg: T) => void\n}\n\nexport function createBoundedBuffer<T = void>(): BoundedBuffer<T> {\n  const buffer: Array<(arg: T) => void> = []\n\n  const add: BoundedBuffer<T>['add'] = (callback: (arg: T) => void) => {\n    const length = buffer.push(callback)\n    if (length > BUFFER_LIMIT) {\n      buffer.splice(0, 1)\n    }\n  }\n\n  const remove: BoundedBuffer<T>['remove'] = (callback: (arg: T) => void) => {\n    removeItem(buffer, callback)\n  }\n\n  const drain = (arg: T) => {\n    buffer.forEach((callback) => callback(arg))\n    buffer.length = 0\n  }\n\n  return {\n    add,\n    remove,\n    drain,\n  }\n}\n","import { display } from './display'\n\nexport function catchUserErrors<Args extends any[], R>(fn: (...args: Args) => R, errorMsg: string) {\n  return (...args: Args) => {\n    try {\n      return fn(...args)\n    } catch (err) {\n      display.error(errorMsg, err)\n    }\n  }\n}\n","/* 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 */\n\nexport const ConsoleApiName = {\n  log: 'log',\n  debug: 'debug',\n  info: 'info',\n  warn: 'warn',\n  error: 'error',\n} as const\n\nexport type ConsoleApiName = (typeof ConsoleApiName)[keyof typeof ConsoleApiName]\n\ninterface Display {\n  debug: typeof console.debug\n  log: typeof console.log\n  info: typeof console.info\n  warn: typeof console.warn\n  error: typeof console.error\n}\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 const globalConsole = console\n\nexport const originalConsoleMethods = {} as Display\nObject.keys(ConsoleApiName).forEach((name) => {\n  originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]\n})\n\nconst PREFIX = 'Datadog Browser SDK:'\n\nexport const display: 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}\n\nexport const DOCS_ORIGIN = 'https://docs.datadoghq.com'\nexport const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`\nexport const MORE_DETAILS = 'More details:'\n","/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\n\nimport { objectHasValue } from './utils/objectUtils'\n\n// eslint-disable-next-line no-restricted-syntax\nexport enum ExperimentalFeature {\n  WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',\n  REMOTE_CONFIGURATION = 'remote_configuration',\n  ACTION_NAME_MASKING = 'action_name_masking',\n  CONSISTENT_TRACE_SAMPLING = 'consistent_trace_sampling',\n}\n\nconst enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()\n\nexport function initFeatureFlags(enableExperimentalFeatures: string[] | undefined) {\n  if (Array.isArray(enableExperimentalFeatures)) {\n    addExperimentalFeatures(\n      enableExperimentalFeatures.filter((flag): flag is ExperimentalFeature =>\n        objectHasValue(ExperimentalFeature, flag)\n      )\n    )\n  }\n}\n\nexport function addExperimentalFeatures(enabledFeatures: ExperimentalFeature[]): void {\n  enabledFeatures.forEach((flag) => {\n    enabledExperimentalFeatures.add(flag)\n  })\n}\n\nexport function isExperimentalFeatureEnabled(featureName: ExperimentalFeature): boolean {\n  return enabledExperimentalFeatures.has(featureName)\n}\n\nexport function resetExperimentalFeatures(): void {\n  enabledExperimentalFeatures.clear()\n}\n\nexport function getExperimentalFeatures(): Set<ExperimentalFeature> {\n  return enabledExperimentalFeatures\n}\n","/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\n\nexport function getGlobalObject<T = typeof globalThis>(): T {\n  if (typeof globalThis === 'object') {\n    return globalThis as unknown as T\n  }\n  Object.defineProperty(Object.prototype, '_dd_temp_', {\n    get() {\n      return this as object\n    },\n    configurable: true,\n  })\n  // @ts-ignore _dd_temp is defined using defineProperty\n  let globalObject: unknown = _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    } else if (typeof window === 'object') {\n      globalObject = window\n    } else {\n      globalObject = {}\n    }\n  }\n  return globalObject as T\n}\n","import { getGlobalObject } from './getGlobalObject'\n\nexport interface BrowserWindowWithZoneJs extends Window {\n  Zone?: {\n    // All Zone.js versions expose the __symbol__ method, but we observed that some website have a\n    // 'Zone' global variable unrelated to Zone.js, so let's consider this method optional\n    // nonetheless.\n    __symbol__?: (name: string) => string\n  }\n}\n\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 extends keyof Target & string>(\n  target: Target,\n  name: Name\n): Target[Name] {\n  const browserWindow = getGlobalObject<BrowserWindowWithZoneJs>()\n  let original: Target[Name] | undefined\n  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n    original = (target as any)[browserWindow.Zone.__symbol__(name)]\n  }\n  if (!original) {\n    original = target[name]\n  }\n  return original\n}\n","import { setTimeout } from './timer'\nimport { callMonitored } from './monitor'\nimport { noop } from './utils/functionUtils'\nimport { createHandlingStack } from './stackTrace/handlingStack'\n\n/**\n * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more\n * info.\n */\nexport type InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = {\n  /**\n   * The target object on which the method was called.\n   */\n  target: TARGET\n\n  /**\n   * The parameters with which the method was called.\n   *\n   * Note: if needed, parameters can be mutated by the instrumentation\n   */\n  parameters: Parameters<TARGET[METHOD]>\n\n  /**\n   * Registers a callback that will be called after the original method is called, with the method\n   * result passed as argument.\n   */\n  onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void\n\n  /**\n   * The stack trace of the method call.\n   */\n  handlingStack?: string\n}\n\ntype PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = (\n  result: ReturnType<TARGET[METHOD]>\n) => void\n\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<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET & string>(\n  targetPrototype: TARGET,\n  method: METHOD,\n  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void,\n  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}\n) {\n  let original = targetPrototype[method]\n\n  if (typeof original !== 'function') {\n    if (method in targetPrototype && method.startsWith('on')) {\n      original = noop as TARGET[METHOD]\n    } else {\n      return { stop: noop }\n    }\n  }\n\n  let stopped = false\n\n  const instrumentation = function (this: TARGET): ReturnType<TARGET[METHOD]> | undefined {\n    if (stopped) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n      return original.apply(this, arguments as unknown as Parameters<TARGET[METHOD]>)\n    }\n\n    const parameters = Array.from(arguments) as Parameters<TARGET[METHOD]>\n\n    let postCallCallback: PostCallCallback<TARGET, METHOD> | undefined\n\n    callMonitored(onPreCall, null, [\n      {\n        target: this,\n        parameters,\n        onPostCall: (callback) => {\n          postCallCallback = callback\n        },\n        handlingStack: computeHandlingStack ? createHandlingStack() : undefined,\n      },\n    ])\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n    const result = original.apply(this, parameters)\n\n    if (postCallCallback) {\n      callMonitored(postCallCallback, null, [result])\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return result\n  }\n\n  targetPrototype[method] = instrumentation as TARGET[METHOD]\n\n  return {\n    stop: () => {\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}\n\nexport function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY extends keyof TARGET>(\n  targetPrototype: TARGET,\n  property: PROPERTY,\n  after: (target: TARGET, value: TARGET[PROPERTY]) => void\n) {\n  const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property)\n  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n    return { stop: noop }\n  }\n\n  const stoppedInstrumentation = noop\n  let instrumentation = (target: TARGET, value: TARGET[PROPERTY]) => {\n    // put hooked setter into event loop to avoid of set latency\n    setTimeout(() => {\n      if (instrumentation !== stoppedInstrumentation) {\n        after(target, value)\n      }\n    }, 0)\n  }\n\n  const instrumentationWrapper = function (this: TARGET, value: TARGET[PROPERTY]) {\n    originalDescriptor.set!.call(this, value)\n    instrumentation(this, value)\n  }\n\n  Object.defineProperty(targetPrototype, property, {\n    set: instrumentationWrapper,\n  })\n\n  return {\n    stop: () => {\n      if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) {\n        Object.defineProperty(targetPrototype, property, originalDescriptor)\n      }\n      instrumentation = stoppedInstrumentation\n    },\n  }\n}\n","import { getType } from './utils/typeUtils'\n\ntype Merged<TDestination, TSource> =\n  // case 1 - source is undefined - return destination\n  TSource extends undefined\n    ? TDestination\n    : // case 2 - destination is undefined - return source\n      TDestination extends undefined\n      ? TSource\n      : // case 3 - source is an array - see if it merges or overwrites\n        TSource extends any[]\n        ? TDestination extends any[]\n          ? TDestination & TSource\n          : TSource\n        : // case 4 - source is an object - see if it merges or overwrites\n          TSource extends object\n          ? TDestination extends object\n            ? TDestination extends any[]\n              ? TSource\n              : TDestination & TSource\n            : TSource\n          : // case 5 - cannot merge - return source\n            TSource\n\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<D, S>(\n  destination: D,\n  source: S,\n  circularReferenceChecker = createCircularReferenceChecker()\n): Merged<D, S> {\n  // ignore the source if it is undefined\n  if (source === undefined) {\n    return destination as Merged<D, S>\n  }\n\n  if (typeof source !== 'object' || source === null) {\n    // primitive values - just return source\n    return source as Merged<D, S>\n  } else if (source instanceof Date) {\n    return new Date(source.getTime()) as unknown as Merged<D, S>\n  } else if (source instanceof RegExp) {\n    const flags =\n      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) as unknown as Merged<D, S>\n  }\n\n  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n    // remove circular references\n    return undefined as unknown as Merged<D, S>\n  } else if (Array.isArray(source)) {\n    const merged: any[] = Array.isArray(destination) ? destination : []\n    for (let i = 0; i < source.length; ++i) {\n      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker)\n    }\n    return merged as unknown as Merged<D, S>\n  }\n\n  const merged = getType(destination) === 'object' ? (destination as Record<any, any>) : {}\n  for (const 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 as unknown as Merged<D, S>\n}\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<T>(value: T): T {\n  return mergeInto(undefined, value) as T\n}\n\ntype Combined<A, B> = A extends null ? B : B extends null ? A : Merged<A, B>\n\n/*\n * Performs a deep merge of objects and arrays.\n * - Arguments won't be mutated\n * - Object and arrays in the output value are de-referenced (\"deep cloned\")\n * - Arrays values are merged index by index\n * - Objects are merged by keys\n * - Values get replaced, unless undefined\n */\nexport function combine<A, B>(a: A, b: B): Combined<A, B>\nexport function combine<A, B, C>(a: A, b: B, c: C): Combined<Combined<A, B>, C>\nexport function combine<A, B, C, D>(a: A, b: B, c: C, d: D): Combined<Combined<Combined<A, B>, C>, D>\nexport function combine<A, B, C, D, E>(\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E\n): Combined<Combined<Combined<Combined<A, B>, C>, D>, E>\nexport function combine<A, B, C, D, E, F>(\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F\n): Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>\nexport function combine<A, B, C, D, E, F, G>(\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n  g: G\n): Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>\nexport function combine<A, B, C, D, E, F, G, H>(\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n  g: G,\n  h: H\n): Combined<Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>, H>\nexport function combine(...sources: any[]): unknown {\n  let destination: any\n\n  for (const source of sources) {\n    // Ignore any undefined or null sources.\n    if (source === undefined || source === null) {\n      continue\n    }\n\n    destination = mergeInto(destination, source)\n  }\n\n  return destination as unknown\n}\n\ninterface CircularReferenceChecker {\n  hasAlreadyBeenSeen(value: any): boolean\n}\n\nfunction createCircularReferenceChecker(): CircularReferenceChecker {\n  if (typeof WeakSet !== 'undefined') {\n    const set: WeakSet<any> = new WeakSet()\n    return {\n      hasAlreadyBeenSeen(value) {\n        const has = set.has(value)\n        if (!has) {\n          set.add(value)\n        }\n        return has\n      },\n    }\n  }\n  const array: any[] = []\n  return {\n    hasAlreadyBeenSeen(value) {\n      const has = array.indexOf(value) >= 0\n      if (!has) {\n        array.push(value)\n      }\n      return has\n    },\n  }\n}\n","import { display } from './display'\n\nlet onMonitorErrorCollected: undefined | ((error: unknown) => void)\nlet debugMode = false\n\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected: (error: unknown) => void) {\n  onMonitorErrorCollected = newOnMonitorErrorCollected\n}\n\nexport function setDebugMode(newDebugMode: boolean) {\n  debugMode = newDebugMode\n}\n\nexport function resetMonitor() {\n  onMonitorErrorCollected = undefined\n  debugMode = false\n}\n\nexport function monitored<T extends (...params: any[]) => unknown>(\n  _: any,\n  __: string,\n  descriptor: TypedPropertyDescriptor<T>\n) {\n  const originalMethod = descriptor.value!\n  descriptor.value = function (this: any, ...args: Parameters<T>) {\n    const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod\n    return decorated.apply(this, args) as ReturnType<T>\n  } as T\n}\n\nexport function monitor<T extends (...args: any[]) => any>(fn: T): T {\n  return function (this: any) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return callMonitored(fn, this, arguments as unknown as Parameters<T>)\n  } as unknown as T // consider output type has input type\n}\n\nexport function callMonitored<T extends (...args: any[]) => any>(\n  fn: T,\n  context: ThisParameterType<T>,\n  args: Parameters<T>\n): ReturnType<T> | undefined\nexport function callMonitored<T extends (this: void) => any>(fn: T): ReturnType<T> | undefined\nexport function callMonitored<T extends (...args: any[]) => any>(\n  fn: T,\n  context?: any,\n  args?: any\n): ReturnType<T> | undefined {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return fn.apply(context, args)\n  } catch (e) {\n    monitorError(e)\n  }\n}\n\nexport function monitorError(e: unknown) {\n  displayIfDebugEnabled(e)\n  if (onMonitorErrorCollected) {\n    try {\n      onMonitorErrorCollected(e)\n    } catch (e) {\n      displayIfDebugEnabled(e)\n    }\n  }\n}\n\nexport function displayIfDebugEnabled(...args: any[]) {\n  if (debugMode) {\n    display.error('[MONITOR]', ...args)\n  }\n}\n","export interface Subscription {\n  unsubscribe: () => void\n}\n\n// eslint-disable-next-line no-restricted-syntax\nexport class Observable<T> {\n  private observers: Array<(data: T) => void> = []\n  private onLastUnsubscribe?: () => void\n\n  constructor(private onFirstSubscribe?: (observable: Observable<T>) => (() => void) | void) {}\n\n  subscribe(f: (data: T) => void): Subscription {\n    this.observers.push(f)\n    if (this.observers.length === 1 && this.onFirstSubscribe) {\n      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined\n    }\n    return {\n      unsubscribe: () => {\n        this.observers = this.observers.filter((other) => f !== other)\n        if (!this.observers.length && this.onLastUnsubscribe) {\n          this.onLastUnsubscribe()\n        }\n      },\n    }\n  }\n\n  notify(data: T) {\n    this.observers.forEach((observer) => observer(data))\n  }\n}\n\nexport function mergeObservables<T>(...observables: Array<Observable<T>>) {\n  return new Observable<T>((globalObservable) => {\n    const subscriptions: Subscription[] = observables.map((observable) =>\n      observable.subscribe((data) => globalObservable.notify(data))\n    )\n    return () => subscriptions.forEach((subscription) => subscription.unsubscribe())\n  })\n}\n","import { setTimeout, clearTimeout } from './timer'\nimport { monitor } from './monitor'\nimport { dateNow } from './utils/timeUtils'\n\n// This type is not yet supported in TS 3.8. Imported from the TS source until we upgrade the\n// minimum supported TS version.\n// https://github.com/microsoft/TypeScript/blob/13c374a868c926f6a907666a5599992c1351b773/src/lib/dom.generated.d.ts#L9513-L9516\nexport interface IdleDeadline {\n  readonly didTimeout: boolean\n  timeRemaining(): DOMHighResTimeStamp\n}\n\n/**\n * 'requestIdleCallback' with a shim.\n */\nexport function requestIdleCallback(callback: (deadline: IdleDeadline) => void, opts?: { timeout?: number }) {\n  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n  if (window.requestIdleCallback && window.cancelIdleCallback) {\n    const id = window.requestIdleCallback(monitor(callback), opts)\n    return () => window.cancelIdleCallback(id)\n  }\n  return requestIdleCallbackShim(callback)\n}\n\nexport const MAX_TASK_TIME = 50\n\n/*\n * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback\n * Note: there is no simple way to support the \"timeout\" option, so we ignore it.\n */\nexport function requestIdleCallbackShim(callback: (deadline: IdleDeadline) => void) {\n  const start = dateNow()\n  const timeoutId = setTimeout(() => {\n    callback({\n      didTimeout: false,\n      timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),\n    })\n  }, 0)\n  return () => clearTimeout(timeoutId)\n}\n","interface BrowserWindow {\n  __ddBrowserSdkExtensionCallback?: (message: unknown) => void\n}\n\ntype ExtensionMessageType = 'logs' | 'record' | 'rum' | 'telemetry'\n\nexport function sendToExtension(type: ExtensionMessageType, payload: unknown) {\n  const callback = (window as BrowserWindow).__ddBrowserSdkExtensionCallback\n  if (callback) {\n    callback({ type, payload })\n  }\n}\n","import { noop } from '../utils/functionUtils'\n\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(\n  value: unknown,\n  replacer?: Array<string | number>,\n  space?: string | number\n): string | undefined {\n  if (typeof value !== 'object' || value === null) {\n    return JSON.stringify(value)\n  }\n\n  // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n  // subclasses.\n  const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)\n  const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)\n  const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value))\n  const restoreValueToJson = detachToJsonMethod(value)\n\n  try {\n    return JSON.stringify(value, replacer, space)\n  } catch {\n    return '<error: unable to serialize object>'\n  } finally {\n    restoreObjectPrototypeToJson()\n    restoreArrayPrototypeToJson()\n    restoreValuePrototypeToJson()\n    restoreValueToJson()\n  }\n}\n\nexport interface ObjectWithToJsonMethod {\n  toJSON?: () => unknown\n}\n\nexport function detachToJsonMethod(value: object) {\n  const object = value as ObjectWithToJsonMethod\n  const objectToJson = object.toJSON\n  if (objectToJson) {\n    delete object.toJSON\n    return () => {\n      object.toJSON = objectToJson\n    }\n  }\n  return noop\n}\n","import { display } from '../display'\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils'\nimport type { Context, ContextArray, ContextValue } from './context'\nimport type { ObjectWithToJsonMethod } from './jsonStringify'\nimport { detachToJsonMethod } from './jsonStringify'\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\ntype PrimitivesAndFunctions = string | number | boolean | undefined | null | symbol | bigint | Function\ntype ExtendedContextValue = PrimitivesAndFunctions | object | ExtendedContext | ExtendedContextArray\ntype ExtendedContext = { [key: string]: ExtendedContextValue }\ntype ExtendedContextArray = ExtendedContextValue[]\n\ntype ContainerElementToProcess = {\n  source: ExtendedContextArray | ExtendedContext\n  target: ContextArray | Context\n  path: string\n}\n\ntype SanitizedEvent = {\n  type: string\n  isTrusted: boolean\n  currentTarget: string | null | undefined\n  target: string | null | undefined\n}\n\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, ...\nconst SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE\n\n// Symbol for the root element of the JSONPath used for visited objects\nconst JSON_PATH_ROOT_ELEMENT = '$'\n\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.\nconst KEY_DECORATION_LENGTH = 3\n\n/**\n * Ensures user-provided data is 'safe' for the SDK\n * - Deep clones data\n * - Removes cyclic references\n * - Transforms unserializable types to a string representation\n *\n * LIMITATIONS:\n * - Size is in characters, not byte count (may differ according to character encoding)\n * - Size does not take into account indentation that can be applied to JSON.stringify\n * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify\n *\n * @param source              User-provided data meant to be serialized using JSON.stringify\n * @param maxCharacterCount   Maximum number of characters allowed in serialized form\n */\nexport function sanitize(source: string, maxCharacterCount?: number): string | undefined\nexport function sanitize(source: Context, maxCharacterCount?: number): Context\nexport function sanitize(source: unknown, maxCharacterCount?: number): ContextValue\nexport function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {\n  // Unbind any toJSON function we may have on [] or {} prototypes\n  const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)\n  const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)\n\n  // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n  const containerQueue: ContainerElementToProcess[] = []\n  const visitedObjectsWithPath = new WeakMap<object, string>()\n  const sanitizedData = sanitizeProcessor(\n    source as ExtendedContextValue,\n    JSON_PATH_ROOT_ELEMENT,\n    undefined,\n    containerQueue,\n    visitedObjectsWithPath\n  )\n  const serializedSanitizedData = JSON.stringify(sanitizedData)\n  let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0\n\n  if (accumulatedCharacterCount > maxCharacterCount) {\n    warnOverCharacterLimit(maxCharacterCount, 'discarded', source)\n    return undefined\n  }\n\n  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n    const containerToProcess = containerQueue.shift()!\n    let separatorLength = 0 // 0 for the first element, 1 for subsequent elements\n\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 (let key = 0; key < containerToProcess.source.length; key++) {\n        const targetData = sanitizeProcessor(\n          containerToProcess.source[key],\n          containerToProcess.path,\n          key,\n          containerQueue,\n          visitedObjectsWithPath\n        )\n\n        if (targetData !== undefined) {\n          accumulatedCharacterCount += JSON.stringify(targetData).length\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        ;(containerToProcess.target as ContextArray)[key] = targetData\n      }\n    } else {\n      for (const key in containerToProcess.source) {\n        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n          const targetData = sanitizeProcessor(\n            containerToProcess.source[key],\n            containerToProcess.path,\n            key,\n            containerQueue,\n            visitedObjectsWithPath\n          )\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          ;(containerToProcess.target as Context)[key] = targetData\n        }\n      }\n    }\n  }\n\n  // Rebind detached toJSON functions\n  restoreObjectPrototypeToJson()\n  restoreArrayPrototypeToJson()\n\n  return sanitizedData\n}\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(\n  source: ExtendedContextValue,\n  parentPath: string,\n  key: string | number | undefined,\n  queue: ContainerElementToProcess[],\n  visitedObjectsWithPath: WeakMap<object, string>\n) {\n  // Start by handling toJSON, as we want to sanitize its output\n  const sourceToSanitize = tryToApplyToJSON(source)\n\n  if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n    return sanitizePrimitivesAndFunctions(sourceToSanitize)\n  }\n\n  const sanitizedSource = sanitizeObjects(sourceToSanitize)\n  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n    return sanitizedSource\n  }\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  const sourceAsObject = source as object\n  if (visitedObjectsWithPath.has(sourceAsObject)) {\n    return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)!}]`\n  }\n\n  // Add processed source to queue\n  const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath\n  const target = Array.isArray(sourceToSanitize) ? ([] as ContextArray) : ({} as Context)\n  visitedObjectsWithPath.set(sourceAsObject, currentPath)\n  queue.push({ source: sourceToSanitize as ExtendedContext | ExtendedContextArray, target, path: currentPath })\n\n  return target\n}\n\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value: PrimitivesAndFunctions) {\n  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n  if (typeof value === 'bigint') {\n    return `[BigInt] ${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] ${value.name || 'unknown'}`\n  }\n  // JSON.stringify() does not serialize symbols.\n  if (typeof value === 'symbol') {\n    // symbol.description is part of ES2019+\n    type symbolWithDescription = symbol & { description: string }\n    return `[Symbol] ${(value as symbolWithDescription).description || value.toString()}`\n  }\n\n  return value\n}\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 */\nfunction sanitizeObjects(value: object): string | SanitizedEvent {\n  try {\n    if (value instanceof Event) {\n      return sanitizeEvent(value)\n    }\n\n    if (value instanceof RegExp) {\n      return `[RegExp] ${value.toString()}`\n    }\n\n    // Handle all remaining object types in a generic way\n    const result = Object.prototype.toString.call(value)\n    const match = result.match(/\\[object (.*)\\]/)\n    if (match && match[1]) {\n      return `[${match[1]}]`\n    }\n  } catch {\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\nfunction sanitizeEvent(event: Event): SanitizedEvent {\n  return {\n    type: event.type,\n    isTrusted: event.isTrusted,\n    currentTarget: event.currentTarget ? (sanitizeObjects(event.currentTarget) as string) : null,\n    target: event.target ? (sanitizeObjects(event.target) as string) : null,\n  }\n}\n\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value: ExtendedContextValue) {\n  const object = value as ObjectWithToJsonMethod\n  if (object && typeof object.toJSON === 'function') {\n    try {\n      return object.toJSON() as ExtendedContextValue\n    } catch {\n      // If toJSON fails, we continue by trying to serialize the value manually\n    }\n  }\n\n  return value\n}\n\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount: number, changeType: 'discarded' | 'truncated', source: unknown) {\n  display.warn(\n    `The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`,\n    source\n  )\n}\n","/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\n\nexport interface StackFrame {\n  url?: string\n  func?: string\n  /** The arguments passed to the function, if known. */\n  args?: string[]\n  line?: number\n  column?: number\n  /** An array of source code lines; the middle element corresponds to the correct line. */\n  context?: string[]\n}\n\nexport interface StackTrace {\n  name?: string\n  message?: string\n  url?: string\n  stack: StackFrame[]\n  incomplete?: boolean\n  partial?: boolean\n}\n\nconst UNKNOWN_FUNCTION = '?'\n\nexport function computeStackTrace(ex: unknown): StackTrace {\n  const stack: StackFrame[] = []\n\n  let stackProperty = tryToGetString(ex, 'stack')\n  const exString = String(ex)\n  if (stackProperty && stackProperty.startsWith(exString)) {\n    stackProperty = stackProperty.slice(exString.length)\n  }\n  if (stackProperty) {\n    stackProperty.split('\\n').forEach((line) => {\n      const stackFrame =\n        parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line)\n      if (stackFrame) {\n        if (!stackFrame.func && stackFrame.line) {\n          stackFrame.func = UNKNOWN_FUNCTION\n        }\n\n        stack.push(stackFrame)\n      }\n    })\n  }\n\n  return {\n    message: tryToGetString(ex, 'message'),\n    name: tryToGetString(ex, 'name'),\n    stack,\n  }\n}\nconst fileUrl =\n  '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)'\nconst filePosition = '(?::(\\\\d+))'\nconst CHROME_LINE_RE = new RegExp(`^\\\\s*at (.*?) ?\\\\(${fileUrl}${filePosition}?${filePosition}?\\\\)?\\\\s*$`, 'i')\n\nconst CHROME_EVAL_RE = new RegExp(`\\\\((\\\\S*)${filePosition}${filePosition}\\\\)`)\n\nfunction parseChromeLine(line: string): StackFrame | undefined {\n  const parts = CHROME_LINE_RE.exec(line)\n\n  if (!parts) {\n    return\n  }\n\n  const isNative = parts[2] && parts[2].indexOf('native') === 0 // start of line\n  const isEval = parts[2] && parts[2].indexOf('eval') === 0 // start of line\n  const submatch = CHROME_EVAL_RE.exec(parts[2])\n\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\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}\n\nconst CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\\\s*at ?${fileUrl}${filePosition}?${filePosition}??\\\\s*$`, 'i')\n\nfunction parseChromeAnonymousLine(line: string): StackFrame | undefined {\n  const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line)\n\n  if (!parts) {\n    return\n  }\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}\n\nconst WINJS_LINE_RE =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i\n\nfunction parseWinLine(line: string): StackFrame | undefined {\n  const parts = WINJS_LINE_RE.exec(line)\n  if (!parts) {\n    return\n  }\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}\n\nconst GECKO_LINE_RE =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i\nconst GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i\n\nfunction parseGeckoLine(line: string): StackFrame | undefined {\n  const parts = GECKO_LINE_RE.exec(line)\n  if (!parts) {\n    return\n  }\n\n  const isEval = parts[3] && parts[3].indexOf(' > eval') > -1\n  const submatch = GECKO_EVAL_RE.exec(parts[3])\n\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\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}\n\nfunction tryToGetString(candidate: unknown, property: string) {\n  if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n    return undefined\n  }\n  const value = (candidate as { [k: string]: unknown })[property]\n  return typeof value === 'string' ? value : undefined\n}\n\nexport function computeStackTraceFromOnErrorMessage(messageObj: unknown, url?: string, line?: number, column?: number) {\n  const stack = [{ url, column, line }]\n  const { name, message } = tryToParseMessage(messageObj)\n  return {\n    name,\n    message,\n    stack,\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nconst ERROR_TYPES_RE =\n  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/\n\nfunction tryToParseMessage(messageObj: unknown) {\n  let name\n  let message\n  if ({}.toString.call(messageObj) === '[object String]') {\n    ;[, name, message] = ERROR_TYPES_RE.exec(messageObj as string)!\n  }\n  return { name, message }\n}\n","import { callMonitored } from '../monitor'\nimport type { StackTrace } from './computeStackTrace'\nimport { computeStackTrace } from './computeStackTrace'\n\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(): string {\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  const internalFramesToSkip = 2\n  const error = new Error()\n  let formattedStack: string\n\n  callMonitored(() => {\n    const stackTrace = computeStackTrace(error)\n    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)\n    formattedStack = toStackTraceString(stackTrace)\n  })\n\n  return formattedStack!\n}\n\nexport function toStackTraceString(stack: StackTrace) {\n  let result = formatErrorMessage(stack)\n  stack.stack.forEach((frame) => {\n    const func = frame.func === '?' ? '<anonymous>' : frame.func\n    const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : ''\n    const line = frame.line ? `:${frame.line}` : ''\n    const column = frame.line && frame.column ? `:${frame.column}` : ''\n    result += `\\n  at ${func!}${args} @ ${frame.url!}${line}${column}`\n  })\n  return result\n}\n\nexport function formatErrorMessage(stack: StackTrace) {\n  return `${stack.name || 'Error'}: ${stack.message!}`\n}\n","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'\nimport { monitor } from './monitor'\nimport { getGlobalObject } from './getGlobalObject'\n\nexport type TimeoutId = ReturnType<typeof globalThis.setTimeout>\n\nexport function setTimeout(callback: () => void, delay?: number): TimeoutId {\n  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay)\n}\n\nexport function clearTimeout(timeoutId: TimeoutId | undefined) {\n  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId)\n}\n\nexport function setInterval(callback: () => void, delay?: number): TimeoutId {\n  return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay)\n}\n\nexport function clearInterval(timeoutId: TimeoutId | undefined) {\n  getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId)\n}\n","export function removeDuplicates<T>(array: T[]) {\n  const set = new Set<T>()\n  array.forEach((item) => set.add(item))\n  return Array.from(set)\n}\n\nexport function removeItem<T>(array: T[], item: T) {\n  const index = array.indexOf(item)\n  if (index >= 0) {\n    array.splice(index, 1)\n  }\n}\n","// Exported only for tests\nexport const enum Browser {\n  CHROMIUM,\n  SAFARI,\n  OTHER,\n}\n\nexport function isChromium() {\n  return detectBrowserCached() === Browser.CHROMIUM\n}\n\nexport function isSafari() {\n  return detectBrowserCached() === Browser.SAFARI\n}\n\nlet browserCache: Browser | undefined\nfunction detectBrowserCached() {\n  return browserCache ?? (browserCache = detectBrowser())\n}\n\n// Exported only for tests\nexport function detectBrowser(browserWindow: Window = window) {\n  const userAgent = browserWindow.navigator.userAgent\n  if ((browserWindow as any).chrome || /HeadlessChrome/.test(userAgent)) {\n    return Browser.CHROMIUM\n  }\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    browserWindow.navigator.vendor?.indexOf('Apple') === 0 ||\n    (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))\n  ) {\n    return Browser.SAFARI\n  }\n\n  return Browser.OTHER\n}\n","export const ONE_KIBI_BYTE = 1024\nexport const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE\n\n// eslint-disable-next-line no-control-regex\nconst HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/\n\nexport function computeBytesCount(candidate: string): number {\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\n  if (window.TextEncoder !== undefined) {\n    return new TextEncoder().encode(candidate).length\n  }\n\n  return new Blob([candidate]).size\n}\n\nexport function concatBuffers(buffers: Uint8Array[]): Uint8Array {\n  const length = buffers.reduce((total, buffer) => total + buffer.length, 0)\n  const result: Uint8Array = new Uint8Array(length)\n  let offset = 0\n  for (const buffer of buffers) {\n    result.set(buffer, offset)\n    offset += buffer.length\n  }\n  return result\n}\n","import type { TimeoutId } from '../timer'\nimport { setTimeout, clearTimeout } from '../timer'\n\n// use lodash API\nexport function throttle<T extends (...args: any[]) => void>(\n  fn: T,\n  wait: number,\n  options?: { leading?: boolean; trailing?: boolean }\n) {\n  const needLeadingExecution = options && options.leading !== undefined ? options.leading : true\n  const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true\n  let inWaitPeriod = false\n  let pendingExecutionWithParameters: Parameters<T> | undefined\n  let pendingTimeoutId: TimeoutId\n\n  return {\n    throttled: (...parameters: Parameters<T>) => {\n      if (inWaitPeriod) {\n        pendingExecutionWithParameters = parameters\n        return\n      }\n      if (needLeadingExecution) {\n        fn(...parameters)\n      } else {\n        pendingExecutionWithParameters = parameters\n      }\n      inWaitPeriod = true\n      pendingTimeoutId = setTimeout(() => {\n        if (needTrailingExecution && pendingExecutionWithParameters) {\n          fn(...pendingExecutionWithParameters)\n        }\n        inWaitPeriod = false\n        pendingExecutionWithParameters = undefined\n      }, wait)\n    },\n    cancel: () => {\n      clearTimeout(pendingTimeoutId)\n      inWaitPeriod = false\n      pendingExecutionWithParameters = undefined\n    },\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() {}\n","/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold: number): boolean {\n  return threshold !== 0 && Math.random() * 100 <= threshold\n}\n\nexport function round(num: number, decimals: 0 | 1 | 2 | 3 | 4) {\n  return +num.toFixed(decimals)\n}\n\nexport function isPercentage(value: unknown) {\n  return isNumber(value) && value >= 0 && value <= 100\n}\n\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number'\n}\n","export function shallowClone<T>(object: T): T & Record<string, never> {\n  return { ...object } as T & Record<string, never>\n}\n\nexport function objectHasValue<T extends { [key: string]: unknown }>(object: T, value: unknown): value is T[keyof T] {\n  return Object.keys(object).some((key) => object[key] === value)\n}\n\nexport function isEmptyObject(object: object) {\n  return Object.keys(object).length === 0\n}\n\nexport function mapValues<A, B>(object: { [key: string]: A }, fn: (arg: A) => B) {\n  const newObject: { [key: string]: B } = {}\n  for (const key of Object.keys(object)) {\n    newObject[key] = fn(object[key])\n  }\n  return newObject\n}\n","export function findLast<T, S extends T>(\n  array: T[],\n  predicate: (item: T, index: number, array: T[]) => item is S\n): S | undefined {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    const item = array[i]\n    if (predicate(item, i, array)) {\n      return item\n    }\n  }\n  return undefined\n}\n\n// Keep the following wrapper functions as it can be mangled and will result in smaller bundle size that using\n// the native Object.values and Object.entries directly\n\nexport function objectValues<T = unknown>(object: { [key: string]: T }) {\n  return Object.values(object)\n}\n\nexport function objectEntries<T = unknown>(object: { [key: string]: T }): Array<[string, T]> {\n  return Object.entries(object)\n}\n","export function isServerError(status: number) {\n  return status >= 500\n}\n\nexport function tryToClone(response: Response): Response | undefined {\n  try {\n    return response.clone()\n  } catch {\n    // clone can throw if the response has already been used by another instrumentation or is disturbed\n    return\n  }\n}\n","import { isNumber, round } from './numberUtils'\n\nexport const ONE_SECOND = 1000\nexport const ONE_MINUTE = 60 * ONE_SECOND\nexport const ONE_HOUR = 60 * ONE_MINUTE\nexport const ONE_DAY = 24 * ONE_HOUR\nexport const ONE_YEAR = 365 * ONE_DAY\n\nexport type Duration = number & { d: 'Duration in ms' }\nexport type ServerDuration = number & { s: 'Duration in ns' }\nexport type TimeStamp = number & { t: 'Epoch time' }\nexport type RelativeTime = number & { r: 'Time relative to navigation start' } & { d: 'Duration in ms' }\nexport type ClocksState = { relative: RelativeTime; timeStamp: TimeStamp }\n\nexport function relativeToClocks(relative: RelativeTime) {\n  return { relative, timeStamp: getCorrectedTimeStamp(relative) }\n}\n\nexport function timeStampToClocks(timeStamp: TimeStamp) {\n  return { relative: getRelativeTime(timeStamp), timeStamp }\n}\n\nfunction getCorrectedTimeStamp(relativeTime: RelativeTime) {\n  const correctedOrigin = (dateNow() - performance.now()) as TimeStamp\n  // apply correction only for positive drift\n  if (correctedOrigin > getNavigationStart()) {\n    return Math.round(addDuration(correctedOrigin, relativeTime)) as TimeStamp\n  }\n  return getTimeStamp(relativeTime)\n}\n\nexport function currentDrift() {\n  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now() as Duration))\n}\n\nexport function toServerDuration(duration: Duration): ServerDuration\nexport function toServerDuration(duration: Duration | undefined): ServerDuration | undefined\nexport function toServerDuration(duration: Duration | undefined) {\n  if (!isNumber(duration)) {\n    return duration\n  }\n  return round(duration * 1e6, 0) as ServerDuration\n}\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}\n\nexport function timeStampNow() {\n  return dateNow() as TimeStamp\n}\n\nexport function relativeNow() {\n  return performance.now() as RelativeTime\n}\n\nexport function clocksNow() {\n  return { relative: relativeNow(), timeStamp: timeStampNow() }\n}\n\nexport function clocksOrigin() {\n  return { relative: 0 as RelativeTime, timeStamp: getNavigationStart() }\n}\n\nexport function elapsed(start: TimeStamp, end: TimeStamp): Duration\nexport function elapsed(start: RelativeTime, end: RelativeTime): Duration\nexport function elapsed(start: number, end: number) {\n  return (end - start) as Duration\n}\n\nexport function addDuration(a: TimeStamp, b: Duration): TimeStamp\nexport function addDuration(a: RelativeTime, b: Duration): RelativeTime\nexport function addDuration(a: Duration, b: Duration): Duration\nexport function addDuration(a: number, b: number) {\n  return a + b\n}\n\n// Get the time since the navigation was started.\nexport function getRelativeTime(timestamp: TimeStamp) {\n  return (timestamp - getNavigationStart()) as RelativeTime\n}\n\nexport function getTimeStamp(relativeTime: RelativeTime) {\n  return Math.round(addDuration(getNavigationStart(), relativeTime)) as TimeStamp\n}\n\nexport function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is RelativeTime {\n  return time < ONE_YEAR\n}\n\n/**\n * Navigation start slightly change on some rare cases\n */\nlet navigationStart: TimeStamp | undefined\n\n/**\n * Notes: this does not use `performance.timeOrigin` because:\n * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,\n * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)\n * - It is not supported in Safari <15\n */\nfunction getNavigationStart() {\n  if (navigationStart === undefined) {\n    navigationStart = performance.timing.navigationStart as TimeStamp\n  }\n  return navigationStart\n}\n","/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value: unknown) {\n  if (value === null) {\n    return 'null'\n  }\n  if (Array.isArray(value)) {\n    return 'array'\n  }\n  return typeof value\n}\n","import { jsonStringify } from '../serialisation/jsonStringify'\n\nexport function normalizeUrl(url: string) {\n  return buildUrl(url, location.href).href\n}\n\nexport function isValidUrl(url: string) {\n  try {\n    return !!buildUrl(url)\n  } catch {\n    return false\n  }\n}\n\nexport function getPathName(url: string) {\n  const pathname = buildUrl(url).pathname\n  return pathname[0] === '/' ? pathname : `/${pathname}`\n}\n\nexport function buildUrl(url: string, base?: string) {\n  const supportedURL = getSupportedUrl()\n  if (supportedURL) {\n    try {\n      return base !== undefined ? new supportedURL(url, base) : new supportedURL(url)\n    } catch (error) {\n      throw new Error(`Failed to construct URL: ${String(error)} ${jsonStringify({ url, base })!}`)\n    }\n  }\n  if (base === undefined && !/:/.test(url)) {\n    throw new Error(`Invalid URL: '${url}'`)\n  }\n  let doc = document\n  const anchorElement = doc.createElement('a')\n  if (base !== undefined) {\n    doc = document.implementation.createHTMLDocument('')\n    const 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}\n\nconst originalURL = URL\nlet isURLSupported: boolean | undefined\nfunction getSupportedUrl(): typeof URL | undefined {\n  if (isURLSupported === undefined) {\n    try {\n      const url = new originalURL('http://test/path')\n      isURLSupported = url.href === 'http://test/path'\n    } catch {\n      isURLSupported = false\n    }\n  }\n  return isURLSupported ? originalURL : undefined\n}\n","import { getGlobalObject } from '../tools/getGlobalObject'\nimport type { DefaultPrivacyLevel } from '../domain/configuration'\n\nexport interface BrowserWindowWithEventBridge extends Window {\n  DatadogEventBridge?: DatadogEventBridge\n}\n\nexport interface DatadogEventBridge {\n  getCapabilities?(): string\n  getPrivacyLevel?(): DefaultPrivacyLevel\n  getAllowedWebViewHosts(): string\n  send(msg: string): void\n}\n\nexport const enum BridgeCapability {\n  RECORDS = 'records',\n}\n\nexport function getEventBridge<T, E>() {\n  const eventBridgeGlobal = getEventBridgeGlobal()\n\n  if (!eventBridgeGlobal) {\n    return\n  }\n\n  return {\n    getCapabilities() {\n      return JSON.parse(eventBridgeGlobal.getCapabilities?.() || '[]') as BridgeCapability[]\n    },\n    getPrivacyLevel() {\n      return eventBridgeGlobal.getPrivacyLevel?.()\n    },\n    getAllowedWebViewHosts() {\n      return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts()) as string[]\n    },\n    send(eventType: T, event: E, viewId?: string) {\n      const view = viewId ? { id: viewId } : undefined\n      eventBridgeGlobal.send(JSON.stringify({ eventType, event, view }))\n    },\n  }\n}\n\nexport function bridgeSupports(capability: BridgeCapability): boolean {\n  const bridge = getEventBridge()\n  return !!bridge && bridge.getCapabilities().includes(capability)\n}\n\nexport function canUseEventBridge(currentHost = getGlobalObject<Window>().location?.hostname): boolean {\n  const bridge = getEventBridge()\n  return (\n    !!bridge &&\n    bridge\n      .getAllowedWebViewHosts()\n      .some((allowedHost) => currentHost === allowedHost || currentHost.endsWith(`.${allowedHost}`))\n  )\n}\n\nfunction getEventBridgeGlobal() {\n  return getGlobalObject<BrowserWindowWithEventBridge>().DatadogEventBridge\n}\n","import type { TrackType } from '../domain/configuration'\nimport { 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 type { RawError } from '../domain/error/error.types'\nimport { ErrorSource } from '../domain/error/error.types'\nimport type { Payload, HttpResponse } from './httpRequest'\n\nexport const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE\nexport const MAX_ONGOING_REQUESTS = 32\nexport const MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE\nexport const MAX_BACKOFF_TIME = ONE_MINUTE\nexport const INITIAL_BACKOFF_TIME = ONE_SECOND\n\nconst enum TransportStatus {\n  UP,\n  FAILURE_DETECTED,\n  DOWN,\n}\n\nconst enum RetryReason {\n  AFTER_SUCCESS,\n  AFTER_RESUME,\n}\n\nexport interface RetryState {\n  transportStatus: TransportStatus\n  currentBackoffTime: number\n  bandwidthMonitor: ReturnType<typeof newBandwidthMonitor>\n  queuedPayloads: ReturnType<typeof newPayloadQueue>\n  queueFullReported: boolean\n}\n\ntype SendStrategy = (payload: Payload, onResponse: (r: HttpResponse) => void) => void\n\nexport function sendWithRetryStrategy(\n  payload: Payload,\n  state: RetryState,\n  sendStrategy: SendStrategy,\n  trackType: TrackType,\n  reportError: (error: RawError) => void\n) {\n  if (\n    state.transportStatus === TransportStatus.UP &&\n    state.queuedPayloads.size() === 0 &&\n    state.bandwidthMonitor.canHandle(payload)\n  ) {\n    send(payload, state, sendStrategy, {\n      onSuccess: () => retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, trackType, reportError),\n      onFailure: () => {\n        state.queuedPayloads.enqueue(payload)\n        scheduleRetry(state, sendStrategy, trackType, reportError)\n      },\n    })\n  } else {\n    state.queuedPayloads.enqueue(payload)\n  }\n}\n\nfunction scheduleRetry(\n  state: RetryState,\n  sendStrategy: SendStrategy,\n  trackType: TrackType,\n  reportError: (error: RawError) => void\n) {\n  if (state.transportStatus !== TransportStatus.DOWN) {\n    return\n  }\n  setTimeout(() => {\n    const payload = state.queuedPayloads.first()\n    send(payload, state, sendStrategy, {\n      onSuccess: () => {\n        state.queuedPayloads.dequeue()\n        state.currentBackoffTime = INITIAL_BACKOFF_TIME\n        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, trackType, reportError)\n      },\n      onFailure: () => {\n        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)\n        scheduleRetry(state, sendStrategy, trackType, reportError)\n      },\n    })\n  }, state.currentBackoffTime)\n}\n\nfunction send(\n  payload: Payload,\n  state: RetryState,\n  sendStrategy: SendStrategy,\n  { onSuccess, onFailure }: { onSuccess: () => void; onFailure: () => void }\n) {\n  state.bandwidthMonitor.add(payload)\n  sendStrategy(payload, (response) => {\n    state.bandwidthMonitor.remove(payload)\n    if (!shouldRetryRequest(response)) {\n      state.transportStatus = TransportStatus.UP\n      onSuccess()\n    } else {\n      // do not consider transport down if another ongoing request could succeed\n      state.transportStatus =\n        state.bandwidthMonitor.ongoingRequestCount > 0 ? TransportStatus.FAILURE_DETECTED : TransportStatus.DOWN\n      payload.retry = {\n        count: payload.retry ? payload.retry.count + 1 : 1,\n        lastFailureStatus: response.status,\n      }\n      onFailure()\n    }\n  })\n}\n\nfunction retryQueuedPayloads(\n  reason: RetryReason,\n  state: RetryState,\n  sendStrategy: SendStrategy,\n  trackType: TrackType,\n  reportError: (error: RawError) => void\n) {\n  if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {\n    reportError({\n      message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,\n      source: ErrorSource.AGENT,\n      startClocks: clocksNow(),\n    })\n    state.queueFullReported = true\n  }\n  const previousQueue = state.queuedPayloads\n  state.queuedPayloads = newPayloadQueue()\n  while (previousQueue.size() > 0) {\n    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, trackType, reportError)\n  }\n}\n\nfunction shouldRetryRequest(response: HttpResponse) {\n  return (\n    response.type !== 'opaque' &&\n    ((response.status === 0 && !navigator.onLine) ||\n      response.status === 408 ||\n      response.status === 429 ||\n      isServerError(response.status))\n  )\n}\n\nexport function newRetryState(): RetryState {\n  return {\n    transportStatus: TransportStatus.UP,\n    currentBackoffTime: INITIAL_BACKOFF_TIME,\n    bandwidthMonitor: newBandwidthMonitor(),\n    queuedPayloads: newPayloadQueue(),\n    queueFullReported: false,\n  }\n}\n\nfunction newPayloadQueue() {\n  const queue: Payload[] = []\n  return {\n    bytesCount: 0,\n    enqueue(payload: Payload) {\n      if (this.isFull()) {\n        return\n      }\n      queue.push(payload)\n      this.bytesCount += payload.bytesCount\n    },\n    first() {\n      return queue[0]\n    },\n    dequeue() {\n      const payload = queue.shift()\n      if (payload) {\n        this.bytesCount -= payload.bytesCount\n      }\n      return payload\n    },\n    size() {\n      return queue.length\n    },\n    isFull() {\n      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT\n    },\n  }\n}\n\nfunction newBandwidthMonitor() {\n  return {\n    ongoingRequestCount: 0,\n    ongoingByteCount: 0,\n    canHandle(payload: Payload) {\n      return (\n        this.ongoingRequestCount === 0 ||\n        (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n          this.ongoingRequestCount < MAX_ONGOING_REQUESTS)\n      )\n    },\n    add(payload: Payload) {\n      this.ongoingRequestCount += 1\n      this.ongoingByteCount += payload.bytesCount\n    },\n    remove(payload: Payload) {\n      this.ongoingRequestCount -= 1\n      this.ongoingByteCount -= payload.bytesCount\n    },\n  }\n}\n","import type { EndpointBuilder } from '../domain/configuration'\nimport { addTelemetryError } from '../domain/telemetry'\nimport type { Context } from '../tools/serialisation/context'\nimport { monitor } from '../tools/monitor'\nimport { addEventListener } from '../browser/addEventListener'\nimport type { RawError } from '../domain/error/error.types'\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'\n\n/**\n * Use POST request without content type to:\n * - avoid CORS preflight requests\n * - allow usage of sendBeacon\n *\n * multiple elements are sent separated by \\n in order\n * to be parsed correctly without content type header\n */\n\nexport type HttpRequest = ReturnType<typeof createHttpRequest>\n\nexport interface HttpResponse extends Context {\n  status: number\n  type?: ResponseType\n}\n\nexport interface Payload {\n  data: string | FormData | Blob\n  bytesCount: number\n  retry?: RetryInfo\n  encoding?: 'deflate'\n}\n\nexport interface RetryInfo {\n  count: number\n  lastFailureStatus: number\n}\n\nexport function createHttpRequest(\n  endpointBuilder: EndpointBuilder,\n  bytesLimit: number,\n  reportError: (error: RawError) => void\n) {\n  const retryState = newRetryState()\n  const sendStrategyForRetry = (payload: Payload, onResponse: (r: HttpResponse) => void) =>\n    fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse)\n\n  return {\n    send: (payload: 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: (payload: Payload) => {\n      sendBeaconStrategy(endpointBuilder, bytesLimit, payload)\n    },\n  }\n}\n\nfunction sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {\n  const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit\n  if (canUseBeacon) {\n    try {\n      const beaconUrl = endpointBuilder.build('beacon', payload)\n      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)\n\n      if (isQueued) {\n        return\n      }\n    } catch (e) {\n      reportBeaconError(e)\n    }\n  }\n\n  const xhrUrl = endpointBuilder.build('xhr', payload)\n  sendXHR(xhrUrl, payload.data)\n}\n\nlet hasReportedBeaconError = false\n\nfunction reportBeaconError(e: unknown) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true\n    addTelemetryError(e)\n  }\n}\n\nexport function fetchKeepAliveStrategy(\n  endpointBuilder: EndpointBuilder,\n  bytesLimit: number,\n  payload: Payload,\n  onResponse?: (r: HttpResponse) => void\n) {\n  const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit\n  if (canUseKeepAlive) {\n    const fetchUrl = endpointBuilder.build('fetch', payload)\n    fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(\n      monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })),\n      monitor(() => {\n        const xhrUrl = endpointBuilder.build('xhr', payload)\n        // failed to queue the request\n        sendXHR(xhrUrl, payload.data, onResponse)\n      })\n    )\n  } else {\n    const xhrUrl = endpointBuilder.build('xhr', payload)\n    sendXHR(xhrUrl, payload.data, onResponse)\n  }\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  } catch {\n    return false\n  }\n}\n\nexport function sendXHR(url: string, data: Payload['data'], onResponse?: (r: HttpResponse) => void) {\n  const request = new XMLHttpRequest()\n  request.open('POST', url, true)\n  if (data instanceof Blob) {\n    // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header\n    // automatically, so the intake request ends up being rejected with an HTTP status 415\n    // Defining the header manually fixes this issue.\n    request.setRequestHeader('Content-Type', data.type)\n  }\n  addEventListener(\n    // allow untrusted event to acount for synthetic event dispatched by third party xhr wrapper\n    { allowUntrustedEvents: true },\n    request,\n    'loadend',\n    () => {\n      onResponse?.({ status: request.status })\n    },\n    {\n      // prevent multiple onResponse callbacks\n      // if the xhr instance is reused by a third party\n      once: true,\n    }\n  )\n  request.send(data)\n}\n","import { ONE_KIBI_BYTE, computeBytesCount } from '../../tools/utils/byteUtils'\nimport { throttle } from '../../tools/utils/functionUtils'\nimport type { Context } from '../../tools/serialisation/context'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../../tools/display'\nimport { isEmptyObject } from '../../tools/utils/objectUtils'\nimport type { CustomerDataType } from './contextConstants'\n\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 const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE\n\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 const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE\n\nexport const BYTES_COMPUTATION_THROTTLING_DELAY = 200\n\nexport type CustomerDataTracker = ReturnType<typeof createCustomerDataTracker>\nexport type CustomerDataTrackerManager = ReturnType<typeof createCustomerDataTrackerManager>\n\nexport const enum CustomerDataCompressionStatus {\n  Unknown,\n  Enabled,\n  Disabled,\n}\n\nexport function createCustomerDataTrackerManager(\n  compressionStatus: CustomerDataCompressionStatus = CustomerDataCompressionStatus.Disabled\n) {\n  const customerDataTrackers = new Map<CustomerDataType, CustomerDataTracker>()\n\n  let alreadyWarned = false\n  function checkCustomerDataLimit(initialBytesCount = 0) {\n    if (alreadyWarned || compressionStatus === CustomerDataCompressionStatus.Unknown) {\n      return\n    }\n\n    const bytesCountLimit =\n      compressionStatus === CustomerDataCompressionStatus.Disabled\n        ? CUSTOMER_DATA_BYTES_LIMIT\n        : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT\n\n    let bytesCount = initialBytesCount\n    customerDataTrackers.forEach((tracker) => {\n      bytesCount += tracker.getBytesCount()\n    })\n\n    if (bytesCount > bytesCountLimit) {\n      displayCustomerDataLimitReachedWarning(bytesCountLimit)\n      alreadyWarned = true\n    }\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: () => {\n      const tracker = createCustomerDataTracker(() => checkCustomerDataLimit(tracker.getBytesCount()))\n      return tracker\n    },\n\n    /**\n     * Creates a tracker if it doesn't exist, and returns it.\n     */\n    getOrCreateTracker: (type: CustomerDataType) => {\n      if (!customerDataTrackers.has(type)) {\n        customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit))\n      }\n      return customerDataTrackers.get(type)!\n    },\n\n    setCompressionStatus: (newCompressionStatus: CustomerDataCompressionStatus) => {\n      if (compressionStatus === CustomerDataCompressionStatus.Unknown) {\n        compressionStatus = newCompressionStatus\n        checkCustomerDataLimit()\n      }\n    },\n\n    getCompressionStatus: () => compressionStatus,\n\n    stop: () => {\n      customerDataTrackers.forEach((tracker) => tracker.stop())\n      customerDataTrackers.clear()\n    },\n  }\n}\n\nexport function createCustomerDataTracker(checkCustomerDataLimit: () => void) {\n  let bytesCountCache = 0\n\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  const { throttled: computeBytesCountThrottled, cancel: cancelComputeBytesCount } = throttle((context: Context) => {\n    bytesCountCache = computeBytesCount(jsonStringify(context)!)\n    checkCustomerDataLimit()\n  }, BYTES_COMPUTATION_THROTTLING_DELAY)\n\n  const resetBytesCount = () => {\n    cancelComputeBytesCount()\n    bytesCountCache = 0\n  }\n\n  return {\n    updateCustomerData: (context: Context) => {\n      if (isEmptyObject(context)) {\n        resetBytesCount()\n      } else {\n        computeBytesCountThrottled(context)\n      }\n    },\n    resetCustomerData: resetBytesCount,\n    getBytesCount: () => bytesCountCache,\n    stop: () => {\n      cancelComputeBytesCount()\n    },\n  }\n}\n\nfunction displayCustomerDataLimitReachedWarning(bytesCountLimit: number) {\n  display.warn(\n    `Customer data exceeds the recommended ${\n      bytesCountLimit / ONE_KIBI_BYTE\n    }KiB threshold. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#customer-data-exceeds-the-recommended-threshold-warning`\n  )\n}\n","import { deepClone } from '../../tools/mergeInto'\nimport { getType } from '../../tools/utils/typeUtils'\nimport { sanitize } from '../../tools/serialisation/sanitize'\nimport type { Context } from '../../tools/serialisation/context'\nimport { Observable } from '../../tools/observable'\nimport type { CustomerDataTracker } from './customerDataTracker'\n\nexport type ContextManager = ReturnType<typeof createContextManager>\n\nexport function createContextManager(customerDataTracker?: CustomerDataTracker) {\n  let context: Context = {}\n  const changeObservable = new Observable<void>()\n\n  const contextManager = {\n    getContext: () => deepClone(context),\n\n    setContext: (newContext: Context) => {\n      if (getType(newContext) === 'object') {\n        context = sanitize(newContext)\n        customerDataTracker?.updateCustomerData(context)\n      } else {\n        contextManager.clearContext()\n      }\n      changeObservable.notify()\n    },\n\n    setContextProperty: (key: string, property: any) => {\n      context[key] = sanitize(property)\n      customerDataTracker?.updateCustomerData(context)\n      changeObservable.notify()\n    },\n\n    removeContextProperty: (key: string) => {\n      delete context[key]\n      customerDataTracker?.updateCustomerData(context)\n      changeObservable.notify()\n    },\n\n    clearContext: () => {\n      context = {}\n      customerDataTracker?.resetCustomerData()\n      changeObservable.notify()\n    },\n\n    changeObservable,\n  }\n  return contextManager\n}\n","import { Observable } from '../tools/observable'\n\nexport const TrackingConsent = {\n  GRANTED: 'granted',\n  NOT_GRANTED: 'not-granted',\n} as const\nexport type TrackingConsent = (typeof TrackingConsent)[keyof typeof TrackingConsent]\n\nexport interface TrackingConsentState {\n  tryToInit: (trackingConsent: TrackingConsent) => void\n  update: (trackingConsent: TrackingConsent) => void\n  isGranted: () => boolean\n  observable: Observable<void>\n}\n\nexport function createTrackingConsentState(currentConsent?: TrackingConsent): TrackingConsentState {\n  const observable = new Observable<void>()\n\n  return {\n    tryToInit(trackingConsent: TrackingConsent) {\n      if (!currentConsent) {\n        currentConsent = trackingConsent\n      }\n    },\n    update(trackingConsent: TrackingConsent) {\n      currentConsent = trackingConsent\n      observable.notify()\n    },\n    isGranted() {\n      return currentConsent === TrackingConsent.GRANTED\n    },\n    observable,\n  }\n}\n","import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'\nimport type { Context } from '../../tools/serialisation/context'\nimport type { Configuration } from '../configuration'\nimport { combine } from '../../tools/mergeInto'\nimport type { ContextManager } from './contextManager'\nimport type { CustomerDataType } from './contextConstants'\n\nconst CONTEXT_STORE_KEY_PREFIX = '_dd_c'\n\nconst storageListeners: Array<{ stop: () => void }> = []\n\nexport function storeContextManager(\n  configuration: Configuration,\n  contextManager: ContextManager,\n  productKey: string,\n  customerDataType: CustomerDataType\n) {\n  const storageKey = buildStorageKey(productKey, customerDataType)\n\n  storageListeners.push(\n    addEventListener(configuration, window, DOM_EVENT.STORAGE, ({ key }) => {\n      if (storageKey === key) {\n        synchronizeWithStorage()\n      }\n    })\n  )\n  contextManager.changeObservable.subscribe(dumpToStorage)\n\n  contextManager.setContext(combine(getFromStorage(), contextManager.getContext()))\n\n  function synchronizeWithStorage() {\n    contextManager.setContext(getFromStorage())\n  }\n\n  function dumpToStorage() {\n    localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()))\n  }\n\n  function getFromStorage() {\n    const rawContext = localStorage.getItem(storageKey)\n    return rawContext !== null ? (JSON.parse(rawContext) as Context) : {}\n  }\n}\n\nexport function buildStorageKey(productKey: string, customerDataType: CustomerDataType) {\n  return `${CONTEXT_STORE_KEY_PREFIX}_${productKey}_${customerDataType}`\n}\n\nexport function removeStorageListeners() {\n  storageListeners.map((listener) => listener.stop())\n}\n","import { computeBytesCount } from './utils/byteUtils'\n\nexport interface Encoder<Output extends string | Uint8Array = string | Uint8Array> {\n  /**\n   * Whether this encoder might call the provided callbacks asynchronously\n   */\n  isAsync: boolean\n\n  /**\n   * Whether some data has been written since the last finish() or finishSync() call\n   */\n  isEmpty: boolean\n\n  /**\n   * Write a string to be encoded.\n   *\n   * This operation can be synchronous or asynchronous depending on the encoder implementation.\n   *\n   * If specified, the callback will be invoked when the operation finishes, unless the operation is\n   * asynchronous and finish() or finishSync() is called in the meantime.\n   */\n  write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void\n\n  /**\n   * Waits for pending data to be encoded and resets the encoder state.\n   *\n   * This operation can be synchronous or asynchronous depending on the encoder implementation.\n   *\n   * The callback will be invoked when the operation finishes, unless the operation is asynchronous\n   * and another call to finish() or finishSync() occurs in the meantime.\n   */\n  finish(callback: (result: EncoderResult<Output>) => void): void\n\n  /**\n   * Resets the encoder state then returns the encoded data and any potential pending data directly,\n   * discarding all pending write operations and finish() callbacks.\n   */\n  finishSync(): EncoderResult<Output> & { pendingData: string }\n\n  /**\n   * Returns a rough estimation of the bytes count if the data was encoded.\n   */\n  estimateEncodedBytesCount(data: string): number\n}\n\nexport interface EncoderResult<Output extends string | Uint8Array = string | Uint8Array> {\n  output: Output\n  outputBytesCount: number\n\n  /**\n   * An encoding type supported by HTTP Content-Encoding, if applicable.\n   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives\n   */\n  encoding?: 'deflate'\n\n  /**\n   * Total bytes count of the input strings encoded to UTF-8.\n   */\n  rawBytesCount: number\n}\n\nexport function createIdentityEncoder(): Encoder<string> {\n  let output = ''\n  let outputBytesCount = 0\n\n  return {\n    isAsync: false,\n\n    get isEmpty() {\n      return !output\n    },\n\n    write(data, callback) {\n      const additionalEncodedBytesCount = computeBytesCount(data)\n      outputBytesCount += additionalEncodedBytesCount\n      output += data\n      if (callback) {\n        callback(additionalEncodedBytesCount)\n      }\n    },\n\n    finish(callback) {\n      callback(this.finishSync())\n    },\n\n    finishSync() {\n      const result = {\n        output,\n        outputBytesCount,\n        rawBytesCount: outputBytesCount,\n        pendingData: '',\n      }\n      output = ''\n      outputBytesCount = 0\n      return result\n    },\n\n    estimateEncodedBytesCount(data) {\n      return data.length\n    },\n  }\n}\n","import type { Context } from '../../tools/serialisation/context'\nimport { display } from '../../tools/display'\nimport { getType } from '../../tools/utils/typeUtils'\nimport type { User } from './user.types'\n\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: Context): Context {\n  // We shallow clone only to prevent mutation of user data.\n  const user = { ...newUser }\n  const keys = ['id', 'name', 'email']\n  keys.forEach((key) => {\n    if (key in user) {\n      /* eslint-disable @typescript-eslint/no-base-to-string */\n      user[key] = String(user[key])\n    }\n  })\n  return user\n}\n\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser: User): boolean {\n  const isValid = getType(newUser) === 'object'\n  if (!isValid) {\n    display.error('Unsupported user:', newUser)\n  }\n  return isValid\n}\n\nexport function generateAnonymousId() {\n  return Math.floor(Math.random() * Math.pow(36, 10))\n    .toString(36)\n    .padStart(10, '0')\n}\n","import type { InitConfiguration } from '../domain/configuration'\nimport { display } from '../tools/display'\n\nexport function displayAlreadyInitializedError(sdkName: 'DD_RUM' | 'DD_LOGS', initConfiguration: InitConfiguration) {\n  if (!initConfiguration.silentMultipleInit) {\n    display.error(`${sdkName} is already initialized.`)\n  }\n}\n","/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder?: string): string {\n  return placeholder\n    ? // eslint-disable-next-line  no-bitwise\n      (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)\n    : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID)\n}\n\nconst COMMA_SEPARATED_KEY_VALUE = /([\\w-]+)\\s*=\\s*([^;]+)/g\n\nexport function findCommaSeparatedValue(rawString: string, name: string): string | undefined {\n  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0\n  while (true) {\n    const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString)\n    if (match) {\n      if (match[1] === name) {\n        return match[2]\n      }\n    } else {\n      break\n    }\n  }\n}\n\nexport function findCommaSeparatedValues(rawString: string): Map<string, string> {\n  const result = new Map<string, string>()\n  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0\n  while (true) {\n    const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString)\n    if (match) {\n      result.set(match[1], match[2])\n    } else {\n      break\n    }\n  }\n  return result\n}\n\nexport function safeTruncate(candidate: string, length: number, suffix = '') {\n  const lastChar = candidate.charCodeAt(length - 1)\n  const isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff\n  const correctedLength = isLastCharSurrogatePair ? length + 1 : length\n\n  if (candidate.length <= correctedLength) {\n    return candidate\n  }\n\n  return `${candidate.slice(0, correctedLength)}${suffix}`\n}\n","import type { ClocksState, Duration, Context } from '@datadog/browser-core'\nimport { clocksNow, combine, elapsed, generateUUID, toServerDuration } from '@datadog/browser-core'\nimport type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { RawRumVitalEvent } from '../../rawRumEvent.types'\nimport { RumEventType, VitalType } from '../../rawRumEvent.types'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport { PageState } from '../contexts/pageStateHistory'\n\nexport interface DurationVitalOptions {\n  context?: Context\n  description?: string\n}\n\nexport interface DurationVitalReference {\n  __dd_vital_reference: true\n}\n\nexport interface DurationVitalStart {\n  name: string\n  startClocks: ClocksState\n  context?: Context\n  description?: string\n}\n\nexport interface DurationVital {\n  name: string\n  type: VitalType.DURATION\n  startClocks: ClocksState\n  duration: Duration\n  description?: string\n  context?: Context\n}\n\nexport interface CustomVitalsState {\n  vitalsByName: Map<string, DurationVitalStart>\n  vitalsByReference: WeakMap<DurationVitalReference, DurationVitalStart>\n}\n\nexport function createCustomVitalsState() {\n  const vitalsByName = new Map<string, DurationVitalStart>()\n  const vitalsByReference = new WeakMap<DurationVitalReference, DurationVitalStart>()\n  return { vitalsByName, vitalsByReference }\n}\n\nexport function startVitalCollection(\n  lifeCycle: LifeCycle,\n  pageStateHistory: PageStateHistory,\n  customVitalsState: CustomVitalsState\n) {\n  function isValid(vital: DurationVital) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(PageState.FROZEN, vital.startClocks.relative, vital.duration)\n  }\n\n  function addDurationVital(vital: DurationVital) {\n    if (isValid(vital)) {\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processVital(vital, true))\n    }\n  }\n\n  return {\n    addDurationVital,\n    startDurationVital: (name: string, options: DurationVitalOptions = {}) =>\n      startDurationVital(customVitalsState, name, options),\n    stopDurationVital: (nameOrRef: string | DurationVitalReference, options: DurationVitalOptions = {}) => {\n      stopDurationVital(addDurationVital, customVitalsState, nameOrRef, options)\n    },\n  }\n}\n\nexport function startDurationVital(\n  { vitalsByName, vitalsByReference }: CustomVitalsState,\n  name: string,\n  options: DurationVitalOptions = {}\n) {\n  const vital = {\n    name,\n    startClocks: clocksNow(),\n    context: options.context,\n    description: options.description,\n  }\n\n  // To avoid leaking implementation details of the vital, we return a reference to it.\n  const reference: DurationVitalReference = { __dd_vital_reference: true }\n\n  vitalsByName.set(name, vital)\n\n  // To avoid memory leaks caused by the creation of numerous references (e.g., from improper useEffect implementations), we use a WeakMap.\n  vitalsByReference.set(reference, vital)\n\n  return reference\n}\n\nexport function stopDurationVital(\n  stopCallback: (vital: DurationVital) => void,\n  { vitalsByName, vitalsByReference }: CustomVitalsState,\n  nameOrRef: string | DurationVitalReference,\n  options: DurationVitalOptions = {}\n) {\n  const vitalStart = typeof nameOrRef === 'string' ? vitalsByName.get(nameOrRef) : vitalsByReference.get(nameOrRef)\n\n  if (!vitalStart) {\n    return\n  }\n\n  stopCallback(buildDurationVital(vitalStart, vitalStart.startClocks, options, clocksNow()))\n\n  if (typeof nameOrRef === 'string') {\n    vitalsByName.delete(nameOrRef)\n  } else {\n    vitalsByReference.delete(nameOrRef)\n  }\n}\n\nfunction buildDurationVital(\n  vitalStart: DurationVitalStart,\n  startClocks: ClocksState,\n  stopOptions: DurationVitalOptions,\n  stopClocks: ClocksState\n): DurationVital {\n  return {\n    name: vitalStart.name,\n    type: VitalType.DURATION,\n    startClocks,\n    duration: elapsed(startClocks.timeStamp, stopClocks.timeStamp),\n    context: combine(vitalStart.context, stopOptions.context),\n    description: stopOptions.description ?? vitalStart.description,\n  }\n}\n\nfunction processVital(vital: DurationVital, valueComputedBySdk: boolean): RawRumEventCollectedData<RawRumVitalEvent> {\n  const rawRumEvent: RawRumVitalEvent = {\n    date: vital.startClocks.timeStamp,\n    vital: {\n      id: generateUUID(),\n      type: vital.type,\n      name: vital.name,\n      duration: toServerDuration(vital.duration),\n      description: vital.description,\n    },\n    type: RumEventType.VITAL,\n  }\n\n  if (valueComputedBySdk) {\n    rawRumEvent._dd = {\n      vital: {\n        computed_value: true,\n      },\n    }\n  }\n\n  return {\n    rawRumEvent,\n    startTime: vital.startClocks.relative,\n    customerContext: vital.context,\n    domainContext: {},\n  }\n}\n","import type { RumPublicApi, Strategy } from '../boot/rumPublicApi'\nimport type { RumInitConfiguration } from './configuration'\n\nexport interface RumPlugin {\n  name: string\n  getConfigurationTelemetry?(): Record<string, unknown>\n  onInit?(options: { initConfiguration: RumInitConfiguration; publicApi: RumPublicApi }): void\n  onRumStart?(options: { strategy: Strategy }): void\n}\n\ntype MethodNames = 'onInit' | 'onRumStart'\ntype MethodParameter<MethodName extends MethodNames> = Parameters<NonNullable<RumPlugin[MethodName]>>[0]\n\nexport function callPluginsMethod<MethodName extends MethodNames>(\n  plugins: RumPlugin[] | undefined,\n  methodName: MethodName,\n  parameter: MethodParameter<MethodName>\n): void\nexport function callPluginsMethod<MethodName extends MethodNames>(\n  plugins: RumPlugin[] | undefined,\n  methodName: MethodName,\n  parameter: any\n) {\n  if (!plugins) {\n    return\n  }\n  for (const plugin of plugins) {\n    const method = plugin[methodName]\n    if (method) {\n      method(parameter)\n    }\n  }\n}\n","import type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { monitor } from '../tools/monitor'\nimport { Observable } from '../tools/observable'\nimport type { ClocksState } from '../tools/utils/timeUtils'\nimport { clocksNow } from '../tools/utils/timeUtils'\nimport { normalizeUrl } from '../tools/utils/urlPolyfill'\n\ninterface FetchContextBase {\n  method: string\n  startClocks: ClocksState\n  input: unknown\n  init?: RequestInit\n  url: string\n  handlingStack?: string\n}\n\nexport interface FetchStartContext extends FetchContextBase {\n  state: 'start'\n}\n\nexport interface FetchResolveContext extends FetchContextBase {\n  state: 'resolve'\n  status: number\n  response?: Response\n  responseType?: string\n  isAborted: boolean\n  error?: Error\n}\n\nexport type FetchContext = FetchStartContext | FetchResolveContext\n\nlet fetchObservable: Observable<FetchContext> | undefined\n\nexport function initFetchObservable() {\n  if (!fetchObservable) {\n    fetchObservable = createFetchObservable()\n  }\n  return fetchObservable\n}\n\nexport function resetFetchObservable() {\n  fetchObservable = undefined\n}\n\nfunction createFetchObservable() {\n  return new Observable<FetchContext>((observable) => {\n    if (!window.fetch) {\n      return\n    }\n\n    const { stop } = instrumentMethod(window, 'fetch', (call) => beforeSend(call, observable), {\n      computeHandlingStack: true,\n    })\n\n    return stop\n  })\n}\n\nfunction beforeSend(\n  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<Window, 'fetch'>,\n  observable: Observable<FetchContext>\n) {\n  const [input, init] = parameters\n  let methodFromParams = init && init.method\n\n  if (methodFromParams === undefined && input instanceof Request) {\n    methodFromParams = input.method\n  }\n\n  const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET'\n  const url = input instanceof Request ? input.url : normalizeUrl(String(input))\n  const startClocks = clocksNow()\n\n  const context: FetchStartContext = {\n    state: 'start',\n    init,\n    input,\n    method,\n    startClocks,\n    url,\n    handlingStack,\n  }\n\n  observable.notify(context)\n\n  // Those properties can be changed by observable subscribers\n  parameters[0] = context.input as RequestInfo | URL\n  parameters[1] = context.init\n\n  onPostCall((responsePromise) => afterSend(observable, responsePromise, context))\n}\n\nfunction afterSend(\n  observable: Observable<FetchContext>,\n  responsePromise: Promise<Response>,\n  startContext: FetchStartContext\n) {\n  const context = startContext as unknown as FetchResolveContext\n\n  function reportFetch(partialContext: Partial<FetchResolveContext>) {\n    context.state = 'resolve'\n    Object.assign(context, partialContext)\n    observable.notify(context)\n  }\n\n  responsePromise.then(\n    monitor((response) => {\n      reportFetch({\n        response,\n        responseType: response.type,\n        status: response.status,\n        isAborted: false,\n      })\n    }),\n    monitor((error: Error) => {\n      reportFetch({\n        status: 0,\n        isAborted:\n          context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),\n        error,\n      })\n    })\n  )\n}\n","import { display } from '../tools/display'\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'\nimport { findCommaSeparatedValue, findCommaSeparatedValues, generateUUID } from '../tools/utils/stringUtils'\n\nexport interface CookieOptions {\n  secure?: boolean\n  crossSite?: boolean\n  partitioned?: boolean\n  domain?: string\n}\n\nexport function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {\n  const date = new Date()\n  date.setTime(date.getTime() + expireDelay)\n  const expires = `expires=${date.toUTCString()}`\n  const sameSite = options && options.crossSite ? 'none' : 'strict'\n  const domain = options && options.domain ? `;domain=${options.domain}` : ''\n  const secure = options && options.secure ? ';secure' : ''\n  const partitioned = options && options.partitioned ? ';partitioned' : ''\n  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`\n}\n\nexport function getCookie(name: string) {\n  return findCommaSeparatedValue(document.cookie, name)\n}\n\nlet initCookieParsed: Map<string, string> | undefined\n\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: string) {\n  if (!initCookieParsed) {\n    initCookieParsed = findCommaSeparatedValues(document.cookie)\n  }\n  return initCookieParsed.get(name)\n}\n\nexport function resetInitCookies() {\n  initCookieParsed = undefined\n}\n\nexport function deleteCookie(name: string, options?: CookieOptions) {\n  setCookie(name, '', 0, options)\n}\n\nexport function areCookiesAuthorized(options: CookieOptions): boolean {\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    const testCookieName = `dd_cookie_test_${generateUUID()}`\n    const testCookieValue = 'test'\n    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options)\n    const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue\n    deleteCookie(testCookieName, options)\n    return isCookieCorrectlySet\n  } catch (error) {\n    display.error(error)\n    return false\n  }\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 */\nlet getCurrentSiteCache: string | undefined\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    const testCookieName = `dd_site_test_${generateUUID()}`\n    const testCookieValue = 'test'\n\n    const domainLevels = window.location.hostname.split('.')\n    let candidateDomain = domainLevels.pop()!\n    while (domainLevels.length && !getCookie(testCookieName)) {\n      candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`\n      setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })\n    }\n    deleteCookie(testCookieName, { domain: candidateDomain })\n    getCurrentSiteCache = candidateDomain\n  }\n  return getCurrentSiteCache\n}\n","import { getInitCookie } from '../../browser/cookie'\n\nexport const SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id'\nexport const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id'\nexport const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum'\n\nexport interface BrowserWindow extends Window {\n  _DATADOG_SYNTHETICS_PUBLIC_ID?: unknown\n  _DATADOG_SYNTHETICS_RESULT_ID?: unknown\n  _DATADOG_SYNTHETICS_INJECTS_RUM?: unknown\n}\n\nexport function willSyntheticsInjectRum(): boolean {\n  return Boolean(\n    (window as BrowserWindow)._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)\n  )\n}\n\nexport function getSyntheticsTestId(): string | undefined {\n  const value = (window as BrowserWindow)._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)\n  return typeof value === 'string' ? value : undefined\n}\n\nexport function getSyntheticsResultId(): string | undefined {\n  const value =\n    (window as BrowserWindow)._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)\n  return typeof value === 'string' ? value : undefined\n}\n","import type { CookieOptions } from '../../../browser/cookie'\nimport type { SessionPersistence } from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\n\nexport const SESSION_STORE_KEY = '_dd_s'\n\nexport type SessionStoreStrategyType =\n  | { type: typeof SessionPersistence.COOKIE; cookieOptions: CookieOptions }\n  | { type: typeof SessionPersistence.LOCAL_STORAGE }\n\nexport interface SessionStoreStrategy {\n  isLockEnabled: boolean\n  persistSession: (session: SessionState) => void\n  retrieveSession: () => SessionState\n  expireSession: (previousSessionState: SessionState) => void\n}\n","import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils'\n\nexport const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR\nexport const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE\nexport const SESSION_COOKIE_EXPIRATION_DELAY = ONE_YEAR\n\nexport const SessionPersistence = {\n  COOKIE: 'cookie',\n  LOCAL_STORAGE: 'local-storage',\n} as const\nexport type SessionPersistence = (typeof SessionPersistence)[keyof typeof SessionPersistence]\n","export const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/\nexport const SESSION_ENTRY_SEPARATOR = '&'\n\nexport function isValidSessionString(sessionString: string | undefined | null): sessionString is string {\n  return (\n    !!sessionString &&\n    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))\n  )\n}\n","import { isEmptyObject } from '../../tools/utils/objectUtils'\nimport { objectEntries } from '../../tools/utils/polyfills'\nimport { dateNow } from '../../tools/utils/timeUtils'\nimport { generateAnonymousId } from '../user'\nimport type { Configuration } from '../configuration'\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'\nimport { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'\nexport const EXPIRED = '1'\n\nexport interface SessionState {\n  id?: string\n  created?: string\n  expire?: string\n  isExpired?: typeof EXPIRED\n\n  [key: string]: string | undefined\n}\n\nexport function getExpiredSessionState(\n  previousSessionState: SessionState | undefined,\n  configuration: Configuration\n): SessionState {\n  const expiredSessionState: SessionState = {\n    isExpired: EXPIRED,\n  }\n  if (configuration.trackAnonymousUser) {\n    if (previousSessionState?.anonymousId) {\n      expiredSessionState.anonymousId = previousSessionState?.anonymousId\n    } else {\n      expiredSessionState.anonymousId = generateAnonymousId()\n    }\n  }\n  return expiredSessionState\n}\n\nexport function isSessionInNotStartedState(session: SessionState) {\n  return isEmptyObject(session)\n}\n\nexport function isSessionStarted(session: SessionState) {\n  return !isSessionInNotStartedState(session)\n}\n\nexport function isSessionInExpiredState(session: SessionState) {\n  return session.isExpired !== undefined || !isActiveSession(session)\n}\n\n// An active session is a session in either `Tracked` or `NotTracked` state\nfunction isActiveSession(sessionState: 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 (\n    (sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&\n    (sessionState.expire === undefined || dateNow() < Number(sessionState.expire))\n  )\n}\n\nexport function expandSessionState(session: SessionState) {\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)\n}\n\nexport function toSessionString(session: SessionState) {\n  return (\n    objectEntries(session)\n      // we use `aid` as a key for anonymousId\n      .map(([key, value]) => (key === 'anonymousId' ? `aid=${value}` : `${key}=${value}`))\n      .join(SESSION_ENTRY_SEPARATOR)\n  )\n}\n\nexport function toSessionState(sessionString: string | undefined | null) {\n  const session: SessionState = {}\n  if (isValidSessionString(sessionString)) {\n    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach((entry) => {\n      const matches = SESSION_ENTRY_REGEXP.exec(entry)\n      if (matches !== null) {\n        const [, key, value] = matches\n        if (key === 'aid') {\n          // we use `aid` as a key for anonymousId\n          session.anonymousId = value\n        } else {\n          session[key] = value\n        }\n      }\n    })\n  }\n  return session\n}\n","import { getInitCookie } from '../../browser/cookie'\nimport type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'\nimport type { SessionState } from './sessionState'\nimport { expandSessionState, isSessionStarted } from './sessionState'\n\nexport const OLD_SESSION_COOKIE_NAME = '_dd'\nexport const OLD_RUM_COOKIE_NAME = '_dd_r'\nexport const OLD_LOGS_COOKIE_NAME = '_dd_l'\n\n// duplicate values to avoid dependency issues\nexport const RUM_SESSION_KEY = 'rum'\nexport const LOGS_SESSION_KEY = 'logs'\n\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: SessionStoreStrategy) {\n  const sessionString = getInitCookie(SESSION_STORE_KEY)\n  if (!sessionString) {\n    const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME)\n    const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME)\n    const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME)\n    const session: SessionState = {}\n\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\n    if (isSessionStarted(session)) {\n      expandSessionState(session)\n      cookieStoreStrategy.persistSession(session)\n    }\n  }\n}\n","import { isChromium } from '../../../tools/utils/browserDetection'\nimport type { CookieOptions } from '../../../browser/cookie'\nimport { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie'\nimport type { InitConfiguration, Configuration } from '../../configuration'\nimport { tryOldCookiesMigration } from '../oldCookiesMigration'\nimport {\n  SESSION_COOKIE_EXPIRATION_DELAY,\n  SESSION_EXPIRATION_DELAY,\n  SESSION_TIME_OUT_DELAY,\n  SessionPersistence,\n} from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'\nimport type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy'\n\nexport function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {\n  const cookieOptions = buildCookieOptions(initConfiguration)\n  return areCookiesAuthorized(cookieOptions) ? { type: SessionPersistence.COOKIE, cookieOptions } : undefined\n}\n\nexport function initCookieStrategy(configuration: Configuration, cookieOptions: CookieOptions): SessionStoreStrategy {\n  const 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: (sessionState: SessionState) => expireSessionCookie(cookieOptions, sessionState, configuration),\n  }\n\n  tryOldCookiesMigration(cookieStore)\n\n  return cookieStore\n}\n\nfunction persistSessionCookie(options: CookieOptions) {\n  return (session: SessionState) => {\n    setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options)\n  }\n}\n\nfunction expireSessionCookie(options: CookieOptions, sessionState: SessionState, configuration: Configuration) {\n  const expiredSessionState = getExpiredSessionState(sessionState, configuration)\n  // we do not extend cookie expiration date\n  setCookie(\n    SESSION_STORE_KEY,\n    toSessionString(expiredSessionState),\n    configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY,\n    options\n  )\n}\n\nfunction retrieveSessionCookie(): SessionState {\n  const sessionString = getCookie(SESSION_STORE_KEY)\n  const sessionState = toSessionState(sessionString)\n  return sessionState\n}\n\nexport function buildCookieOptions(initConfiguration: InitConfiguration) {\n  const cookieOptions: CookieOptions = {}\n\n  cookieOptions.secure =\n    !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie\n  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie\n  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie\n\n  if (initConfiguration.trackSessionAcrossSubdomains) {\n    cookieOptions.domain = getCurrentSite()\n  }\n\n  return cookieOptions\n}\n","import { generateUUID } from '../../../tools/utils/stringUtils'\nimport type { Configuration } from '../../configuration'\nimport { SessionPersistence } from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\nimport { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'\nimport type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy'\n\nconst LOCAL_STORAGE_TEST_KEY = '_dd_test_'\n\nexport function selectLocalStorageStrategy(): SessionStoreStrategyType | undefined {\n  try {\n    const id = generateUUID()\n    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`\n    localStorage.setItem(testKey, id)\n    const retrievedId = localStorage.getItem(testKey)\n    localStorage.removeItem(testKey)\n    return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport function initLocalStorageStrategy(configuration: Configuration): SessionStoreStrategy {\n  return {\n    isLockEnabled: false,\n    persistSession: persistInLocalStorage,\n    retrieveSession: retrieveSessionFromLocalStorage,\n    expireSession: (sessionState: SessionState) => expireSessionFromLocalStorage(sessionState, configuration),\n  }\n}\n\nfunction persistInLocalStorage(sessionState: SessionState) {\n  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))\n}\n\nfunction retrieveSessionFromLocalStorage(): SessionState {\n  const sessionString = localStorage.getItem(SESSION_STORE_KEY)\n  return toSessionState(sessionString)\n}\n\nfunction expireSessionFromLocalStorage(previousSessionState: SessionState, configuration: Configuration) {\n  persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration))\n}\n","import { setTimeout } from '../../tools/timer'\nimport { generateUUID } from '../../tools/utils/stringUtils'\nimport type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'\nimport type { SessionState } from './sessionState'\nimport { expandSessionState, isSessionInExpiredState } from './sessionState'\n\ntype Operations = {\n  process: (sessionState: SessionState) => SessionState | undefined\n  after?: (sessionState: SessionState) => void\n}\n\nexport const LOCK_RETRY_DELAY = 10\nexport const LOCK_MAX_TRIES = 100\nconst bufferedOperations: Operations[] = []\nlet ongoingOperations: Operations | undefined\n\nexport function processSessionStoreOperations(\n  operations: Operations,\n  sessionStoreStrategy: SessionStoreStrategy,\n  numberOfRetries = 0\n) {\n  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy\n  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })\n  const retrieveStore = () => {\n    const session = sessionStoreStrategy.retrieveSession()\n    const lock = session.lock\n\n    if (session.lock) {\n      delete session.lock\n    }\n\n    return {\n      session,\n      lock,\n    }\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  let currentLock: string\n  let 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  let processedSession = operations.process(currentStore.session)\n  if (isLockEnabled) {\n    // if lock corrupted after process, retry later\n    currentStore = retrieveStore()\n    if (currentStore.lock !== currentLock!) {\n      retryLater(operations, sessionStoreStrategy, numberOfRetries)\n      return\n    }\n  }\n  if (processedSession) {\n    if (isSessionInExpiredState(processedSession)) {\n      expireSession(processedSession)\n    } else {\n      expandSessionState(processedSession)\n      if (isLockEnabled) {\n        persistWithLock(processedSession)\n      } else {\n        persistSession(processedSession)\n      }\n    }\n  }\n  if (isLockEnabled) {\n    // correctly handle lock around expiration would require to handle this case properly at several levels\n    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n    if (!(processedSession && isSessionInExpiredState(processedSession))) {\n      // if lock corrupted after persist, retry later\n      currentStore = retrieveStore()\n      if (currentStore.lock !== currentLock!) {\n        retryLater(operations, sessionStoreStrategy, numberOfRetries)\n        return\n      }\n      persistSession(currentStore.session)\n      processedSession = currentStore.session\n    }\n  }\n  // call after even if session is not persisted in order to perform operations on\n  // up-to-date session state value => the value could have been modified by another tab\n  operations.after?.(processedSession || currentStore.session)\n  next(sessionStoreStrategy)\n}\n\nfunction retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {\n  setTimeout(() => {\n    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)\n  }, LOCK_RETRY_DELAY)\n}\n\nfunction next(sessionStore: SessionStoreStrategy) {\n  ongoingOperations = undefined\n  const nextOperations = bufferedOperations.shift()\n  if (nextOperations) {\n    processSessionStoreOperations(nextOperations, sessionStore)\n  }\n}\n","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 type { InitConfiguration, Configuration } from '../configuration'\nimport { display } from '../../tools/display'\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'\nimport type { SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'\nimport {\n  getExpiredSessionState,\n  isSessionInExpiredState,\n  isSessionInNotStartedState,\n  isSessionStarted,\n} from './sessionState'\nimport type { SessionState } from './sessionState'\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'\nimport { processSessionStoreOperations } from './sessionStoreOperations'\nimport { SessionPersistence } from './sessionConstants'\n\nexport interface SessionStore {\n  expandOrRenewSession: () => void\n  expandSession: () => void\n  getSession: () => SessionState\n  restartSession: () => void\n  renewObservable: Observable<void>\n  expireObservable: Observable<void>\n  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>\n  expire: () => void\n  stop: () => void\n  updateSessionState: (state: Partial<SessionState>) => void\n}\n\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 const STORAGE_POLL_DELAY = ONE_SECOND\n\n/**\n * Selects the correct session store strategy type based on the configuration and storage\n * availability.\n */\nexport function selectSessionStoreStrategyType(\n  initConfiguration: InitConfiguration\n): SessionStoreStrategyType | undefined {\n  switch (initConfiguration.sessionPersistence) {\n    case SessionPersistence.COOKIE:\n      return selectCookieStrategy(initConfiguration)\n\n    case SessionPersistence.LOCAL_STORAGE:\n      return selectLocalStorageStrategy()\n\n    case undefined: {\n      let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)\n      if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n        sessionStoreStrategyType = selectLocalStorageStrategy()\n      }\n      return sessionStoreStrategyType\n    }\n\n    default:\n      display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`)\n  }\n}\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<TrackingType extends string>(\n  sessionStoreStrategyType: SessionStoreStrategyType,\n  configuration: Configuration,\n  productKey: string,\n  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean }\n): SessionStore {\n  const renewObservable = new Observable<void>()\n  const expireObservable = new Observable<void>()\n  const sessionStateUpdateObservable = new Observable<{ previousState: SessionState; newState: SessionState }>()\n\n  const sessionStoreStrategy =\n    sessionStoreStrategyType.type === SessionPersistence.COOKIE\n      ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)\n      : initLocalStorageStrategy(configuration)\n  const { expireSession } = sessionStoreStrategy\n\n  const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)\n  let sessionCache: SessionState\n\n  startSession()\n\n  const { throttled: throttledExpandOrRenewSession, cancel: cancelExpandOrRenewSession } = throttle(() => {\n    processSessionStoreOperations(\n      {\n        process: (sessionState) => {\n          if (isSessionInNotStartedState(sessionState)) {\n            return\n          }\n\n          const synchronizedSession = synchronizeSession(sessionState)\n          expandOrRenewSessionState(synchronizedSession)\n          return synchronizedSession\n        },\n        after: (sessionState) => {\n          if (isSessionStarted(sessionState) && !hasSessionInCache()) {\n            renewSessionInCache(sessionState)\n          }\n          sessionCache = sessionState\n        },\n      },\n      sessionStoreStrategy\n    )\n  }, STORAGE_POLL_DELAY)\n\n  function expandSession() {\n    processSessionStoreOperations(\n      {\n        process: (sessionState) => (hasSessionInCache() ? synchronizeSession(sessionState) : undefined),\n      },\n      sessionStoreStrategy\n    )\n  }\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      {\n        process: (sessionState) =>\n          isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,\n        after: synchronizeSession,\n      },\n      sessionStoreStrategy\n    )\n  }\n\n  function synchronizeSession(sessionState: SessionState) {\n    if (isSessionInExpiredState(sessionState)) {\n      sessionState = getExpiredSessionState(sessionState, configuration)\n    }\n    if (hasSessionInCache()) {\n      if (isSessionInCacheOutdated(sessionState)) {\n        expireSessionInCache()\n      } else {\n        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState })\n        sessionCache = sessionState\n      }\n    }\n    return sessionState\n  }\n\n  function startSession() {\n    processSessionStoreOperations(\n      {\n        process: (sessionState) => {\n          if (isSessionInNotStartedState(sessionState)) {\n            return getExpiredSessionState(sessionState, configuration)\n          }\n        },\n        after: (sessionState) => {\n          sessionCache = sessionState\n        },\n      },\n      sessionStoreStrategy\n    )\n  }\n\n  function expandOrRenewSessionState(sessionState: SessionState) {\n    if (isSessionInNotStartedState(sessionState)) {\n      return false\n    }\n\n    const { trackingType, isTracked } = computeSessionState(sessionState[productKey])\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\n  function hasSessionInCache() {\n    return sessionCache[productKey] !== undefined\n  }\n\n  function isSessionInCacheOutdated(sessionState: SessionState) {\n    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey]\n  }\n\n  function expireSessionInCache() {\n    sessionCache = getExpiredSessionState(sessionCache, configuration)\n    expireObservable.notify()\n  }\n\n  function renewSessionInCache(sessionState: SessionState) {\n    sessionCache = sessionState\n    renewObservable.notify()\n  }\n\n  function updateSessionState(partialSessionState: Partial<SessionState>) {\n    processSessionStoreOperations(\n      {\n        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),\n        after: synchronizeSession,\n      },\n      sessionStoreStrategy\n    )\n  }\n\n  return {\n    expandOrRenewSession: throttledExpandOrRenewSession,\n    expandSession,\n    getSession: () => sessionCache,\n    renewObservable,\n    expireObservable,\n    sessionStateUpdateObservable,\n    restartSession: startSession,\n    expire: () => {\n      cancelExpandOrRenewSession()\n      expireSession(sessionCache)\n      synchronizeSession(getExpiredSessionState(sessionCache, configuration))\n    },\n    stop: () => {\n      clearInterval(watchSessionTimeoutId)\n    },\n    updateSessionState,\n  }\n}\n","import type { Payload } from '../../transport'\nimport { timeStampNow } from '../../tools/utils/timeUtils'\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill'\nimport { generateUUID } from '../../tools/utils/stringUtils'\nimport type { InitConfiguration } from './configuration'\nimport { INTAKE_SITE_US1, INTAKE_SITE_FED_STAGING, PCI_INTAKE_HOST_US1 } from './intakeSites'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nexport type TrackType = 'logs' | 'rum' | 'replay'\nexport type ApiType =\n  | 'xhr'\n  | 'fetch'\n  | 'beacon'\n  // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or\n  // a Node.js script).\n  | 'manual'\n\nexport type EndpointBuilder = ReturnType<typeof createEndpointBuilder>\n\nexport function createEndpointBuilder(\n  initConfiguration: InitConfiguration,\n  trackType: TrackType,\n  configurationTags: string[]\n) {\n  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)\n\n  return {\n    build(api: ApiType, payload: Payload) {\n      const parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload)\n      return buildUrlWithParameters(parameters)\n    },\n    urlPrefix: buildUrlWithParameters(''),\n    trackType,\n  }\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(\n  initConfiguration: InitConfiguration,\n  trackType: TrackType\n): (parameters: string) => string {\n  const path = `/api/v2/${trackType}`\n  const proxy = initConfiguration.proxy\n  if (typeof proxy === 'string') {\n    const normalizedProxyUrl = normalizeUrl(proxy)\n    return (parameters) => `${normalizedProxyUrl}?ddforward=${encodeURIComponent(`${path}?${parameters}`)}`\n  }\n  if (typeof proxy === 'function') {\n    return (parameters) => proxy({ path, parameters })\n  }\n  const host = buildEndpointHost(trackType, initConfiguration)\n  return (parameters) => `https://${host}${path}?${parameters}`\n}\n\nfunction buildEndpointHost(trackType: TrackType, initConfiguration: InitConfiguration & { usePciIntake?: boolean }) {\n  const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration\n\n  if (trackType === 'logs' && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {\n    return PCI_INTAKE_HOST_US1\n  }\n\n  if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n    return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`\n  }\n\n  if (site === INTAKE_SITE_FED_STAGING) {\n    return `http-intake.logs.${site}`\n  }\n\n  const domainParts = site.split('.')\n  const extension = domainParts.pop()\n  return `browser-intake-${domainParts.join('-')}.${extension!}`\n}\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(\n  { clientToken, internalAnalyticsSubdomain }: InitConfiguration,\n  trackType: TrackType,\n  configurationTags: string[],\n  api: ApiType,\n  { retry, encoding }: Payload\n) {\n  const tags = [`sdk_version:${__BUILD_ENV__SDK_VERSION__}`, `api:${api}`].concat(configurationTags)\n  if (retry) {\n    tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`)\n  }\n\n  const parameters = [\n    'ddsource=browser',\n    `ddtags=${encodeURIComponent(tags.join(','))}`,\n    `dd-api-key=${clientToken}`,\n    `dd-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,\n    'dd-evp-origin=browser',\n    `dd-request-id=${generateUUID()}`,\n  ]\n\n  if (encoding) {\n    parameters.push(`dd-evp-encoding=${encoding}`)\n  }\n\n  if (trackType === 'rum') {\n    parameters.push(`batch_time=${timeStampNow()}`)\n  }\n\n  if (internalAnalyticsSubdomain) {\n    parameters.reverse()\n  }\n\n  return parameters.join('&')\n}\n","import { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display'\nimport type { InitConfiguration } from './configuration'\n\nexport const TAG_SIZE_LIMIT = 200\n\nexport function buildTags(configuration: InitConfiguration): string[] {\n  const { env, service, version, datacenter } = configuration\n  const tags = []\n\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\n  return tags\n}\n\nexport function buildTag(key: string, rawValue: string) {\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  const valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1\n\n  if (rawValue.length > valueSizeLimit || hasForbiddenCharacters(rawValue)) {\n    display.warn(\n      `${key} value doesn't meet tag requirements and will be sanitized. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/tagging/#defining-tags`\n    )\n  }\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  const sanitizedValue = rawValue.replace(/,/g, '_')\n\n  return `${key}:${sanitizedValue}`\n}\n\nfunction hasForbiddenCharacters(rawValue: string) {\n  // Unicode property escapes is not supported in all browsers, so we use a try/catch.\n  // Todo: Remove the try/catch when dropping support for Chrome 63 and Firefox 67\n  // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#browser_compatibility\n  if (!supportUnicodePropertyEscapes()) {\n    return false\n  }\n\n  // We use the Unicode property escapes to match any character that is a letter including other languages like Chinese, Japanese, etc.\n  // p{Ll} matches a lowercase letter.\n  // p{Lo} matches a letter that is neither uppercase nor lowercase (ex: Japanese characters).\n  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#unicode_property_escapes_vs._character_classes\n  return new RegExp('[^\\\\p{Ll}\\\\p{Lo}0-9_:./-]', 'u').test(rawValue)\n}\n\nexport function supportUnicodePropertyEscapes() {\n  try {\n    new RegExp('[\\\\p{Ll}]', 'u')\n    return true\n  } catch {\n    return false\n  }\n}\n","import type { InitConfiguration } from './configuration'\nimport type { EndpointBuilder } from './endpointBuilder'\nimport { createEndpointBuilder } from './endpointBuilder'\nimport { buildTags } from './tags'\nimport type { Site } from './intakeSites'\nimport { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from './intakeSites'\n\nexport interface TransportConfiguration {\n  logsEndpointBuilder: EndpointBuilder\n  rumEndpointBuilder: EndpointBuilder\n  sessionReplayEndpointBuilder: EndpointBuilder\n  replica?: ReplicaConfiguration\n  site: Site\n}\n\nexport interface ReplicaConfiguration {\n  applicationId?: string\n  logsEndpointBuilder: EndpointBuilder\n  rumEndpointBuilder: EndpointBuilder\n}\n\nexport function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {\n  const site = initConfiguration.site || INTAKE_SITE_US1\n\n  const tags = buildTags(initConfiguration)\n\n  const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)\n  const replicaConfiguration = computeReplicaConfiguration(initConfiguration, tags)\n\n  return {\n    replica: replicaConfiguration,\n    site,\n    ...endpointBuilders,\n  }\n}\n\nfunction computeEndpointBuilders(initConfiguration: InitConfiguration, tags: string[]) {\n  return {\n    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),\n  }\n}\n\nfunction computeReplicaConfiguration(\n  initConfiguration: InitConfiguration,\n  tags: string[]\n): ReplicaConfiguration | undefined {\n  if (!initConfiguration.replica) {\n    return\n  }\n\n  const replicaConfiguration: InitConfiguration = {\n    ...initConfiguration,\n    site: INTAKE_SITE_US1,\n    clientToken: initConfiguration.replica.clientToken,\n  }\n\n  const replicaEndpointBuilders = {\n    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n  }\n\n  return { applicationId: initConfiguration.replica.applicationId, ...replicaEndpointBuilders }\n}\n\nexport function isIntakeUrl(url: string): boolean {\n  // check if tags is present in the query string\n  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))\n}\n","import { catchUserErrors } from '../../tools/catchUserErrors'\nimport { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display'\nimport type { RawTelemetryConfiguration } from '../telemetry'\nimport type { Duration } from '../../tools/utils/timeUtils'\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 { selectSessionStoreStrategyType } from '../session/sessionStore'\nimport type { SessionStoreStrategyType } from '../session/storeStrategies/sessionStoreStrategy'\nimport { TrackingConsent } from '../trackingConsent'\nimport type { SessionPersistence } from '../session/sessionConstants'\nimport type { TransportConfiguration } from './transportConfiguration'\nimport { computeTransportConfiguration } from './transportConfiguration'\nimport type { Site } from './intakeSites'\n\nexport const DefaultPrivacyLevel = {\n  ALLOW: 'allow',\n  MASK: 'mask',\n  MASK_USER_INPUT: 'mask-user-input',\n} as const\nexport type DefaultPrivacyLevel = (typeof DefaultPrivacyLevel)[keyof typeof DefaultPrivacyLevel]\n\nexport const TraceContextInjection = {\n  ALL: 'all',\n  SAMPLED: 'sampled',\n} as const\n\nexport type TraceContextInjection = (typeof TraceContextInjection)[keyof typeof TraceContextInjection]\n\nexport interface InitConfiguration {\n  /**\n   * The client token for Datadog. Required for authenticating your application with Datadog.\n   */\n  clientToken: string\n  beforeSend?: GenericBeforeSendCallback | undefined\n  /**\n   * The percentage of sessions tracked. A value between 0 and 100.\n   * @default 100\n   */\n  sessionSampleRate?: number | undefined\n  /**\n   * The percentage of telemetry events sent. A value between 0 and 100.\n   * @default 20\n   */\n  telemetrySampleRate?: number | undefined\n  /**\n   * Initialization fails silently if the RUM Browser SDK is already initialized on the page.\n   * @default false\n   */\n  silentMultipleInit?: boolean | undefined\n\n  /**\n   * Which storage strategy to use for persisting sessions. Can be either 'cookie' or 'local-storage'.\n   * @default \"cookie\"\n   */\n  sessionPersistence?: SessionPersistence | undefined\n\n  /**\n   * Allows the use of localStorage when cookies cannot be set. This enables the RUM Browser SDK to run in environments that do not provide cookie support.\n   * See [Monitor Electron Applications Using the Browser SDK](https://docs.datadoghq.com/real_user_monitoring/guide/monitor-electron-applications-using-browser-sdk) for further information.\n   * @deprecated use `sessionPersistence: local-storage` where you want to use localStorage instead\n   */\n  allowFallbackToLocalStorage?: boolean | undefined\n\n  /**\n   * Allow listening to DOM events dispatched programmatically ([untrusted events](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)). Enabling this option can be useful if you heavily rely on programmatic events, such as in an automated UI test environment.\n   * @default false\n   */\n  allowUntrustedEvents?: boolean | undefined\n  /**\n   * Store global context and user context in localStorage to preserve them along the user navigation.\n   * See [Contexts life cycle](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#contexts-life-cycle) for further information.\n   * @default false\n   */\n  storeContextsAcrossPages?: boolean | undefined\n  /**\n   * Set the initial user tracking consent state.\n   * See [User tracking consent](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#user-tracking-consent) for further information.\n   * @default granted\n   */\n  trackingConsent?: TrackingConsent | undefined\n\n  // transport options\n  /**\n   * Optional proxy URL, for example: https://www.proxy.com/path.\n   * See [Proxy Your Browser RUM Data](https://docs.datadoghq.com/real_user_monitoring/guide/proxy-rum-data) for further information.\n   */\n  proxy?: string | ProxyFn | undefined\n  /**\n   * The Datadog [site](https://docs.datadoghq.com/getting_started/site) parameter of your organization.\n   * @default datadoghq.com\n   */\n  site?: Site | undefined\n\n  // tag and context options\n  /**\n   * The service name for your application. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).\n   */\n  service?: string | undefined | null\n  /**\n   * The application’s environment, for example: prod, pre-prod, and staging. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).\n   */\n  env?: string | undefined | null\n  /**\n   * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13. Follows the [tag syntax requirements](https://docs.datadoghq.com/getting_started/tagging/#define-tags).\n   */\n  version?: string | undefined | null\n\n  // cookie options\n  /**\n   * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.\n   * @default false\n   */\n  usePartitionedCrossSiteSessionCookie?: boolean | undefined\n  /**\n   * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.\n   * @default false\n   */\n  useSecureSessionCookie?: boolean | undefined\n  /**\n   * Preserve the session across subdomains for the same site.\n   * @default false\n   */\n  trackSessionAcrossSubdomains?: boolean | undefined\n  /**\n   * Track anonymous user for the same site and extend cookie expiration date\n   * @default true\n   */\n  trackAnonymousUser?: boolean | undefined\n  // internal options\n  /**\n   * [Internal option] Enable experimental features\n   */\n  enableExperimentalFeatures?: string[] | undefined\n  /**\n   * [Internal option] Configure the dual chipping to another datacenter\n   */\n  replica?: ReplicaUserConfiguration | undefined\n  /**\n   * [Internal option] Set the datacenter from where the data is dual chipped\n   */\n  datacenter?: string\n  /**\n   * [Internal option] Datadog internal analytics subdomain\n   */\n  // TODO next major: remove this option and replace usages by proxyFn\n  internalAnalyticsSubdomain?: string\n  /**\n   * [Internal option] The percentage of telemetry configuration sent. A value between 0 and 100.\n   * @default 5\n   */\n  telemetryConfigurationSampleRate?: number\n  /**\n   * [Internal option] The percentage of telemetry usage sent. A value between 0 and 100.\n   * @default 5\n   */\n  telemetryUsageSampleRate?: number\n}\n\n// This type is only used to build the core configuration. Logs and RUM SDKs are using a proper type\n// for this option.\ntype GenericBeforeSendCallback = (event: any, context?: any) => unknown\n\n/**\n * path: /api/vX/product\n * parameters: xxx=yyy&zzz=aaa\n */\ntype ProxyFn = (options: { path: string; parameters: string }) => string\n\nexport interface ReplicaUserConfiguration {\n  applicationId?: string\n  clientToken: string\n}\n\nexport interface Configuration extends TransportConfiguration {\n  // Built from init configuration\n  beforeSend: GenericBeforeSendCallback | undefined\n  sessionStoreStrategyType: SessionStoreStrategyType | undefined\n  sessionSampleRate: number\n  telemetrySampleRate: number\n  telemetryConfigurationSampleRate: number\n  telemetryUsageSampleRate: number\n  service: string | undefined\n  silentMultipleInit: boolean\n  allowUntrustedEvents: boolean\n  trackingConsent: TrackingConsent\n  storeContextsAcrossPages: boolean\n  trackAnonymousUser?: boolean\n\n  // Event limits\n  eventRateLimiterThreshold: number // Limit the maximum number of actions, errors and logs per minutes\n  maxTelemetryEventsPerPage: number\n\n  // Batch configuration\n  batchBytesLimit: number\n  flushTimeout: Duration\n  batchMessagesLimit: number\n  messageBytesLimit: number\n}\n\nfunction isString(tag: unknown, tagName: string): tag is string | undefined | null {\n  if (tag !== undefined && tag !== null && typeof tag !== 'string') {\n    display.error(`${tagName} must be defined as a string`)\n    return false\n  }\n  return true\n}\n\nfunction isDatadogSite(site: unknown) {\n  if (site && typeof site === 'string' && !/(datadog|ddog|datad0g|dd0g)/.test(site)) {\n    display.error(`Site should be a valid Datadog site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`)\n    return false\n  }\n  return true\n}\n\nexport function isSampleRate(sampleRate: unknown, name: string) {\n  if (sampleRate !== undefined && !isPercentage(sampleRate)) {\n    display.error(`${name} Sample Rate should be a number between 0 and 100`)\n    return false\n  }\n  return true\n}\n\nexport function validateAndBuildConfiguration(initConfiguration: InitConfiguration): Configuration | undefined {\n  if (!initConfiguration || !initConfiguration.clientToken) {\n    display.error('Client Token is not configured, we will not send any data.')\n    return\n  }\n\n  if (\n    !isDatadogSite(initConfiguration.site) ||\n    !isSampleRate(initConfiguration.sessionSampleRate, 'Session') ||\n    !isSampleRate(initConfiguration.telemetrySampleRate, 'Telemetry') ||\n    !isSampleRate(initConfiguration.telemetryConfigurationSampleRate, 'Telemetry Configuration') ||\n    !isSampleRate(initConfiguration.telemetryUsageSampleRate, 'Telemetry Usage') ||\n    !isString(initConfiguration.version, 'Version') ||\n    !isString(initConfiguration.env, 'Env') ||\n    !isString(initConfiguration.service, 'Service')\n  ) {\n    return\n  }\n\n  if (\n    initConfiguration.trackingConsent !== undefined &&\n    !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)\n  ) {\n    display.error('Tracking Consent should be either \"granted\" or \"not-granted\"')\n    return\n  }\n\n  return {\n    beforeSend:\n      initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n    sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),\n    sessionSampleRate: initConfiguration.sessionSampleRate ?? 100,\n    telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,\n    telemetryConfigurationSampleRate: initConfiguration.telemetryConfigurationSampleRate ?? 5,\n    telemetryUsageSampleRate: initConfiguration.telemetryUsageSampleRate ?? 5,\n    service: initConfiguration.service || undefined,\n    silentMultipleInit: !!initConfiguration.silentMultipleInit,\n    allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,\n    trackingConsent: initConfiguration.trackingConsent ?? TrackingConsent.GRANTED,\n    trackAnonymousUser: initConfiguration.trackAnonymousUser ?? true,\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\n    eventRateLimiterThreshold: 3000,\n    maxTelemetryEventsPerPage: 15,\n\n    /**\n     * flush automatically, aim to be lower than ALB connection timeout\n     * to maximize connection reuse.\n     */\n    flushTimeout: (30 * ONE_SECOND) as Duration,\n\n    /**\n     * Logs intake limit\n     */\n    batchMessagesLimit: 50,\n    messageBytesLimit: 256 * ONE_KIBI_BYTE,\n    ...computeTransportConfiguration(initConfiguration),\n  }\n}\n\nexport function serializeConfiguration(initConfiguration: 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_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    track_anonymous_user: initConfiguration.trackAnonymousUser,\n    session_persistence: initConfiguration.sessionPersistence,\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  } satisfies RawTelemetryConfiguration\n}\n","import { display } from './display'\nimport { getType } from './utils/typeUtils'\n\nexport type MatchOption = string | RegExp | ((value: string) => boolean)\n\nexport function isMatchOption(item: unknown): item is MatchOption {\n  const itemType = getType(item)\n  return itemType === 'string' || itemType === 'function' || item instanceof RegExp\n}\n\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list: MatchOption[], value: string, useStartsWith = false): boolean {\n  return list.some((item) => {\n    try {\n      if (typeof item === 'function') {\n        return item(value)\n      } else if (item instanceof RegExp) {\n        return item.test(value)\n      } else if (typeof item === 'string') {\n        return useStartsWith ? value.startsWith(item) : item === value\n      }\n    } catch (e) {\n      display.error(e)\n    }\n    return false\n  })\n}\n","export function getCrypto() {\n  // TODO: remove msCrypto when IE11 support is dropped\n  return window.crypto || (window as any).msCrypto\n}\n","import { ExperimentalFeature, isExperimentalFeatureEnabled } from '@datadog/browser-core'\nimport { getCrypto } from '../../browser/crypto'\n\ninterface BaseIdentifier {\n  toString(radix?: number): string\n}\n\nexport interface TraceIdentifier extends BaseIdentifier {\n  // We use a brand to distinguish between TraceIdentifier and SpanIdentifier, else TypeScript\n  // considers them as the same type\n  __brand: 'traceIdentifier'\n}\n\nexport interface SpanIdentifier extends BaseIdentifier {\n  __brand: 'spanIdentifier'\n}\n\nexport function createTraceIdentifier() {\n  return createIdentifier(64) as TraceIdentifier\n}\n\nexport function createSpanIdentifier() {\n  return createIdentifier(63) as SpanIdentifier\n}\n\nlet createIdentifierImplementationCache: ((bits: 63 | 64) => BaseIdentifier) | undefined\n\nexport function clearIdentifierImplementationCache() {\n  createIdentifierImplementationCache = undefined\n}\n\nfunction createIdentifier(bits: 63 | 64): BaseIdentifier {\n  if (!createIdentifierImplementationCache) {\n    createIdentifierImplementationCache =\n      isExperimentalFeatureEnabled(ExperimentalFeature.CONSISTENT_TRACE_SAMPLING) && areBigIntIdentifiersSupported()\n        ? createIdentifierUsingBigInt\n        : createIdentifierUsingUint32Array\n  }\n  return createIdentifierImplementationCache(bits)\n}\n\nexport function areBigIntIdentifiersSupported() {\n  try {\n    crypto.getRandomValues(new BigUint64Array(1))\n    return true\n  } catch {\n    return false\n  }\n}\n\nfunction createIdentifierUsingBigInt(bits: 63 | 64): BaseIdentifier {\n  let id = crypto.getRandomValues(new BigUint64Array(1))[0]\n  if (bits === 63) {\n    // eslint-disable-next-line no-bitwise\n    id >>= BigInt('1')\n  }\n  return id\n}\n\n// TODO: remove this when all browser we support have BigInt support\nfunction createIdentifierUsingUint32Array(bits: 63 | 64): BaseIdentifier {\n  const buffer = getCrypto().getRandomValues(new Uint32Array(2))\n  if (bits === 63) {\n    // eslint-disable-next-line no-bitwise\n    buffer[buffer.length - 1] >>>= 1 // force 63-bit\n  }\n\n  return {\n    toString(radix = 10) {\n      let high = buffer[1]\n      let low = buffer[0]\n      let str = ''\n\n      do {\n        const mod = (high % radix) * 4294967296 + low\n        high = Math.floor(high / radix)\n        low = Math.floor(mod / radix)\n        str = (mod % radix).toString(radix) + str\n      } while (high || low)\n\n      return str\n    },\n  }\n}\n\nexport function toPaddedHexadecimalString(id: BaseIdentifier) {\n  const traceId = id.toString(16)\n  // TODO: replace with String.prototype.padStart when we drop IE11 support\n  return Array(17 - traceId.length).join('0') + traceId\n}\n","import {\n  objectEntries,\n  shallowClone,\n  getType,\n  isMatchOption,\n  matchList,\n  TraceContextInjection,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport type {\n  RumFetchResolveContext,\n  RumFetchStartContext,\n  RumXhrCompleteContext,\n  RumXhrStartContext,\n} from '../requestCollection'\nimport type { RumSessionManager } from '../rumSessionManager'\nimport { getCrypto } from '../../browser/crypto'\nimport type { PropagatorType, TracingOption } from './tracer.types'\nimport type { SpanIdentifier, TraceIdentifier } from './identifier'\nimport { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier'\nimport { isTraceSampled } from './sampler'\n\nexport interface Tracer {\n  traceFetch: (context: Partial<RumFetchStartContext>) => void\n  traceXhr: (context: Partial<RumXhrStartContext>, xhr: XMLHttpRequest) => void\n  clearTracingIfNeeded: (context: RumFetchResolveContext | RumXhrCompleteContext) => void\n}\n\ninterface TracingHeaders {\n  [key: string]: string\n}\n\nexport function isTracingOption(item: unknown): item is TracingOption {\n  const expectedItem = item as TracingOption\n  return (\n    getType(expectedItem) === 'object' &&\n    isMatchOption(expectedItem.match) &&\n    Array.isArray(expectedItem.propagatorTypes)\n  )\n}\n\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course, it might not be the case every time, but it should limit having incomplete traces a\n * bit.\n * */\nexport function clearTracingIfNeeded(context: RumFetchResolveContext | RumXhrCompleteContext) {\n  if (context.status === 0 && !context.isAborted) {\n    context.traceId = undefined\n    context.spanId = undefined\n    context.traceSampled = undefined\n  }\n}\n\nexport function startTracer(configuration: RumConfiguration, sessionManager: RumSessionManager): Tracer {\n  return {\n    clearTracingIfNeeded,\n    traceFetch: (context) =>\n      injectHeadersIfTracingAllowed(configuration, context, sessionManager, (tracingHeaders: TracingHeaders) => {\n        if (context.input instanceof Request && !context.init?.headers) {\n          context.input = new Request(context.input)\n          Object.keys(tracingHeaders).forEach((key) => {\n            ;(context.input as Request).headers.append(key, tracingHeaders[key])\n          })\n        } else {\n          context.init = shallowClone(context.init)\n          const headers: Array<[string, string]> = []\n          if (context.init.headers instanceof Headers) {\n            context.init.headers.forEach((value, key) => {\n              headers.push([key, value])\n            })\n          } else if (Array.isArray(context.init.headers)) {\n            context.init.headers.forEach((header) => {\n              headers.push(header)\n            })\n          } else if (context.init.headers) {\n            Object.keys(context.init.headers).forEach((key) => {\n              headers.push([key, (context.init!.headers as Record<string, string>)[key]])\n            })\n          }\n          context.init.headers = headers.concat(objectEntries(tracingHeaders))\n        }\n      }),\n    traceXhr: (context, xhr) =>\n      injectHeadersIfTracingAllowed(configuration, context, sessionManager, (tracingHeaders: TracingHeaders) => {\n        Object.keys(tracingHeaders).forEach((name) => {\n          xhr.setRequestHeader(name, tracingHeaders[name])\n        })\n      }),\n  }\n}\n\nfunction injectHeadersIfTracingAllowed(\n  configuration: RumConfiguration,\n  context: Partial<RumFetchStartContext | RumXhrStartContext>,\n  sessionManager: RumSessionManager,\n  inject: (tracingHeaders: TracingHeaders) => void\n) {\n  if (!isTracingSupported() || !sessionManager.findTrackedSession()) {\n    return\n  }\n\n  const tracingOption = configuration.allowedTracingUrls.find((tracingOption: TracingOption) =>\n    matchList([tracingOption.match], context.url!, true)\n  )\n  if (!tracingOption) {\n    return\n  }\n  const traceId = createTraceIdentifier()\n  context.traceSampled = isTraceSampled(traceId, configuration.traceSampleRate)\n\n  const shouldInjectHeaders = context.traceSampled || configuration.traceContextInjection === TraceContextInjection.ALL\n\n  if (!shouldInjectHeaders) {\n    return\n  }\n\n  context.traceId = traceId\n  context.spanId = createSpanIdentifier()\n\n  inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes))\n}\n\nexport function isTracingSupported() {\n  return getCrypto() !== undefined\n}\n\n/**\n * When trace is not sampled, set priority to '0' instead of not adding the tracing headers\n * to prepare the implementation for sampling delegation.\n */\nfunction makeTracingHeaders(\n  traceId: TraceIdentifier,\n  spanId: SpanIdentifier,\n  traceSampled: boolean,\n  propagatorTypes: PropagatorType[]\n): TracingHeaders {\n  const tracingHeaders: TracingHeaders = {}\n\n  propagatorTypes.forEach((propagatorType) => {\n    switch (propagatorType) {\n      case 'datadog': {\n        Object.assign(tracingHeaders, {\n          'x-datadog-origin': 'rum',\n          'x-datadog-parent-id': spanId.toString(),\n          'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n          'x-datadog-trace-id': traceId.toString(),\n        })\n        break\n      }\n      // https://www.w3.org/TR/trace-context/\n      case 'tracecontext': {\n        Object.assign(tracingHeaders, {\n          traceparent: `00-0000000000000000${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-0${\n            traceSampled ? '1' : '0'\n          }`,\n          tracestate: `dd=s:${traceSampled ? '1' : '0'};o:rum`,\n        })\n        break\n      }\n      // https://github.com/openzipkin/b3-propagation\n      case 'b3': {\n        Object.assign(tracingHeaders, {\n          b3: `${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-${traceSampled ? '1' : '0'}`,\n        })\n        break\n      }\n      case 'b3multi': {\n        Object.assign(tracingHeaders, {\n          'X-B3-TraceId': toPaddedHexadecimalString(traceId),\n          'X-B3-SpanId': toPaddedHexadecimalString(spanId),\n          'X-B3-Sampled': traceSampled ? '1' : '0',\n        })\n        break\n      }\n    }\n  })\n  return tracingHeaders\n}\n","import { performDraw } from '@datadog/browser-core'\nimport type { TraceIdentifier } from './identifier'\n\nexport function isTraceSampled(identifier: TraceIdentifier, sampleRate: number) {\n  // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for\n  // customers willing to ingest all traces.\n  if (sampleRate === 100) {\n    return true\n  }\n\n  if (sampleRate === 0) {\n    return false\n  }\n\n  // For simplicity, we don't use consistent sampling for browser that don't support BigInt\n  // TODO: remove this when all browser we support have BigInt support\n  if (typeof identifier !== 'bigint') {\n    return performDraw(sampleRate)\n  }\n\n  // Offer consistent sampling for the same trace id across different environments. The rule is:\n  //\n  //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64\n  //\n  // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the\n  // modulo would be incorrect. Thus, we are using BigInts here.\n  //\n  // Implementation in other languages:\n  // * Go     https://github.com/DataDog/dd-trace-go/blob/ec6fbb1f2d517b7b8e69961052adf7136f3af773/ddtrace/tracer/sampler.go#L86-L91\n  // * Python https://github.com/DataDog/dd-trace-py/blob/0cee2f066fb6e79aa15947c1514c0f406dea47c5/ddtrace/sampling_rule.py#L197\n  // * Ruby   https://github.com/DataDog/dd-trace-rb/blob/1a6e255cdcb7e7e22235ea5955f90f6dfa91045d/lib/datadog/tracing/sampling/rate_sampler.rb#L42\n  // * C++    https://github.com/DataDog/dd-trace-cpp/blob/159629edc438ae45f2bb318eb7bd51abd05e94b5/src/datadog/trace_sampler.cpp#L58\n  // * Java   https://github.com/DataDog/dd-trace-java/blob/896dd6b380533216e0bdee59614606c8272d313e/dd-trace-core/src/main/java/datadog/trace/common/sampling/DeterministicSampler.java#L48\n  //\n  // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and\n  // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation\n  // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less\n  // BigInt arithmetic to write. In practice this does not matter, as we are using floating point\n  // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).\n  const knuthFactor = BigInt('1111111111111111111')\n  const twoPow64 = BigInt('0x10000000000000000') // 2n ** 64n\n  const hash = (identifier * knuthFactor) % twoPow64\n  return Number(hash) <= (sampleRate / 100) * Number(twoPow64)\n}\n","import type { Configuration, InitConfiguration, MatchOption, RawTelemetryConfiguration } from '@datadog/browser-core'\nimport {\n  getType,\n  isMatchOption,\n  serializeConfiguration,\n  DefaultPrivacyLevel,\n  TraceContextInjection,\n  display,\n  objectHasValue,\n  validateAndBuildConfiguration,\n  isSampleRate,\n  isNumber,\n} from '@datadog/browser-core'\nimport type { RumEventDomainContext } from '../../domainContext.types'\nimport type { RumEvent } from '../../rumEvent.types'\nimport type { RumPlugin } from '../plugins'\nimport { isTracingOption } from '../tracing/tracer'\nimport type { PropagatorType, TracingOption } from '../tracing/tracer.types'\n\nexport const DEFAULT_PROPAGATOR_TYPES: PropagatorType[] = ['tracecontext', 'datadog']\n\nexport interface RumInitConfiguration extends InitConfiguration {\n  // global options\n  /**\n   * The RUM application ID.\n   */\n  applicationId: string\n  /**\n   * Access to every event collected by the RUM SDK before they are sent to Datadog.\n   * It allows:\n   * - Enrich your RUM events with additional context attributes\n   * - Modify your RUM events to modify their content, or redact sensitive sequences (see the list of editable properties)\n   * - Discard selected RUM events\n   *\n   * See [Enrich And Control Browser RUM Data With beforeSend](https://docs.datadoghq.com/real_user_monitoring/guide/enrich-and-control-rum-data) for further information.\n   */\n  beforeSend?: ((event: RumEvent, context: RumEventDomainContext) => boolean) | undefined\n  /**\n   * A list of request origins ignored when computing the page activity.\n   * See [How page activity is calculated](https://docs.datadoghq.com/real_user_monitoring/browser/monitoring_page_performance/#how-page-activity-is-calculated) for further information.\n   */\n  excludedActivityUrls?: MatchOption[] | undefined\n  /**\n   * URL pointing to the Datadog Browser SDK Worker JavaScript file. The URL can be relative or absolute, but is required to have the same origin as the web application.\n   * See [Content Security Policy guidelines](https://docs.datadoghq.com/integrations/content_security_policy_logs/?tab=firefox#use-csp-with-real-user-monitoring-and-session-replay) for further information.\n   */\n  workerUrl?: string\n  /**\n   * Compress requests sent to the Datadog intake to reduce bandwidth usage when sending large amounts of data. The compression is done in a Worker thread.\n   * See [Content Security Policy guidelines](https://docs.datadoghq.com/integrations/content_security_policy_logs/?tab=firefox#use-csp-with-real-user-monitoring-and-session-replay) for further information.\n   */\n  compressIntakeRequests?: boolean | undefined\n  remoteConfigurationId?: string | undefined\n\n  // tracing options\n  /**\n   * A list of request URLs used to inject tracing headers.\n   * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n   */\n  allowedTracingUrls?: Array<MatchOption | TracingOption> | undefined\n\n  /**\n   * The percentage of requests to trace: 100 for all, 0 for none.\n   * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n   */\n  traceSampleRate?: number | undefined\n  /**\n   * If you set a `traceSampleRate`, to ensure backend services' sampling decisions are still applied, configure the `traceContextInjection` initialization parameter to sampled.\n   * @default sampled\n   * See [Connect RUM and Traces](https://docs.datadoghq.com/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n   */\n  traceContextInjection?: TraceContextInjection | undefined\n\n  // replay options\n  /**\n   * Allow to protect end user privacy and prevent sensitive organizational information from being collected.\n   * @default mask\n   * See [Replay Privacy Options](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser/privacy_options) for further information.\n   */\n  defaultPrivacyLevel?: DefaultPrivacyLevel | undefined\n  /**\n   * If you are accessing Datadog through a custom subdomain, you can set `subdomain` to include your custom domain in the `getSessionReplayLink()` returned URL .\n   * See [Connect Session Replay To Your Third-Party Tools](https://docs.datadoghq.com/real_user_monitoring/guide/connect-session-replay-to-your-third-party-tools) for further information.\n   */\n  subdomain?: string\n  /**\n   * The percentage of tracked sessions with [Browser RUM & Session Replay pricing](https://www.datadoghq.com/pricing/?product=real-user-monitoring--session-replay#real-user-monitoring--session-replay) features: 100 for all, 0 for none.\n   * See [Configure Your Setup For Browser RUM and Browser RUM & Session Replay Sampling](https://docs.datadoghq.com/real_user_monitoring/guide/sampling-browser-plans) for further information.\n   */\n  sessionReplaySampleRate?: number | undefined\n  /**\n   * If the session is sampled for Session Replay, only start the recording when `startSessionReplayRecording()` is called, instead of at the beginning of the session. Default: if startSessionReplayRecording is 0, true; otherwise, false.\n   * See [Session Replay Usage](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser/#usage) for further information.\n   */\n  startSessionReplayRecordingManually?: boolean | undefined\n\n  /**\n   * Enables privacy control for action names.\n   */\n  enablePrivacyForActionName?: boolean | undefined // TODO next major: remove this option and make privacy for action name the default behavior\n  /**\n   * Enables automatic collection of users actions.\n   * See [Tracking User Actions](https://docs.datadoghq.com/real_user_monitoring/browser/tracking_user_actions) for further information.\n   * @default true\n   */\n  trackUserInteractions?: boolean | undefined\n  /**\n   * Specify your own attribute to use to name actions.\n   * See [Declare a name for click actions](https://docs.datadoghq.com/real_user_monitoring/browser/tracking_user_actions/#declare-a-name-for-click-actions) for further information.\n   */\n  actionNameAttribute?: string | undefined\n\n  // view options\n  /**\n   * Allows you to control RUM views creation. See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/?tab=npm#override-default-rum-view-names) for further information.\n   */\n  trackViewsManually?: boolean | undefined\n  /**\n   * Enables collection of resource events.\n   * @default true\n   */\n  trackResources?: boolean | undefined\n  /**\n   * Enables collection of long task events.\n   * @default true\n   */\n  trackLongTasks?: boolean | undefined\n\n  /**\n   * List of plugins to enable. The plugins API is unstable and experimental, and may change without\n   * notice. Please use only plugins provided by Datadog matching the version of the SDK you are\n   * using.\n   */\n  plugins?: RumPlugin[] | undefined\n\n  /**\n   * Enables collection of features flags in chosen events.\n   */\n  trackFeatureFlagsForEvents?: FeatureFlagsForEvents[]\n}\n\nexport type HybridInitConfiguration = Omit<RumInitConfiguration, 'applicationId' | 'clientToken'>\n\nexport type FeatureFlagsForEvents = 'vital' | 'action' | 'long_task' | 'resource'\n\nexport interface RumConfiguration extends Configuration {\n  // Built from init configuration\n  actionNameAttribute: string | undefined\n  traceSampleRate: number\n  rulePsr: number | undefined\n  allowedTracingUrls: TracingOption[]\n  excludedActivityUrls: MatchOption[]\n  workerUrl: string | undefined\n  compressIntakeRequests: boolean\n  applicationId: string\n  defaultPrivacyLevel: DefaultPrivacyLevel\n  enablePrivacyForActionName: boolean\n  sessionReplaySampleRate: number\n  startSessionReplayRecordingManually: boolean\n  trackUserInteractions: boolean\n  trackViewsManually: boolean\n  trackResources: boolean\n  trackLongTasks: boolean\n  version?: string\n  subdomain?: string\n  customerDataTelemetrySampleRate: number\n  traceContextInjection: TraceContextInjection\n  plugins: RumPlugin[]\n  trackFeatureFlagsForEvents: FeatureFlagsForEvents[]\n}\n\nexport function validateAndBuildRumConfiguration(\n  initConfiguration: RumInitConfiguration\n): RumConfiguration | undefined {\n  if (\n    initConfiguration.trackFeatureFlagsForEvents !== undefined &&\n    !Array.isArray(initConfiguration.trackFeatureFlagsForEvents)\n  ) {\n    display.warn('trackFeatureFlagsForEvents should be an array')\n  }\n\n  if (!initConfiguration.applicationId) {\n    display.error('Application ID is not configured, no RUM data will be collected.')\n    return\n  }\n\n  if (\n    !isSampleRate(initConfiguration.sessionReplaySampleRate, 'Session Replay') ||\n    !isSampleRate(initConfiguration.traceSampleRate, 'Trace')\n  ) {\n    return\n  }\n\n  if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {\n    display.error('Excluded Activity Urls should be an array')\n    return\n  }\n\n  const allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration)\n  if (!allowedTracingUrls) {\n    return\n  }\n\n  const baseConfiguration = validateAndBuildConfiguration(initConfiguration)\n  if (!baseConfiguration) {\n    return\n  }\n\n  const sessionReplaySampleRate = initConfiguration.sessionReplaySampleRate ?? 0\n\n  return {\n    applicationId: initConfiguration.applicationId,\n    version: initConfiguration.version || undefined,\n    actionNameAttribute: initConfiguration.actionNameAttribute,\n    sessionReplaySampleRate,\n    startSessionReplayRecordingManually:\n      initConfiguration.startSessionReplayRecordingManually !== undefined\n        ? !!initConfiguration.startSessionReplayRecordingManually\n        : sessionReplaySampleRate === 0,\n    traceSampleRate: initConfiguration.traceSampleRate ?? 100,\n    rulePsr: isNumber(initConfiguration.traceSampleRate) ? initConfiguration.traceSampleRate / 100 : undefined,\n    allowedTracingUrls,\n    excludedActivityUrls: initConfiguration.excludedActivityUrls ?? [],\n    workerUrl: initConfiguration.workerUrl,\n    compressIntakeRequests: !!initConfiguration.compressIntakeRequests,\n    trackUserInteractions: !!(initConfiguration.trackUserInteractions ?? true),\n    trackViewsManually: !!initConfiguration.trackViewsManually,\n    trackResources: !!(initConfiguration.trackResources ?? true),\n    trackLongTasks: !!(initConfiguration.trackLongTasks ?? true),\n    subdomain: initConfiguration.subdomain,\n    defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n      ? initConfiguration.defaultPrivacyLevel\n      : DefaultPrivacyLevel.MASK,\n    enablePrivacyForActionName: !!initConfiguration.enablePrivacyForActionName,\n    customerDataTelemetrySampleRate: 1,\n    traceContextInjection: objectHasValue(TraceContextInjection, initConfiguration.traceContextInjection)\n      ? initConfiguration.traceContextInjection\n      : TraceContextInjection.SAMPLED,\n    plugins: initConfiguration.plugins || [],\n    trackFeatureFlagsForEvents: initConfiguration.trackFeatureFlagsForEvents || [],\n    ...baseConfiguration,\n  }\n}\n\n/**\n * Validates allowedTracingUrls and converts match options to tracing options\n */\nfunction validateAndBuildTracingOptions(initConfiguration: RumInitConfiguration): TracingOption[] | undefined {\n  if (initConfiguration.allowedTracingUrls === undefined) {\n    return []\n  }\n  if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n    display.error('Allowed Tracing URLs should be an array')\n    return\n  }\n  if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n    display.error('Service needs to be configured when tracing is enabled')\n    return\n  }\n  // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n  const tracingOptions: TracingOption[] = []\n  initConfiguration.allowedTracingUrls.forEach((option) => {\n    if (isMatchOption(option)) {\n      tracingOptions.push({ match: option, propagatorTypes: DEFAULT_PROPAGATOR_TYPES })\n    } else if (isTracingOption(option)) {\n      tracingOptions.push(option)\n    } else {\n      display.warn(\n        'Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter',\n        option\n      )\n    }\n  })\n\n  return tracingOptions\n}\n\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls\n */\nfunction getSelectedTracingPropagators(configuration: RumInitConfiguration): PropagatorType[] {\n  const usedTracingPropagators = new Set<PropagatorType>()\n\n  if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n    configuration.allowedTracingUrls.forEach((option) => {\n      if (isMatchOption(option)) {\n        DEFAULT_PROPAGATOR_TYPES.forEach((propagatorType) => usedTracingPropagators.add(propagatorType))\n      } else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n        // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n        option.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType))\n      }\n    })\n  }\n\n  return Array.from(usedTracingPropagators)\n}\n\nexport function serializeRumConfiguration(configuration: RumInitConfiguration) {\n  const baseSerializedConfiguration = serializeConfiguration(configuration)\n\n  return {\n    session_replay_sample_rate: configuration.sessionReplaySampleRate,\n    start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n    trace_sample_rate: configuration.traceSampleRate,\n    trace_context_injection: configuration.traceContextInjection,\n    action_name_attribute: configuration.actionNameAttribute,\n    use_allowed_tracing_urls:\n      Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\n    selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n    default_privacy_level: configuration.defaultPrivacyLevel,\n    enable_privacy_for_action_name: configuration.enablePrivacyForActionName,\n    use_excluded_activity_urls:\n      Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\n    use_worker_url: !!configuration.workerUrl,\n    compress_intake_requests: configuration.compressIntakeRequests,\n    track_views_manually: configuration.trackViewsManually,\n    track_user_interactions: configuration.trackUserInteractions,\n    track_resources: configuration.trackResources,\n    track_long_task: configuration.trackLongTasks,\n    plugins: configuration.plugins?.map((plugin) => ({\n      name: plugin.name,\n      ...plugin.getConfigurationTelemetry?.(),\n    })),\n    track_feature_flags_for_events: configuration.trackFeatureFlagsForEvents,\n    ...baseSerializedConfiguration,\n  } satisfies RawTelemetryConfiguration\n}\n","import type { DefaultPrivacyLevel } from '@datadog/browser-core'\nimport { display, addEventListener } from '@datadog/browser-core'\nimport type { RumInitConfiguration } from './configuration'\n\nexport const REMOTE_CONFIGURATION_URL = 'https://d3uc069fcn7uxw.cloudfront.net/configuration'\n\nexport interface RumRemoteConfiguration {\n  sessionSampleRate?: number\n  sessionReplaySampleRate?: number\n  defaultPrivacyLevel?: DefaultPrivacyLevel\n}\n\nexport function fetchAndApplyRemoteConfiguration(\n  initConfiguration: RumInitConfiguration,\n  callback: (initConfiguration: RumInitConfiguration) => void\n) {\n  fetchRemoteConfiguration(initConfiguration, (remoteInitConfiguration) => {\n    callback(applyRemoteConfiguration(initConfiguration, remoteInitConfiguration))\n  })\n}\n\nexport function applyRemoteConfiguration(\n  initConfiguration: RumInitConfiguration,\n  remoteInitConfiguration: RumRemoteConfiguration\n) {\n  return { ...initConfiguration, ...remoteInitConfiguration }\n}\n\nexport function fetchRemoteConfiguration(\n  configuration: RumInitConfiguration,\n  callback: (remoteConfiguration: RumRemoteConfiguration) => void\n) {\n  const xhr = new XMLHttpRequest()\n\n  addEventListener(configuration, xhr, 'load', function () {\n    if (xhr.status === 200) {\n      callback(JSON.parse(xhr.responseText))\n    } else {\n      displayRemoteConfigurationFetchingError()\n    }\n  })\n\n  addEventListener(configuration, xhr, 'error', function () {\n    displayRemoteConfigurationFetchingError()\n  })\n\n  xhr.open('GET', `${REMOTE_CONFIGURATION_URL}/${encodeURIComponent(configuration.remoteConfigurationId!)}.json`)\n  xhr.send()\n}\n\nfunction displayRemoteConfigurationFetchingError() {\n  display.error('Error fetching the remote configuration.')\n}\n","import {\n  createBoundedBuffer,\n  display,\n  canUseEventBridge,\n  displayAlreadyInitializedError,\n  willSyntheticsInjectRum,\n  noop,\n  timeStampNow,\n  clocksNow,\n  getEventBridge,\n  ExperimentalFeature,\n  isExperimentalFeatureEnabled,\n  initFeatureFlags,\n  addTelemetryConfiguration,\n  initFetchObservable,\n} from '@datadog/browser-core'\nimport type { TrackingConsentState, DeflateWorker, Context } from '@datadog/browser-core'\nimport {\n  validateAndBuildRumConfiguration,\n  type RumConfiguration,\n  type RumInitConfiguration,\n} from '../domain/configuration'\nimport type { CommonContext } from '../domain/contexts/commonContext'\nimport type { ViewOptions } from '../domain/view/trackViews'\nimport type { DurationVital, CustomVitalsState } from '../domain/vital/vitalCollection'\nimport { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection'\nimport { fetchAndApplyRemoteConfiguration, serializeRumConfiguration } from '../domain/configuration'\nimport { callPluginsMethod } from '../domain/plugins'\nimport type { RumPublicApiOptions, Strategy } from './rumPublicApi'\nimport type { StartRumResult } from './startRum'\n\nexport function createPreStartStrategy(\n  { ignoreInitIfSyntheticsWillInjectRum, startDeflateWorker }: RumPublicApiOptions,\n  getCommonContext: () => CommonContext,\n  trackingConsentState: TrackingConsentState,\n  customVitalsState: CustomVitalsState,\n  doStartRum: (\n    configuration: RumConfiguration,\n    deflateWorker: DeflateWorker | undefined,\n    initialViewOptions?: ViewOptions\n  ) => StartRumResult\n): Strategy {\n  const bufferApiCalls = createBoundedBuffer<StartRumResult>()\n\n  let firstStartViewCall:\n    | { options: ViewOptions | undefined; callback: (startRumResult: StartRumResult) => void }\n    | undefined\n  let deflateWorker: DeflateWorker | undefined\n\n  let cachedInitConfiguration: RumInitConfiguration | undefined\n  let cachedConfiguration: RumConfiguration | undefined\n\n  const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum)\n\n  const emptyContext: Context = {}\n\n  function tryStartRum() {\n    if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {\n      return\n    }\n\n    trackingConsentStateSubscription.unsubscribe()\n\n    let initialViewOptions: ViewOptions | undefined\n\n    if (cachedConfiguration.trackViewsManually) {\n      if (!firstStartViewCall) {\n        return\n      }\n      // An initial view is always created when starting RUM.\n      // When tracking views automatically, any startView call before RUM start creates an extra\n      // view.\n      // When tracking views manually, we use the ViewOptions from the first startView call as the\n      // initial view options, and we remove the actual startView call so we don't create an extra\n      // view.\n      bufferApiCalls.remove(firstStartViewCall.callback)\n      initialViewOptions = firstStartViewCall.options\n    }\n\n    const startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions)\n\n    bufferApiCalls.drain(startRumResult)\n  }\n\n  function doInit(initConfiguration: RumInitConfiguration) {\n    const eventBridgeAvailable = canUseEventBridge()\n    if (eventBridgeAvailable) {\n      initConfiguration = overrideInitConfigurationForBridge(initConfiguration)\n    }\n\n    // Update the exposed initConfiguration to reflect the bridge and remote configuration overrides\n    cachedInitConfiguration = initConfiguration\n    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration))\n\n    if (cachedConfiguration) {\n      displayAlreadyInitializedError('DD_RUM', initConfiguration)\n      return\n    }\n\n    const configuration = validateAndBuildRumConfiguration(initConfiguration)\n    if (!configuration) {\n      return\n    }\n\n    if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {\n      display.warn('No storage available for session. We will not send any data.')\n      return\n    }\n\n    if (configuration.compressIntakeRequests && !eventBridgeAvailable && startDeflateWorker) {\n      deflateWorker = startDeflateWorker(\n        configuration,\n        'Datadog RUM',\n        // Worker initialization can fail asynchronously, especially in Firefox where even CSP\n        // issues are reported asynchronously. For now, the SDK will continue its execution even if\n        // data won't be sent to Datadog. We could improve this behavior in the future.\n        noop\n      )\n      if (!deflateWorker) {\n        // `startDeflateWorker` should have logged an error message explaining the issue\n        return\n      }\n    }\n\n    cachedConfiguration = configuration\n    // Instrumuent fetch to track network requests\n    // This is needed in case the consent is not granted and some cutsomer\n    // library (Apollo Client) is storing uninstrumented fetch to be used later\n    // The subscrption is needed so that the instrumentation process is completed\n    initFetchObservable().subscribe(noop)\n\n    trackingConsentState.tryToInit(configuration.trackingConsent)\n    tryStartRum()\n  }\n\n  const addDurationVital = (vital: DurationVital) => {\n    bufferApiCalls.add((startRumResult) => startRumResult.addDurationVital(vital))\n  }\n\n  const strategy: Strategy = {\n    init(initConfiguration, publicApi) {\n      if (!initConfiguration) {\n        display.error('Missing configuration')\n        return\n      }\n      // Set the experimental feature flags as early as possible, so we can use them in most places\n      initFeatureFlags(initConfiguration.enableExperimentalFeatures)\n\n      // Expose the initial configuration regardless of initialization success.\n      cachedInitConfiguration = initConfiguration\n\n      // If we are in a Synthetics test configured to automatically inject a RUM instance, we want\n      // to completely discard the customer application RUM instance by ignoring their init() call.\n      // But, we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n      // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n      if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n        return\n      }\n\n      callPluginsMethod(initConfiguration.plugins, 'onInit', { initConfiguration, publicApi })\n\n      if (\n        initConfiguration.remoteConfigurationId &&\n        isExperimentalFeatureEnabled(ExperimentalFeature.REMOTE_CONFIGURATION)\n      ) {\n        fetchAndApplyRemoteConfiguration(initConfiguration, doInit)\n      } else {\n        doInit(initConfiguration)\n      }\n    },\n\n    get initConfiguration() {\n      return cachedInitConfiguration\n    },\n\n    getInternalContext: noop as () => undefined,\n\n    stopSession: noop,\n\n    addTiming(name, time = timeStampNow()) {\n      bufferApiCalls.add((startRumResult) => startRumResult.addTiming(name, time))\n    },\n\n    startView(options, startClocks = clocksNow()) {\n      const callback = (startRumResult: StartRumResult) => {\n        startRumResult.startView(options, startClocks)\n      }\n      bufferApiCalls.add(callback)\n\n      if (!firstStartViewCall) {\n        firstStartViewCall = { options, callback }\n        tryStartRum()\n      }\n    },\n\n    setViewName(name) {\n      bufferApiCalls.add((startRumResult) => startRumResult.setViewName(name))\n    },\n\n    setViewContext(context) {\n      bufferApiCalls.add((startRumResult) => startRumResult.setViewContext(context))\n    },\n\n    setViewContextProperty(key, value) {\n      bufferApiCalls.add((startRumResult) => startRumResult.setViewContextProperty(key, value))\n    },\n\n    getViewContext: () => emptyContext,\n\n    addAction(action, commonContext = getCommonContext()) {\n      bufferApiCalls.add((startRumResult) => startRumResult.addAction(action, commonContext))\n    },\n\n    addError(providedError, commonContext = getCommonContext()) {\n      bufferApiCalls.add((startRumResult) => startRumResult.addError(providedError, commonContext))\n    },\n\n    addFeatureFlagEvaluation(key, value) {\n      bufferApiCalls.add((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value))\n    },\n\n    startDurationVital(name, options) {\n      return startDurationVital(customVitalsState, name, options)\n    },\n\n    stopDurationVital(name, options) {\n      stopDurationVital(addDurationVital, customVitalsState, name, options)\n    },\n\n    addDurationVital,\n  }\n\n  return strategy\n}\n\nfunction overrideInitConfigurationForBridge(initConfiguration: RumInitConfiguration): RumInitConfiguration {\n  return {\n    ...initConfiguration,\n    applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n    clientToken: 'empty',\n    sessionSampleRate: 100,\n    defaultPrivacyLevel: initConfiguration.defaultPrivacyLevel ?? getEventBridge()?.getPrivacyLevel(),\n  }\n}\n","import type {\n  Context,\n  TimeStamp,\n  RelativeTime,\n  User,\n  DeflateWorker,\n  DeflateEncoderStreamId,\n  DeflateEncoder,\n  TrackingConsent,\n  PublicApi,\n  Duration,\n} from '@datadog/browser-core'\nimport {\n  addTelemetryUsage,\n  CustomerDataType,\n  createContextManager,\n  deepClone,\n  makePublicApi,\n  monitor,\n  clocksNow,\n  callMonitored,\n  createHandlingStack,\n  checkUser,\n  sanitizeUser,\n  sanitize,\n  createIdentityEncoder,\n  CustomerDataCompressionStatus,\n  createCustomerDataTrackerManager,\n  storeContextManager,\n  displayAlreadyInitializedError,\n  createTrackingConsentState,\n  timeStampToClocks,\n} from '@datadog/browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport type { ViewHistory } from '../domain/contexts/viewHistory'\nimport type { RumSessionManager } from '../domain/rumSessionManager'\nimport type { ReplayStats } from '../rawRumEvent.types'\nimport { ActionType, VitalType } from '../rawRumEvent.types'\nimport type { RumConfiguration, RumInitConfiguration } from '../domain/configuration'\nimport type { ViewOptions } from '../domain/view/trackViews'\nimport { buildCommonContext } from '../domain/contexts/commonContext'\nimport type { InternalContext } from '../domain/contexts/internalContext'\nimport type { DurationVitalReference } from '../domain/vital/vitalCollection'\nimport { createCustomVitalsState } from '../domain/vital/vitalCollection'\nimport { callPluginsMethod } from '../domain/plugins'\nimport { createPreStartStrategy } from './preStartRum'\nimport type { StartRum, StartRumResult } from './startRum'\n\nexport interface StartRecordingOptions {\n  force: boolean\n}\nexport interface RumPublicApi extends PublicApi {\n  /**\n   * Init the RUM browser SDK.\n   * @param initConfiguration Configuration options of the SDK\n   *\n   * See [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser) for further information.\n   */\n  init: (initConfiguration: RumInitConfiguration) => void\n\n  /**\n   * Set the tracking consent of the current user.\n   *\n   * @param {\"granted\" | \"not-granted\"} trackingConsent The user tracking consent\n   *\n   * Data will be sent only if it is set to \"granted\". This value won't be stored by the library\n   * across page loads: you will need to call this method or set the appropriate `trackingConsent`\n   * field in the init() method at each page load.\n   *\n   * If this method is called before the init() method, the provided value will take precedence\n   * over the one provided as initialization parameter.\n   *\n   * See [User tracking consent](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-tracking-consent) for further information.\n   */\n  setTrackingConsent: (trackingConsent: TrackingConsent) => void\n\n  /**\n   * Set View Name.\n   *\n   * Enable to manually change the name of the current view.\n   * @param name name of the view\n   * See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#override-default-rum-view-names) for further information.\n   */\n  setViewName: (name: string) => void\n\n  /**\n   * Set View Context.\n   *\n   * Enable to manually set the context of the current view.\n   * @param context context of the view\n   */\n  setViewContext: (context: Context) => void\n  /**\n   * Set View Context Property.\n   *\n   * Enable to manually set a property of the context of the current view.\n   * @param key key of the property\n   * @param value value of the property\n   */\n  setViewContextProperty: (key: string, value: any) => void\n\n  /**\n   * Get View Context.\n   */\n  getViewContext: () => Context\n\n  /**\n   * Set the global context information to all events, stored in `@context`\n   *\n   * @param context Global context\n   *\n   * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.\n   */\n  setGlobalContext: (context: any) => void\n\n  /**\n   * Get the global Context\n   *\n   * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.\n   */\n  getGlobalContext: () => Context\n\n  /**\n   * Set or update a global context property, stored in `@context.<key>`\n   *\n   * @param key Key of the property\n   * @param property Value of the property\n   *\n   * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.\n   */\n  setGlobalContextProperty: (key: any, value: any) => void\n\n  /**\n   * Remove a global context property\n   *\n   * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.\n   */\n  removeGlobalContextProperty: (key: any) => void\n\n  /**\n   * Clear the global context\n   *\n   * See [Global context](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#global-context) for further information.\n   */\n  clearGlobalContext: () => void\n\n  /**\n   * [Internal API] Get the internal SDK context\n   */\n  getInternalContext: (startTime?: number) => InternalContext | undefined\n\n  /**\n   * Get the init configuration\n   */\n  getInitConfiguration: () => RumInitConfiguration | undefined\n\n  /**\n   * Add a custom action, stored in `@action`\n   * @param name Name of the action\n   * @param context Context of the action\n   *\n   * See [Send RUM Custom Actions](https://docs.datadoghq.com/real_user_monitoring/guide/send-rum-custom-actions) for further information.\n   */\n  addAction: (name: string, context?: object) => void\n\n  /**\n   * Add a custom error, stored in `@error`.\n   * @param error Error. Favor sending a [Javascript Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) to have a stack trace attached to the error event.\n   * @param context Context of the error\n   *\n   * See [Send RUM Custom Actions](https://docs.datadoghq.com/real_user_monitoring/guide/send-rum-custom-actions) for further information.\n   */\n  addError: (error: unknown, context?: object) => void\n\n  /**\n   * Add a custom timing relative to the start of the current view,\n   * stored in `@view.custom_timings.<timing_name>`\n   *\n   * @param name Name of the custom timing\n   * @param [time] Epoch timestamp of the custom timing (if not set, will use current time)\n   *\n   * Note: passing a relative time is discouraged since it is actually used as-is but displayed relative to the view start.\n   * We currently don't provide a way to retrieve the view start time, so it can be challenging to provide a timing relative to the view start.\n   * see https://github.com/DataDog/browser-sdk/issues/2552\n   */\n  addTiming: (name: string, time?: number) => void\n\n  /**\n   * Set user information to all events, stored in `@usr`\n   *\n   * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.\n   */\n  setUser: (newUser: User) => void\n\n  /**\n   * Get user information\n   *\n   * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.\n   */\n  getUser: () => Context\n\n  /**\n   * Set or update the user property, stored in `@usr.<key>`\n   *\n   * @param key Key of the property\n   * @param property Value of the property\n   *\n   * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.\n   */\n  setUserProperty: (key: any, property: any) => void\n\n  /**\n   * Remove a user property\n   *\n   * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.\n   */\n  removeUserProperty: (key: any) => void\n\n  /**\n   * Clear all user information\n   *\n   * See [User session](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#user-session) for further information.\n   */\n  clearUser: () => void\n\n  /**\n   * Start a view manually.\n   * Enable to manual start a view, use `trackViewsManually: true` init parameter and call `startView()` to create RUM views and be aligned with how you’ve defined them in your SPA application routing.\n   *\n   * @param options.name name of the view\n   * @param options.service service of the view\n   * @param options.version version of the view\n   *\n   * See [Override default RUM view names](https://docs.datadoghq.com/real_user_monitoring/browser/advanced_configuration/#override-default-rum-view-names) for further information.\n   */\n  startView: {\n    (name?: string): void\n    (options: ViewOptions): void\n  }\n\n  /**\n   * Stop the session. A new session will start at the next user interaction with the page.\n   */\n  stopSession: () => void\n\n  /**\n   * Add a feature flag evaluation,\n   * stored in `@feature_flags.<feature_flag_key>`\n   *\n   * @param {string} key The key of the feature flag.\n   * @param {any} value The value of the feature flag.\n   *\n   * We recommend enabling the intake request compression when using feature flags `compressIntakeRequests: true`.\n   *\n   * See [Feature Flag Tracking](https://docs.datadoghq.com/real_user_monitoring/feature_flag_tracking/) for further information.\n   */\n  addFeatureFlagEvaluation: (key: string, value: any) => void\n\n  /**\n   * Get the Session Replay Link.\n   *\n   * See [Connect Session Replay To Your Third-Party Tools](https://docs.datadoghq.com/real_user_monitoring/guide/connect-session-replay-to-your-third-party-tools) for further information.\n   */\n  getSessionReplayLink: () => string | undefined\n\n  /**\n   * Start Session Replay recording.\n   * Enable to conditionally start the recording, use the `startSessionReplayRecordingManually:true` init parameter and call `startSessionReplayRecording()`\n   *\n   * See [Browser Session Replay](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser) for further information.\n   */\n  startSessionReplayRecording: (options?: StartRecordingOptions) => void\n\n  /**\n   * Stop Session Replay recording.\n   *\n   * See [Browser Session Replay](https://docs.datadoghq.com/real_user_monitoring/session_replay/browser) for further information.\n   */\n  stopSessionReplayRecording: () => void\n\n  /**\n   * Add a custom duration vital\n   *\n   * @param name name of the custom vital\n   * @param options.startTime epoch timestamp of the start of the custom vital\n   * @param options.duration duration of the custom vital in millisecond\n   * @param options.context custom context attached to the vital\n   * @param options.description  Description of the vital\n   */\n  addDurationVital: (\n    name: string,\n    options: { startTime: number; duration: number; context?: object; description?: string }\n  ) => void\n\n  /**\n   * Start a custom duration vital.\n   *\n   * If you plan to have multiple durations for the same vital, you should use the reference returned by this method.\n   *\n   * @param name name of the custom vital\n   * @param options.context custom context attached to the vital\n   * @param options.description Description of the vital\n   * @returns reference to the custom vital\n   */\n  startDurationVital: (name: string, options?: { context?: object; description?: string }) => DurationVitalReference\n\n  /**\n   * Stop a custom duration vital\n   *\n   * @param nameOrRef name of the custom vital or the reference to it\n   * @param options.context custom context attached to the vital\n   * @param options.description Description of the vital\n   */\n  stopDurationVital: (\n    nameOrRef: string | DurationVitalReference,\n    options?: { context?: object; description?: string }\n  ) => void\n}\n\nexport interface RecorderApi {\n  start: (options?: StartRecordingOptions) => void\n  stop: () => void\n  onRumStart: (\n    lifeCycle: LifeCycle,\n    configuration: RumConfiguration,\n    sessionManager: RumSessionManager,\n    viewHistory: ViewHistory,\n    deflateWorker: DeflateWorker | undefined\n  ) => void\n  isRecording: () => boolean\n  getReplayStats: (viewId: string) => ReplayStats | undefined\n  getSessionReplayLink: () => string | undefined\n}\n\nexport interface RumPublicApiOptions {\n  ignoreInitIfSyntheticsWillInjectRum?: boolean\n  startDeflateWorker?: (\n    configuration: RumConfiguration,\n    source: string,\n    onInitializationFailure: () => void\n  ) => DeflateWorker | undefined\n  createDeflateEncoder?: (\n    configuration: RumConfiguration,\n    worker: DeflateWorker,\n    streamId: DeflateEncoderStreamId\n  ) => DeflateEncoder\n}\n\nconst RUM_STORAGE_KEY = 'rum'\n\nexport interface Strategy {\n  init: (initConfiguration: RumInitConfiguration, publicApi: RumPublicApi) => void\n  initConfiguration: RumInitConfiguration | undefined\n  getInternalContext: StartRumResult['getInternalContext']\n  stopSession: StartRumResult['stopSession']\n  addTiming: StartRumResult['addTiming']\n  startView: StartRumResult['startView']\n  setViewName: StartRumResult['setViewName']\n  setViewContext: StartRumResult['setViewContext']\n  setViewContextProperty: StartRumResult['setViewContextProperty']\n  getViewContext: StartRumResult['getViewContext']\n  addAction: StartRumResult['addAction']\n  addError: StartRumResult['addError']\n  addFeatureFlagEvaluation: StartRumResult['addFeatureFlagEvaluation']\n  startDurationVital: StartRumResult['startDurationVital']\n  stopDurationVital: StartRumResult['stopDurationVital']\n  addDurationVital: StartRumResult['addDurationVital']\n}\n\nexport function makeRumPublicApi(\n  startRumImpl: StartRum,\n  recorderApi: RecorderApi,\n  options: RumPublicApiOptions = {}\n): RumPublicApi {\n  const customerDataTrackerManager = createCustomerDataTrackerManager(CustomerDataCompressionStatus.Unknown)\n  const globalContextManager = createContextManager(\n    customerDataTrackerManager.getOrCreateTracker(CustomerDataType.GlobalContext)\n  )\n  const userContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(CustomerDataType.User))\n  const trackingConsentState = createTrackingConsentState()\n  const customVitalsState = createCustomVitalsState()\n\n  function getCommonContext() {\n    return buildCommonContext(globalContextManager, userContextManager, recorderApi)\n  }\n\n  let strategy = createPreStartStrategy(\n    options,\n    getCommonContext,\n    trackingConsentState,\n    customVitalsState,\n    (configuration, deflateWorker, initialViewOptions) => {\n      if (configuration.storeContextsAcrossPages) {\n        storeContextManager(configuration, globalContextManager, RUM_STORAGE_KEY, CustomerDataType.GlobalContext)\n        storeContextManager(configuration, userContextManager, RUM_STORAGE_KEY, CustomerDataType.User)\n      }\n\n      customerDataTrackerManager.setCompressionStatus(\n        deflateWorker ? CustomerDataCompressionStatus.Enabled : CustomerDataCompressionStatus.Disabled\n      )\n\n      const startRumResult = startRumImpl(\n        configuration,\n        recorderApi,\n        customerDataTrackerManager,\n        getCommonContext,\n        initialViewOptions,\n        deflateWorker && options.createDeflateEncoder\n          ? (streamId) => options.createDeflateEncoder!(configuration, deflateWorker, streamId)\n          : createIdentityEncoder,\n        trackingConsentState,\n        customVitalsState\n      )\n\n      recorderApi.onRumStart(\n        startRumResult.lifeCycle,\n        configuration,\n        startRumResult.session,\n        startRumResult.viewHistory,\n        deflateWorker\n      )\n\n      strategy = createPostStartStrategy(strategy, startRumResult)\n\n      callPluginsMethod(configuration.plugins, 'onRumStart', { strategy })\n\n      return startRumResult\n    }\n  )\n\n  const startView: {\n    (name?: string): void\n    (options: ViewOptions): void\n  } = monitor((options?: string | ViewOptions) => {\n    const sanitizedOptions = typeof options === 'object' ? options : { name: options }\n    if (sanitizedOptions.context) {\n      customerDataTrackerManager.getOrCreateTracker(CustomerDataType.View).updateCustomerData(sanitizedOptions.context)\n    }\n    strategy.startView(sanitizedOptions)\n    addTelemetryUsage({ feature: 'start-view' })\n  })\n\n  const rumPublicApi: RumPublicApi = makePublicApi<RumPublicApi>({\n    init: monitor((initConfiguration) => {\n      strategy.init(initConfiguration, rumPublicApi)\n    }),\n\n    setTrackingConsent: monitor((trackingConsent) => {\n      trackingConsentState.update(trackingConsent)\n      addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent })\n    }),\n\n    setViewName: monitor((name: string) => {\n      strategy.setViewName(name)\n    }),\n\n    setViewContext: monitor((context: Context) => {\n      strategy.setViewContext(context)\n    }),\n\n    setViewContextProperty: monitor((key: string, value: any) => {\n      strategy.setViewContextProperty(key, value)\n    }),\n\n    getViewContext: monitor(() => strategy.getViewContext()),\n\n    setGlobalContext: monitor((context) => {\n      globalContextManager.setContext(context)\n      addTelemetryUsage({ feature: 'set-global-context' })\n    }),\n\n    getGlobalContext: monitor(() => globalContextManager.getContext()),\n\n    setGlobalContextProperty: monitor((key, value) => {\n      globalContextManager.setContextProperty(key, value)\n      addTelemetryUsage({ feature: 'set-global-context' })\n    }),\n\n    removeGlobalContextProperty: monitor((key) => globalContextManager.removeContextProperty(key)),\n\n    clearGlobalContext: monitor(() => globalContextManager.clearContext()),\n\n    getInternalContext: monitor((startTime) => strategy.getInternalContext(startTime)),\n\n    getInitConfiguration: monitor(() => deepClone(strategy.initConfiguration)),\n\n    addAction: (name, context) => {\n      const handlingStack = createHandlingStack()\n\n      callMonitored(() => {\n        strategy.addAction({\n          name: sanitize(name)!,\n          context: sanitize(context) as Context,\n          startClocks: clocksNow(),\n          type: ActionType.CUSTOM,\n          handlingStack,\n        })\n        addTelemetryUsage({ feature: 'add-action' })\n      })\n    },\n\n    addError: (error, context) => {\n      const handlingStack = createHandlingStack()\n      callMonitored(() => {\n        strategy.addError({\n          error, // Do not sanitize error here, it is needed unserialized by computeRawError()\n          handlingStack,\n          context: sanitize(context) as Context,\n          startClocks: clocksNow(),\n        })\n        addTelemetryUsage({ feature: 'add-error' })\n      })\n    },\n\n    addTiming: monitor((name, time) => {\n      // TODO: next major decide to drop relative time support or update its behaviour\n      strategy.addTiming(sanitize(name)!, time as RelativeTime | TimeStamp | undefined)\n    }),\n\n    setUser: monitor((newUser) => {\n      if (checkUser(newUser)) {\n        userContextManager.setContext(sanitizeUser(newUser as Context))\n      }\n      addTelemetryUsage({ feature: 'set-user' })\n    }),\n\n    getUser: monitor(() => userContextManager.getContext()),\n\n    setUserProperty: monitor((key, property) => {\n      const sanitizedProperty = sanitizeUser({ [key]: property })[key]\n      userContextManager.setContextProperty(key, sanitizedProperty)\n      addTelemetryUsage({ feature: 'set-user' })\n    }),\n\n    removeUserProperty: monitor((key) => userContextManager.removeContextProperty(key)),\n\n    clearUser: monitor(() => userContextManager.clearContext()),\n\n    startView,\n\n    stopSession: monitor(() => {\n      strategy.stopSession()\n      addTelemetryUsage({ feature: 'stop-session' })\n    }),\n\n    addFeatureFlagEvaluation: monitor((key, value) => {\n      strategy.addFeatureFlagEvaluation(sanitize(key)!, sanitize(value))\n      addTelemetryUsage({ feature: 'add-feature-flag-evaluation' })\n    }),\n\n    getSessionReplayLink: monitor(() => recorderApi.getSessionReplayLink()),\n    startSessionReplayRecording: monitor((options?: StartRecordingOptions) => {\n      recorderApi.start(options)\n      addTelemetryUsage({ feature: 'start-session-replay-recording', force: options && options.force })\n    }),\n\n    stopSessionReplayRecording: monitor(() => recorderApi.stop()),\n\n    addDurationVital: monitor((name, options) => {\n      addTelemetryUsage({ feature: 'add-duration-vital' })\n      strategy.addDurationVital({\n        name: sanitize(name)!,\n        type: VitalType.DURATION,\n        startClocks: timeStampToClocks(options.startTime as TimeStamp),\n        duration: options.duration as Duration,\n        context: sanitize(options && options.context) as Context,\n        description: sanitize(options && options.description) as string | undefined,\n      })\n    }),\n\n    startDurationVital: monitor((name, options) => {\n      addTelemetryUsage({ feature: 'start-duration-vital' })\n      return strategy.startDurationVital(sanitize(name)!, {\n        context: sanitize(options && options.context) as Context,\n        description: sanitize(options && options.description) as string | undefined,\n      })\n    }),\n\n    stopDurationVital: monitor((nameOrRef, options) => {\n      addTelemetryUsage({ feature: 'stop-duration-vital' })\n      strategy.stopDurationVital(typeof nameOrRef === 'string' ? sanitize(nameOrRef)! : nameOrRef, {\n        context: sanitize(options && options.context) as Context,\n        description: sanitize(options && options.description) as string | undefined,\n      })\n    }),\n  })\n\n  return rumPublicApi\n}\n\nfunction createPostStartStrategy(preStartStrategy: Strategy, startRumResult: StartRumResult): Strategy {\n  return {\n    init: (initConfiguration: RumInitConfiguration) => {\n      displayAlreadyInitializedError('DD_RUM', initConfiguration)\n    },\n    initConfiguration: preStartStrategy.initConfiguration,\n    ...startRumResult,\n  }\n}\n","import type { Context, ContextManager, User } from '@datadog/browser-core'\nimport type { RecorderApi } from '../../boot/rumPublicApi'\n\nexport interface CommonContext {\n  user: User\n  context: Context\n  hasReplay: true | undefined\n}\n\nexport function buildCommonContext(\n  globalContextManager: ContextManager,\n  userContextManager: ContextManager,\n  recorderApi: RecorderApi\n): CommonContext {\n  return {\n    context: globalContextManager.getContext(),\n    user: userContextManager.getContext(),\n    hasReplay: recorderApi.isRecording() ? true : undefined,\n  }\n}\n","import { monitor, noop, Observable, getZoneJsOriginalValue } from '@datadog/browser-core'\n\nexport function createDOMMutationObservable() {\n  const MutationObserver = getMutationObserverConstructor()\n\n  return new Observable<void>((observable) => {\n    if (!MutationObserver) {\n      return\n    }\n    const observer = new MutationObserver(monitor(() => observable.notify()))\n    observer.observe(document, {\n      attributes: true,\n      characterData: true,\n      childList: true,\n      subtree: true,\n    })\n    return () => observer.disconnect()\n  })\n}\n\ntype MutationObserverConstructor = new (callback: MutationCallback) => MutationObserver\n\nexport interface BrowserWindow extends Window {\n  MutationObserver?: MutationObserverConstructor\n  Zone?: unknown\n}\n\nexport function getMutationObserverConstructor(): MutationObserverConstructor | undefined {\n  let constructor: MutationObserverConstructor | undefined\n  const browserWindow: BrowserWindow = window\n\n  // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n  // global MutationObserver constructor with a patched version to support the context propagation.\n  // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n  // component: on some occasions, the callback is being called in an infinite loop, causing the\n  // page to freeze (even if the callback is completely empty).\n  //\n  // To work around this issue, we try to get the original MutationObserver constructor stored by\n  // Zone.js.\n  //\n  // [1] https://github.com/angular/angular/issues/26948\n  // [2] https://github.com/angular/angular/issues/31712\n  if (browserWindow.Zone) {\n    // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n    //\n    // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n    constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver')\n\n    if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n      // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n      // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n      // instance in its properties[4]. Let's get the original MutationObserver constructor from\n      // there.\n      //\n      // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n\n      const patchedInstance = new browserWindow.MutationObserver(noop) as {\n        originalInstance?: { constructor: MutationObserverConstructor }\n      }\n\n      const originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance')\n      constructor = originalInstance && originalInstance.constructor\n    }\n  }\n\n  if (!constructor) {\n    constructor = browserWindow.MutationObserver\n  }\n\n  return constructor\n}\n","import { setTimeout } from '../../tools/timer'\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils'\nimport type { RawError } from '../error/error.types'\nimport { ErrorSource } from '../error/error.types'\n\nexport type EventRateLimiter = ReturnType<typeof createEventRateLimiter>\n\nexport function createEventRateLimiter(\n  eventType: string,\n  limit: number,\n  onLimitReached: (limitError: RawError) => void\n) {\n  let eventCount = 0\n  let allowNextEvent = false\n\n  return {\n    isLimitReached() {\n      if (eventCount === 0) {\n        setTimeout(() => {\n          eventCount = 0\n        }, ONE_MINUTE)\n      }\n\n      eventCount += 1\n      if (eventCount <= limit || allowNextEvent) {\n        allowNextEvent = false\n        return false\n      }\n\n      if (eventCount === limit + 1) {\n        allowNextEvent = true\n        try {\n          onLimitReached({\n            message: `Reached max number of ${eventType}s by minute: ${limit}`,\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n          })\n        } finally {\n          allowNextEvent = false\n        }\n      }\n\n      return true\n    },\n  }\n}\n","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core'\nimport type { Context } from '@datadog/browser-core'\n\nexport type ModifiableFieldPaths = Record<string, 'string' | 'object'>\n\n/**\n * Current limitation:\n * - field path do not support array, 'a.b.c' only\n */\nexport function limitModification<T extends Context, Result>(\n  object: T,\n  modifiableFieldPaths: ModifiableFieldPaths,\n  modifier: (object: T) => Result\n): Result | undefined {\n  const clone = deepClone(object)\n  const result = modifier(clone)\n  objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => {\n    const newValue = get(clone, fieldPath)\n    const newType = getType(newValue)\n    if (newType === fieldType) {\n      set(object, fieldPath, sanitize(newValue))\n    } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n      set(object, fieldPath, {})\n    }\n  })\n  return result\n}\n\nfunction get(object: unknown, path: string) {\n  let current = object\n  for (const field of path.split('.')) {\n    if (!isValidObjectContaining(current, field)) {\n      return\n    }\n    current = current[field]\n  }\n  return current\n}\n\nfunction set(object: unknown, path: string, value: unknown) {\n  let current = object\n  const fields = path.split('.')\n  for (let i = 0; i < fields.length; i += 1) {\n    const field = fields[i]\n    if (!isValidObject(current)) {\n      return\n    }\n    if (i !== fields.length - 1) {\n      current = current[field]\n    } else {\n      current[field] = value\n    }\n  }\n}\n\nfunction isValidObject(object: unknown): object is Record<string, unknown> {\n  return getType(object) === 'object'\n}\n\nfunction isValidObjectContaining(object: unknown, field: string): object is Record<string, unknown> {\n  return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field)\n}\n","import type { Context, RawError, EventRateLimiter, User, RelativeTime } from '@datadog/browser-core'\nimport {\n  combine,\n  isEmptyObject,\n  timeStampNow,\n  currentDrift,\n  display,\n  createEventRateLimiter,\n  canUseEventBridge,\n  round,\n  isExperimentalFeatureEnabled,\n  ExperimentalFeature,\n  getConnectivity,\n} from '@datadog/browser-core'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type {\n  RawRumErrorEvent,\n  RawRumEvent,\n  RawRumLongTaskEvent,\n  RawRumResourceEvent,\n  RumContext,\n} from '../rawRumEvent.types'\nimport { RumEventType } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\nimport type { FeatureFlagContexts } from './contexts/featureFlagContext'\nimport { getSyntheticsContext } from './contexts/syntheticsContext'\nimport type { CiVisibilityContext } from './contexts/ciVisibilityContext'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\nimport type { ViewHistory } from './contexts/viewHistory'\nimport { SessionReplayState, type RumSessionManager } from './rumSessionManager'\nimport type { UrlContexts } from './contexts/urlContexts'\nimport type { RumConfiguration, FeatureFlagsForEvents } from './configuration'\nimport type { ActionContexts } from './action/actionCollection'\nimport type { DisplayContext } from './contexts/displayContext'\nimport type { CommonContext } from './contexts/commonContext'\nimport type { ModifiableFieldPaths } from './limitModification'\nimport { limitModification } from './limitModification'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nconst enum SessionType {\n  SYNTHETICS = 'synthetics',\n  USER = 'user',\n  CI_TEST = 'ci_test',\n}\n\nconst VIEW_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {\n  'view.name': 'string',\n  'view.url': 'string',\n  'view.referrer': 'string',\n}\n\nconst USER_CUSTOMIZABLE_FIELD_PATHS: ModifiableFieldPaths = {\n  context: 'object',\n}\n\nconst ROOT_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {\n  service: 'string',\n  version: 'string',\n}\n\nlet modifiableFieldPathsByEvent: { [key in RumEventType]: ModifiableFieldPaths }\n\ntype Mutable<T> = { -readonly [P in keyof T]: T[P] }\n\nexport function startRumAssembly(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  sessionManager: RumSessionManager,\n  viewHistory: ViewHistory,\n  urlContexts: UrlContexts,\n  actionContexts: ActionContexts,\n  displayContext: DisplayContext,\n  ciVisibilityContext: CiVisibilityContext,\n  featureFlagContexts: FeatureFlagContexts,\n  getCommonContext: () => CommonContext,\n  reportError: (error: RawError) => void\n) {\n  modifiableFieldPathsByEvent = {\n    [RumEventType.VIEW]: { ...USER_CUSTOMIZABLE_FIELD_PATHS, ...VIEW_MODIFIABLE_FIELD_PATHS },\n    [RumEventType.ERROR]: {\n      'error.message': 'string',\n      'error.stack': 'string',\n      'error.resource.url': 'string',\n      'error.fingerprint': 'string',\n      ...USER_CUSTOMIZABLE_FIELD_PATHS,\n      ...VIEW_MODIFIABLE_FIELD_PATHS,\n      ...ROOT_MODIFIABLE_FIELD_PATHS,\n    },\n    [RumEventType.RESOURCE]: {\n      'resource.url': 'string',\n      ...(isExperimentalFeatureEnabled(ExperimentalFeature.WRITABLE_RESOURCE_GRAPHQL)\n        ? { 'resource.graphql': 'object' }\n        : {}),\n      ...USER_CUSTOMIZABLE_FIELD_PATHS,\n      ...VIEW_MODIFIABLE_FIELD_PATHS,\n      ...ROOT_MODIFIABLE_FIELD_PATHS,\n    },\n    [RumEventType.ACTION]: {\n      'action.target.name': 'string',\n      ...USER_CUSTOMIZABLE_FIELD_PATHS,\n      ...VIEW_MODIFIABLE_FIELD_PATHS,\n      ...ROOT_MODIFIABLE_FIELD_PATHS,\n    },\n    [RumEventType.LONG_TASK]: {\n      ...USER_CUSTOMIZABLE_FIELD_PATHS,\n      ...VIEW_MODIFIABLE_FIELD_PATHS,\n    },\n    [RumEventType.VITAL]: {\n      ...USER_CUSTOMIZABLE_FIELD_PATHS,\n      ...VIEW_MODIFIABLE_FIELD_PATHS,\n    },\n  }\n  const eventRateLimiters = {\n    [RumEventType.ERROR]: createEventRateLimiter(\n      RumEventType.ERROR,\n      configuration.eventRateLimiterThreshold,\n      reportError\n    ),\n    [RumEventType.ACTION]: createEventRateLimiter(\n      RumEventType.ACTION,\n      configuration.eventRateLimiterThreshold,\n      reportError\n    ),\n    [RumEventType.VITAL]: createEventRateLimiter(\n      RumEventType.VITAL,\n      configuration.eventRateLimiterThreshold,\n      reportError\n    ),\n  }\n\n  const syntheticsContext = getSyntheticsContext()\n  lifeCycle.subscribe(\n    LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n    ({ startTime, rawRumEvent, domainContext, savedCommonContext, customerContext }) => {\n      const viewHistoryEntry = viewHistory.findView(startTime)\n      const urlContext = urlContexts.findUrl(startTime)\n      const session = sessionManager.findTrackedSession(startTime)\n      if (session && viewHistoryEntry && urlContext) {\n        const commonContext = savedCommonContext || getCommonContext()\n        const actionId = actionContexts.findActionId(startTime)\n\n        const rumContext: RumContext = {\n          _dd: {\n            format_version: 2,\n            drift: currentDrift(),\n            configuration: {\n              session_sample_rate: round(configuration.sessionSampleRate, 3),\n              session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),\n            },\n            browser_sdk_version: canUseEventBridge() ? __BUILD_ENV__SDK_VERSION__ : undefined,\n          },\n          application: {\n            id: configuration.applicationId,\n          },\n          date: timeStampNow(),\n          service: viewHistoryEntry.service || configuration.service,\n          version: viewHistoryEntry.version || configuration.version,\n          source: 'browser',\n          session: {\n            id: session.id,\n            type: syntheticsContext\n              ? SessionType.SYNTHETICS\n              : ciVisibilityContext.get()\n                ? SessionType.CI_TEST\n                : SessionType.USER,\n          },\n          view: {\n            id: viewHistoryEntry.id,\n            name: viewHistoryEntry.name,\n            url: urlContext.url,\n            referrer: urlContext.referrer,\n          },\n          feature_flags: findFeatureFlagsContext(\n            rawRumEvent,\n            startTime,\n            configuration.trackFeatureFlagsForEvents,\n            featureFlagContexts\n          ),\n          action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n          synthetics: syntheticsContext,\n          ci_test: ciVisibilityContext.get(),\n          display: displayContext.get(),\n          connectivity: getConnectivity(),\n        }\n\n        const serverRumEvent = combine(rumContext as RumContext & Context, rawRumEvent) as RumEvent & Context\n        serverRumEvent.context = combine(commonContext.context, viewHistoryEntry.context, customerContext)\n\n        if (!('has_replay' in serverRumEvent.session)) {\n          ;(serverRumEvent.session as Mutable<RumEvent['session']>).has_replay = commonContext.hasReplay\n        }\n        if (serverRumEvent.type === 'view') {\n          ;(serverRumEvent.session as Mutable<RumEvent['session']>).sampled_for_replay =\n            session.sessionReplay === SessionReplayState.SAMPLED\n        }\n\n        if (session.anonymousId && !commonContext.user.anonymous_id && !!configuration.trackAnonymousUser) {\n          commonContext.user.anonymous_id = session.anonymousId\n        }\n        if (!isEmptyObject(commonContext.user)) {\n          ;(serverRumEvent.usr as Mutable<RumEvent['usr']>) = commonContext.user as User & Context\n        }\n\n        if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n          if (isEmptyObject(serverRumEvent.context)) {\n            delete serverRumEvent.context\n          }\n          lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent)\n        }\n      }\n    }\n  )\n}\n\nfunction shouldSend(\n  event: RumEvent & Context,\n  beforeSend: RumConfiguration['beforeSend'],\n  domainContext: RumEventDomainContext,\n  eventRateLimiters: { [key in RumEventType]?: EventRateLimiter }\n) {\n  if (beforeSend) {\n    const result = limitModification(event, modifiableFieldPathsByEvent[event.type], (event) =>\n      beforeSend(event, domainContext)\n    )\n    if (result === false && event.type !== RumEventType.VIEW) {\n      return false\n    }\n    if (result === false) {\n      display.warn(\"Can't dismiss view events using beforeSend!\")\n    }\n  }\n\n  const rateLimitReached = eventRateLimiters[event.type]?.isLimitReached()\n\n  return !rateLimitReached\n}\n\nfunction needToAssembleWithAction(\n  event: RawRumEvent\n): event is RawRumErrorEvent | RawRumResourceEvent | RawRumLongTaskEvent {\n  return [RumEventType.ERROR, RumEventType.RESOURCE, RumEventType.LONG_TASK].indexOf(event.type) !== -1\n}\n\nfunction findFeatureFlagsContext(\n  rawRumEvent: RawRumEvent,\n  eventStartTime: RelativeTime,\n  trackFeatureFlagsForEvents: FeatureFlagsForEvents[],\n  featureFlagContexts: FeatureFlagContexts\n) {\n  const isTrackingEnforced = rawRumEvent.type === RumEventType.VIEW || rawRumEvent.type === RumEventType.ERROR\n\n  const isListedInConfig = trackFeatureFlagsForEvents.includes(rawRumEvent.type as FeatureFlagsForEvents)\n\n  if (isTrackingEnforced || isListedInConfig) {\n    const featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(eventStartTime)\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n      return featureFlagContext\n    }\n  }\n}\n","import { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from '@datadog/browser-core'\n\nexport function getSyntheticsContext() {\n  const testId = getSyntheticsTestId()\n  const resultId = getSyntheticsResultId()\n\n  if (testId && resultId) {\n    return {\n      test_id: testId,\n      result_id: resultId,\n      injected: willSyntheticsInjectRum(),\n    }\n  }\n}\n","import type { Context, PageExitEvent, RawError, RelativeTime } from '@datadog/browser-core'\nimport { AbstractLifeCycle } from '@datadog/browser-core'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type { RawRumEvent } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\nimport type { CommonContext } from './contexts/commonContext'\nimport type { RequestCompleteEvent, RequestStartEvent } from './requestCollection'\nimport type { AutoAction } from './action/actionCollection'\nimport type { ViewEvent, ViewCreatedEvent, ViewEndedEvent } from './view/trackViews'\n\nexport const enum LifeCycleEventType {\n  // Contexts (like viewHistory) should be opened using prefixed BEFORE_XXX events and closed using prefixed AFTER_XXX events\n  // It ensures the context is available during the non prefixed event callbacks\n  AUTO_ACTION_COMPLETED,\n  BEFORE_VIEW_CREATED,\n  VIEW_CREATED,\n  VIEW_UPDATED,\n  VIEW_ENDED,\n  AFTER_VIEW_ENDED,\n  REQUEST_STARTED,\n  REQUEST_COMPLETED,\n\n  // The SESSION_EXPIRED lifecycle event has been introduced to represent when a session has expired\n  // and trigger cleanup tasks related to this, prior to renewing the session. Its implementation is\n  // slightly naive: it is not triggered as soon as the session is expired, but rather just before\n  // notifying that the session is renewed. Thus, the session id is already set to the newly renewed\n  // session.\n  //\n  // This implementation is \"good enough\" for our use-cases. Improving this is not trivial,\n  // primarily because multiple instances of the SDK may be managing the same session cookie at\n  // the same time, for example when using Logs and RUM on the same page, or opening multiple tabs\n  // on the same domain.\n  SESSION_EXPIRED,\n  SESSION_RENEWED,\n  PAGE_EXITED,\n  RAW_RUM_EVENT_COLLECTED,\n  RUM_EVENT_COLLECTED,\n  RAW_ERROR_COLLECTED,\n}\n\n// This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript\n// project configured with `isolatedModules: true`. Even if the const enum is declared in this\n// module, we cannot use it directly to define the EventMap interface keys (TS error: \"Cannot access\n// ambient const enums when the '--isolatedModules' flag is provided.\").\n//\n// Using a plain enum would fix the issue, but would also add 2KB to the minified bundle. By using\n// this workaround, we can keep using a const enum without impacting the bundle size (since it is a\n// \"declare\" statement, it will only be used during typecheck and completely ignored when building\n// JavaScript).\n//\n// See issues:\n// * https://github.com/DataDog/browser-sdk/issues/2208\n// * https://github.com/microsoft/TypeScript/issues/54152\ndeclare const LifeCycleEventTypeAsConst: {\n  AUTO_ACTION_COMPLETED: LifeCycleEventType.AUTO_ACTION_COMPLETED\n  BEFORE_VIEW_CREATED: LifeCycleEventType.BEFORE_VIEW_CREATED\n  VIEW_CREATED: LifeCycleEventType.VIEW_CREATED\n  VIEW_UPDATED: LifeCycleEventType.VIEW_UPDATED\n  VIEW_ENDED: LifeCycleEventType.VIEW_ENDED\n  AFTER_VIEW_ENDED: LifeCycleEventType.AFTER_VIEW_ENDED\n  REQUEST_STARTED: LifeCycleEventType.REQUEST_STARTED\n  REQUEST_COMPLETED: LifeCycleEventType.REQUEST_COMPLETED\n  SESSION_EXPIRED: LifeCycleEventType.SESSION_EXPIRED\n  SESSION_RENEWED: LifeCycleEventType.SESSION_RENEWED\n  PAGE_EXITED: LifeCycleEventType.PAGE_EXITED\n  RAW_RUM_EVENT_COLLECTED: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED\n  RUM_EVENT_COLLECTED: LifeCycleEventType.RUM_EVENT_COLLECTED\n  RAW_ERROR_COLLECTED: LifeCycleEventType.RAW_ERROR_COLLECTED\n}\n\n// Note: this interface needs to be exported even if it is not used outside of this module, else TS\n// fails to build the rum-core package with error TS4058\nexport interface LifeCycleEventMap {\n  [LifeCycleEventTypeAsConst.AUTO_ACTION_COMPLETED]: AutoAction\n  [LifeCycleEventTypeAsConst.BEFORE_VIEW_CREATED]: ViewCreatedEvent\n  [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent\n  [LifeCycleEventTypeAsConst.VIEW_UPDATED]: ViewEvent\n  [LifeCycleEventTypeAsConst.VIEW_ENDED]: ViewEndedEvent\n  [LifeCycleEventTypeAsConst.AFTER_VIEW_ENDED]: ViewEndedEvent\n  [LifeCycleEventTypeAsConst.REQUEST_STARTED]: RequestStartEvent\n  [LifeCycleEventTypeAsConst.REQUEST_COMPLETED]: RequestCompleteEvent\n  [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: void\n  [LifeCycleEventTypeAsConst.SESSION_RENEWED]: void\n  [LifeCycleEventTypeAsConst.PAGE_EXITED]: PageExitEvent\n  [LifeCycleEventTypeAsConst.RAW_RUM_EVENT_COLLECTED]: RawRumEventCollectedData\n  [LifeCycleEventTypeAsConst.RUM_EVENT_COLLECTED]: RumEvent & Context\n  [LifeCycleEventTypeAsConst.RAW_ERROR_COLLECTED]: {\n    error: RawError\n    savedCommonContext?: CommonContext\n    customerContext?: Context\n  }\n}\n\nexport interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {\n  startTime: RelativeTime\n  savedCommonContext?: CommonContext\n  customerContext?: Context\n  rawRumEvent: E\n  domainContext: RumEventDomainContext<E['type']>\n}\n\nexport const LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\nexport type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\n","import type { Subscription } from './observable'\n\n/**\n * Type helper to extract event types that have \"void\" data. This allows to call `notify` without a\n * second argument. Ex:\n *\n * ```\n * interface EventMap {\n *   foo: void\n * }\n * const LifeCycle = AbstractLifeCycle<EventMap>\n * new LifeCycle().notify('foo')\n * ```\n */\ntype EventTypesWithoutData<EventMap> = {\n  [K in keyof EventMap]: EventMap[K] extends void ? K : never\n}[keyof EventMap]\n\n// eslint-disable-next-line no-restricted-syntax\nexport class AbstractLifeCycle<EventMap> {\n  private callbacks: { [key in keyof EventMap]?: Array<(data: any) => void> } = {}\n\n  notify<EventType extends EventTypesWithoutData<EventMap>>(eventType: EventType): void\n  notify<EventType extends keyof EventMap>(eventType: EventType, data: EventMap[EventType]): void\n  notify(eventType: keyof EventMap, data?: unknown) {\n    const eventCallbacks = this.callbacks[eventType]\n    if (eventCallbacks) {\n      eventCallbacks.forEach((callback) => callback(data))\n    }\n  }\n\n  subscribe<EventType extends keyof EventMap>(\n    eventType: EventType,\n    callback: (data: EventMap[EventType]) => void\n  ): Subscription {\n    if (!this.callbacks[eventType]) {\n      this.callbacks[eventType] = []\n    }\n    this.callbacks[eventType]!.push(callback)\n    return {\n      unsubscribe: () => {\n        this.callbacks[eventType] = this.callbacks[eventType]!.filter((other) => callback !== other)\n      },\n    }\n  }\n}\n","import { setInterval, clearInterval } from './timer'\nimport type { TimeoutId } from './timer'\nimport { removeItem } from './utils/arrayUtils'\nimport type { Duration, RelativeTime } from './utils/timeUtils'\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils'\n\nconst END_OF_TIMES = Infinity as RelativeTime\n\nexport interface ValueHistoryEntry<T> {\n  startTime: RelativeTime\n  endTime: RelativeTime\n  value: T\n  remove(): void\n  close(endTime: RelativeTime): void\n}\n\nexport const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE\n\n/**\n * Store and keep track of values spans. This whole cache assumes that values are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nexport interface ValueHistory<Value> {\n  add: (value: Value, startTime: RelativeTime) => ValueHistoryEntry<Value>\n  find: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => Value | undefined\n\n  closeActive: (endTime: RelativeTime) => void\n  findAll: (startTime?: RelativeTime, duration?: Duration) => Value[]\n  reset: () => void\n  stop: () => void\n}\n\nexport function createValueHistory<Value>({\n  expireDelay,\n  maxEntries,\n}: {\n  expireDelay: number\n  maxEntries?: number\n}): ValueHistory<Value> {\n  let entries: Array<ValueHistoryEntry<Value>> = []\n  const clearOldValuesInterval: TimeoutId = setInterval(() => clearOldValues(), CLEAR_OLD_VALUES_INTERVAL)\n\n  function clearOldValues() {\n    const oldTimeThreshold = relativeNow() - expireDelay\n    while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {\n      entries.pop()\n    }\n  }\n\n  /**\n   * Add a value to the history associated with a start time. Returns a reference to this newly\n   * added entry that can be removed or closed.\n   */\n  function add(value: Value, startTime: RelativeTime): ValueHistoryEntry<Value> {\n    const entry: ValueHistoryEntry<Value> = {\n      value,\n      startTime,\n      endTime: END_OF_TIMES,\n      remove: () => {\n        removeItem(entries, entry)\n      },\n      close: (endTime: RelativeTime) => {\n        entry.endTime = endTime\n      },\n    }\n\n    if (maxEntries && entries.length >= maxEntries) {\n      entries.pop()\n    }\n\n    entries.unshift(entry)\n\n    return entry\n  }\n\n  /**\n   * Return the latest value that was active during `startTime`, or the currently active value\n   * if no `startTime` is provided. This method assumes that entries are not overlapping.\n   *\n   * If `option.returnInactive` is true, returns the value at `startTime` (active or not).\n   */\n  function find(\n    startTime: RelativeTime = END_OF_TIMES,\n    options: { returnInactive: boolean } = { returnInactive: false }\n  ): Value | undefined {\n    for (const entry of entries) {\n      if (entry.startTime <= startTime) {\n        if (options.returnInactive || startTime <= entry.endTime) {\n          return entry.value\n        }\n        break\n      }\n    }\n  }\n\n  /**\n   * Helper function to close the currently active value, if any. This method assumes that entries\n   * are not overlapping.\n   */\n  function closeActive(endTime: RelativeTime) {\n    const latestEntry = entries[0]\n    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n      latestEntry.close(endTime)\n    }\n  }\n\n  /**\n   * Return all values with an active period overlapping with the duration,\n   * or all values that were active during `startTime` if no duration is provided,\n   * or all currently active values if no `startTime` is provided.\n   */\n  function findAll(startTime: RelativeTime = END_OF_TIMES, duration = 0 as Duration): Value[] {\n    const endTime = addDuration(startTime, duration)\n    return entries\n      .filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)\n      .map((entry) => entry.value)\n  }\n\n  /**\n   * Remove all entries from this collection.\n   */\n  function reset() {\n    entries = []\n  }\n\n  /**\n   * Stop internal garbage collection of past entries.\n   */\n  function stop() {\n    clearInterval(clearOldValuesInterval)\n  }\n\n  return { add, find, closeActive, findAll, reset, stop }\n}\n","import type { RelativeTime, ClocksState, Context } from '@datadog/browser-core'\nimport { SESSION_TIME_OUT_DELAY, createValueHistory } from '@datadog/browser-core'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { ViewCreatedEvent, ViewEvent } from '../view/trackViews'\n\nexport const VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\n\nexport interface ViewHistoryEntry {\n  service?: string\n  version?: string\n  context?: Context | undefined\n  id: string\n  name?: string\n  startClocks: ClocksState\n}\n\nexport interface ViewHistory {\n  findView: (startTime?: RelativeTime) => ViewHistoryEntry | undefined\n  stop: () => void\n}\n\nexport function startViewHistory(lifeCycle: LifeCycle): ViewHistory {\n  const viewValueHistory = createValueHistory<ViewHistoryEntry>({ expireDelay: VIEW_CONTEXT_TIME_OUT_DELAY })\n\n  lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, (view) => {\n    viewValueHistory.add(buildViewHistoryEntry(view), view.startClocks.relative)\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.AFTER_VIEW_ENDED, ({ endClocks }) => {\n    viewValueHistory.closeActive(endClocks.relative)\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_UPDATED, (viewUpdate: ViewEvent) => {\n    const currentView = viewValueHistory.find(viewUpdate.startClocks.relative)\n    if (currentView && viewUpdate.name) {\n      currentView.name = viewUpdate.name\n    }\n    if (currentView && viewUpdate.context) {\n      currentView.context = viewUpdate.context\n    }\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    viewValueHistory.reset()\n  })\n\n  function buildViewHistoryEntry(view: ViewCreatedEvent) {\n    return {\n      service: view.service,\n      version: view.version,\n      context: view.context,\n      id: view.id,\n      name: view.name,\n      startClocks: view.startClocks,\n    }\n  }\n\n  return {\n    findView: (startTime) => viewValueHistory.find(startTime),\n    stop: () => {\n      viewValueHistory.stop()\n    },\n  }\n}\n","import type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { Observable } from '../tools/observable'\nimport type { Duration, ClocksState } from '../tools/utils/timeUtils'\nimport { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils'\nimport { normalizeUrl } from '../tools/utils/urlPolyfill'\nimport { shallowClone } from '../tools/utils/objectUtils'\nimport type { Configuration } from '../domain/configuration'\nimport { addEventListener } from './addEventListener'\n\nexport interface XhrOpenContext {\n  state: 'open'\n  method: string\n  url: string\n}\n\nexport interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {\n  state: 'start'\n  startClocks: ClocksState\n  isAborted: boolean\n  xhr: XMLHttpRequest\n  handlingStack?: string\n}\n\nexport interface XhrCompleteContext extends Omit<XhrStartContext, 'state'> {\n  state: 'complete'\n  duration: Duration\n  status: number\n}\n\nexport type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext\n\nlet xhrObservable: Observable<XhrContext> | undefined\nconst xhrContexts = new WeakMap<XMLHttpRequest, XhrContext>()\n\nexport function initXhrObservable(configuration: Configuration) {\n  if (!xhrObservable) {\n    xhrObservable = createXhrObservable(configuration)\n  }\n  return xhrObservable\n}\n\nfunction createXhrObservable(configuration: Configuration) {\n  return new Observable<XhrContext>((observable) => {\n    const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)\n\n    const { stop: stopInstrumentingSend } = instrumentMethod(\n      XMLHttpRequest.prototype,\n      'send',\n      (call) => {\n        sendXhr(call, configuration, observable)\n      },\n      { computeHandlingStack: true }\n    )\n\n    const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)\n\n    return () => {\n      stopInstrumentingStart()\n      stopInstrumentingSend()\n      stopInstrumentingAbort()\n    }\n  })\n}\n\nfunction openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodCall<XMLHttpRequest, 'open'>) {\n  xhrContexts.set(xhr, {\n    state: 'open',\n    method: String(method).toUpperCase(),\n    url: normalizeUrl(String(url)),\n  })\n}\n\nfunction sendXhr(\n  { target: xhr, handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,\n  configuration: Configuration,\n  observable: Observable<XhrContext>\n) {\n  const context = xhrContexts.get(xhr)\n  if (!context) {\n    return\n  }\n\n  const startContext = context as XhrStartContext\n  startContext.state = 'start'\n  startContext.startClocks = clocksNow()\n  startContext.isAborted = false\n  startContext.xhr = xhr\n  startContext.handlingStack = handlingStack\n\n  let hasBeenReported = false\n\n  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {\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  })\n\n  const onEnd = () => {\n    unsubscribeLoadEndListener()\n    stopInstrumentingOnReadyStateChange()\n    if (hasBeenReported) {\n      return\n    }\n    hasBeenReported = true\n\n    const completeContext = context as XhrCompleteContext\n    completeContext.state = 'complete'\n    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())\n    completeContext.status = xhr.status\n    observable.notify(shallowClone(completeContext))\n  }\n\n  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)\n\n  observable.notify(startContext)\n}\n\nfunction abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort'>) {\n  const context = xhrContexts.get(xhr) as XhrStartContext | undefined\n  if (context) {\n    context.isAborted = true\n  }\n}\n","import type { RelativeTime, ServerDuration } from '@datadog/browser-core'\nimport {\n  addTelemetryDebug,\n  elapsed,\n  getPathName,\n  isValidUrl,\n  ResourceType,\n  toServerDuration,\n  isIntakeUrl,\n} from '@datadog/browser-core'\n\nimport type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'\n\nimport type { ResourceEntryDetailsElement, DeliveryType } from '../../rawRumEvent.types'\n\nexport interface ResourceEntryDetails {\n  worker?: ResourceEntryDetailsElement\n  redirect?: ResourceEntryDetailsElement\n  dns?: ResourceEntryDetailsElement\n  connect?: ResourceEntryDetailsElement\n  ssl?: ResourceEntryDetailsElement\n  first_byte?: ResourceEntryDetailsElement\n  download?: ResourceEntryDetailsElement\n}\n\nexport const FAKE_INITIAL_DOCUMENT = 'initial_document'\n\nconst RESOURCE_TYPES: Array<[ResourceType, (initiatorType: string, path: string) => boolean]> = [\n  [ResourceType.DOCUMENT, (initiatorType: string) => FAKE_INITIAL_DOCUMENT === initiatorType],\n  [ResourceType.XHR, (initiatorType: string) => 'xmlhttprequest' === initiatorType],\n  [ResourceType.FETCH, (initiatorType: string) => 'fetch' === initiatorType],\n  [ResourceType.BEACON, (initiatorType: string) => 'beacon' === initiatorType],\n  [ResourceType.CSS, (_: string, path: string) => /\\.css$/i.test(path)],\n  [ResourceType.JS, (_: string, path: string) => /\\.js$/i.test(path)],\n  [\n    ResourceType.IMAGE,\n    (initiatorType: string, path: string) =>\n      ['image', 'img', 'icon'].includes(initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null,\n  ],\n  [ResourceType.FONT, (_: string, path: string) => /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],\n  [\n    ResourceType.MEDIA,\n    (initiatorType: string, path: string) =>\n      ['audio', 'video'].includes(initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null,\n  ],\n]\n\nexport function computeResourceEntryType(entry: RumPerformanceResourceTiming) {\n  const url = entry.name\n  if (!isValidUrl(url)) {\n    addTelemetryDebug(`Failed to construct URL for \"${entry.name}\"`)\n    return ResourceType.OTHER\n  }\n  const path = getPathName(url)\n  for (const [type, isType] of RESOURCE_TYPES) {\n    if (isType(entry.initiatorType, path)) {\n      return type\n    }\n  }\n  return ResourceType.OTHER\n}\n\nfunction areInOrder(...numbers: number[]) {\n  for (let i = 1; i < numbers.length; i += 1) {\n    if (numbers[i - 1] > numbers[i]) {\n      return false\n    }\n  }\n  return true\n}\n\nexport function isResourceEntryRequestType(entry: RumPerformanceResourceTiming) {\n  return entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch'\n}\n\nexport function computeResourceEntryDuration(entry: RumPerformanceResourceTiming): ServerDuration {\n  const { duration, startTime, responseEnd } = entry\n\n  // Safari duration is always 0 on timings blocked by cross origin policies.\n  if (duration === 0 && startTime < responseEnd) {\n    return toServerDuration(elapsed(startTime, responseEnd))\n  }\n\n  return toServerDuration(duration)\n}\n\nexport function computeResourceEntryDetails(entry: RumPerformanceResourceTiming): ResourceEntryDetails | undefined {\n  if (!hasValidResourceEntryTimings(entry)) {\n    return undefined\n  }\n  const {\n    startTime,\n    fetchStart,\n    workerStart,\n    redirectStart,\n    redirectEnd,\n    domainLookupStart,\n    domainLookupEnd,\n    connectStart,\n    secureConnectionStart,\n    connectEnd,\n    requestStart,\n    responseStart,\n    responseEnd,\n  } = entry\n\n  const details: ResourceEntryDetails = {\n    download: formatTiming(startTime, responseStart, responseEnd),\n    first_byte: formatTiming(startTime, requestStart, responseStart),\n  }\n\n  // Make sure a worker processing time is recorded\n  if (0 < workerStart && workerStart < fetchStart) {\n    details.worker = formatTiming(startTime, workerStart, fetchStart)\n  }\n\n  // Make sure a connection occurred\n  if (fetchStart < connectEnd) {\n    details.connect = formatTiming(startTime, connectStart, connectEnd)\n\n    // Make sure a secure connection occurred\n    if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) {\n      details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd)\n    }\n  }\n\n  // Make sure a domain lookup occurred\n  if (fetchStart < domainLookupEnd) {\n    details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd)\n  }\n\n  // Make sure a redirection occurred\n  if (startTime < redirectEnd) {\n    details.redirect = formatTiming(startTime, redirectStart, redirectEnd)\n  }\n\n  return details\n}\n\n/**\n * Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM\n * Resource events with negative durations anyway.\n * Since Chromium 128, more entries have unexpected negative durations, see\n * https://issues.chromium.org/issues/363031537\n */\nexport function hasValidResourceEntryDuration(entry: RumPerformanceResourceTiming) {\n  return entry.duration >= 0\n}\n\nexport function hasValidResourceEntryTimings(entry: RumPerformanceResourceTiming) {\n  // Ensure timings are in the right order. On top of filtering out potential invalid\n  // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n  // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n  // it.\n  const areCommonTimingsInOrder = areInOrder(\n    entry.startTime,\n    entry.fetchStart,\n    entry.domainLookupStart,\n    entry.domainLookupEnd,\n    entry.connectStart,\n    entry.connectEnd,\n    entry.requestStart,\n    entry.responseStart,\n    entry.responseEnd\n  )\n\n  const areRedirectionTimingsInOrder = hasRedirection(entry)\n    ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart)\n    : true\n\n  return areCommonTimingsInOrder && areRedirectionTimingsInOrder\n}\n\nfunction hasRedirection(entry: RumPerformanceResourceTiming) {\n  return entry.redirectEnd > entry.startTime\n}\nfunction formatTiming(origin: RelativeTime, start: RelativeTime, end: RelativeTime) {\n  if (origin <= start && start <= end) {\n    return {\n      duration: toServerDuration(elapsed(start, end)),\n      start: toServerDuration(elapsed(origin, start)),\n    }\n  }\n}\n\n/**\n * The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,\n * meaning the protocol is unknown, and we shouldn't report it.\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources\n */\nexport function computeResourceEntryProtocol(entry: RumPerformanceResourceTiming) {\n  return entry.nextHopProtocol === '' ? undefined : entry.nextHopProtocol\n}\n\n/**\n * Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),\n * undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).\n * see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType\n */\nexport function computeResourceEntryDeliveryType(entry: RumPerformanceResourceTiming): DeliveryType | undefined {\n  return entry.deliveryType === '' ? 'other' : entry.deliveryType\n}\n\nexport function computeResourceEntrySize(entry: RumPerformanceResourceTiming) {\n  // Make sure a request actually occurred\n  if (entry.startTime < entry.responseStart) {\n    const { encodedBodySize, decodedBodySize, transferSize } = entry\n    return {\n      size: decodedBodySize,\n      encoded_body_size: encodedBodySize,\n      decoded_body_size: decodedBodySize,\n      transfer_size: transferSize,\n    }\n  }\n  return {\n    size: undefined,\n    encoded_body_size: undefined,\n    decoded_body_size: undefined,\n    transfer_size: undefined,\n  }\n}\n\nexport function isAllowedRequestUrl(url: string) {\n  return url && !isIntakeUrl(url)\n}\n\nconst DATA_URL_REGEX = /data:(.+)?(;base64)?,/g\nexport const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 24_000\n\nexport function isLongDataUrl(url: string): boolean {\n  if (url.length <= MAX_ATTRIBUTE_VALUE_CHAR_LENGTH) {\n    return false\n  } else if (url.substring(0, 5) === 'data:') {\n    // Avoid String.match RangeError: Maximum call stack size exceeded\n    url = url.substring(0, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH)\n    return true\n  }\n  return false\n}\n\nexport function sanitizeDataUrl(url: string): string {\n  return `${url.match(DATA_URL_REGEX)![0]}[...]`\n}\n","import type {\n  Duration,\n  XhrCompleteContext,\n  XhrStartContext,\n  ClocksState,\n  FetchStartContext,\n  FetchResolveContext,\n} from '@datadog/browser-core'\nimport {\n  RequestType,\n  initFetchObservable,\n  initXhrObservable,\n  readBytesFromStream,\n  elapsed,\n  timeStampNow,\n  tryToClone,\n} from '@datadog/browser-core'\nimport type { RumSessionManager } from '..'\nimport type { RumConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\nimport { isAllowedRequestUrl } from './resource/resourceUtils'\nimport type { Tracer } from './tracing/tracer'\nimport { startTracer } from './tracing/tracer'\nimport type { SpanIdentifier, TraceIdentifier } from './tracing/identifier'\n\nexport interface CustomContext {\n  requestIndex: number\n  spanId?: SpanIdentifier\n  traceId?: TraceIdentifier\n  traceSampled?: boolean\n}\nexport interface RumFetchStartContext extends FetchStartContext, CustomContext {}\nexport interface RumFetchResolveContext extends FetchResolveContext, CustomContext {}\nexport interface RumXhrStartContext extends XhrStartContext, CustomContext {}\nexport interface RumXhrCompleteContext extends XhrCompleteContext, CustomContext {}\n\nexport interface RequestStartEvent {\n  requestIndex: number\n  url: string\n}\nexport interface RequestCompleteEvent {\n  requestIndex: number\n  type: RequestType\n  method: string\n  url: string\n  status: number\n  responseType?: string\n  startClocks: ClocksState\n  duration: Duration\n  spanId?: SpanIdentifier\n  traceId?: TraceIdentifier\n  traceSampled?: boolean\n  xhr?: XMLHttpRequest\n  response?: Response\n  input?: unknown\n  init?: RequestInit\n  error?: Error\n  isAborted: boolean\n  handlingStack?: string\n}\n\nlet nextRequestIndex = 1\n\nexport function startRequestCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  sessionManager: RumSessionManager\n) {\n  const tracer = startTracer(configuration, sessionManager)\n  trackXhr(lifeCycle, configuration, tracer)\n  trackFetch(lifeCycle, tracer)\n}\n\nexport function trackXhr(lifeCycle: LifeCycle, configuration: RumConfiguration, tracer: Tracer) {\n  const subscription = initXhrObservable(configuration).subscribe((rawContext) => {\n    const context = rawContext as RumXhrStartContext | RumXhrCompleteContext\n    if (!isAllowedRequestUrl(context.url)) {\n      return\n    }\n\n    switch (context.state) {\n      case 'start':\n        tracer.traceXhr(context, context.xhr)\n        context.requestIndex = getNextRequestIndex()\n\n        lifeCycle.notify(LifeCycleEventType.REQUEST_STARTED, {\n          requestIndex: context.requestIndex,\n          url: context.url,\n        })\n        break\n      case 'complete':\n        tracer.clearTracingIfNeeded(context)\n        lifeCycle.notify(LifeCycleEventType.REQUEST_COMPLETED, {\n          duration: context.duration,\n          method: context.method,\n          requestIndex: context.requestIndex,\n          spanId: context.spanId,\n          startClocks: context.startClocks,\n          status: context.status,\n          traceId: context.traceId,\n          traceSampled: context.traceSampled,\n          type: RequestType.XHR,\n          url: context.url,\n          xhr: context.xhr,\n          isAborted: context.isAborted,\n          handlingStack: context.handlingStack,\n        })\n        break\n    }\n  })\n\n  return { stop: () => subscription.unsubscribe() }\n}\n\nexport function trackFetch(lifeCycle: LifeCycle, tracer: Tracer) {\n  const subscription = initFetchObservable().subscribe((rawContext) => {\n    const context = rawContext as RumFetchResolveContext | RumFetchStartContext\n    if (!isAllowedRequestUrl(context.url)) {\n      return\n    }\n\n    switch (context.state) {\n      case 'start':\n        tracer.traceFetch(context)\n        context.requestIndex = getNextRequestIndex()\n\n        lifeCycle.notify(LifeCycleEventType.REQUEST_STARTED, {\n          requestIndex: context.requestIndex,\n          url: context.url,\n        })\n        break\n      case 'resolve':\n        waitForResponseToComplete(context, (duration: Duration) => {\n          tracer.clearTracingIfNeeded(context)\n          lifeCycle.notify(LifeCycleEventType.REQUEST_COMPLETED, {\n            duration,\n            method: context.method,\n            requestIndex: context.requestIndex,\n            responseType: context.responseType,\n            spanId: context.spanId,\n            startClocks: context.startClocks,\n            status: context.status,\n            traceId: context.traceId,\n            traceSampled: context.traceSampled,\n            type: RequestType.FETCH,\n            url: context.url,\n            response: context.response,\n            init: context.init,\n            input: context.input,\n            isAborted: context.isAborted,\n            handlingStack: context.handlingStack,\n          })\n        })\n        break\n    }\n  })\n  return { stop: () => subscription.unsubscribe() }\n}\n\nfunction getNextRequestIndex() {\n  const result = nextRequestIndex\n  nextRequestIndex += 1\n  return result\n}\n\nfunction waitForResponseToComplete(context: RumFetchResolveContext, callback: (duration: Duration) => void) {\n  const clonedResponse = context.response && tryToClone(context.response)\n  if (!clonedResponse || !clonedResponse.body) {\n    // do not try to wait for the response if the clone failed, fetch error or null body\n    callback(elapsed(context.startClocks.timeStamp, timeStampNow()))\n  } else {\n    readBytesFromStream(\n      clonedResponse.body,\n      () => {\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()))\n      },\n      {\n        bytesLimit: Number.POSITIVE_INFINITY,\n        collectStreamBody: false,\n      }\n    )\n  }\n}\n","import { monitor } from './monitor'\nimport { noop } from './utils/functionUtils'\n\ntype Options = {\n  bytesLimit: number\n  collectStreamBody?: boolean\n}\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(\n  stream: ReadableStream<Uint8Array>,\n  callback: (error?: Error, bytes?: Uint8Array, limitExceeded?: boolean) => void,\n  options: Options\n) {\n  const reader = stream.getReader()\n  const chunks: Uint8Array[] = []\n  let readBytesCount = 0\n\n  readMore()\n\n  function readMore() {\n    reader.read().then(\n      monitor((result: ReadableStreamReadResult<Uint8Array>) => {\n        if (result.done) {\n          onDone()\n          return\n        }\n\n        if (options.collectStreamBody) {\n          chunks.push(result.value)\n        }\n        readBytesCount += result.value.length\n\n        if (readBytesCount > options.bytesLimit) {\n          onDone()\n        } else {\n          readMore()\n        }\n      }),\n      monitor((error) => callback(error))\n    )\n  }\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    )\n\n    let bytes: Uint8Array | undefined\n    let limitExceeded: boolean | undefined\n    if (options.collectStreamBody) {\n      let completeBuffer: Uint8Array\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 = chunks[0]\n      } else {\n        // else, we need to copy buffers into a larger buffer to concatenate them.\n        completeBuffer = new Uint8Array(readBytesCount)\n        let offset = 0\n        chunks.forEach((chunk) => {\n          completeBuffer.set(chunk, offset)\n          offset += chunk.length\n        })\n      }\n      bytes = completeBuffer.slice(0, options.bytesLimit)\n      limitExceeded = completeBuffer.length > options.bytesLimit\n    }\n\n    callback(undefined, bytes, limitExceeded)\n  }\n}\n","import type { ServerDuration } from '@datadog/browser-core'\nimport { isNumber } from '@datadog/browser-core'\n\nexport function discardNegativeDuration(duration: ServerDuration | undefined): ServerDuration | undefined {\n  return isNumber(duration) && duration < 0 ? undefined : duration\n}\n","import { noop } from '@datadog/browser-core'\nimport { RumEventType } from '../rawRumEvent.types'\nimport type { RumActionEvent, RumErrorEvent, RumLongTaskEvent, RumResourceEvent } from '../rumEvent.types'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\n\nexport interface EventCounts {\n  errorCount: number\n  actionCount: number\n  longTaskCount: number\n  resourceCount: number\n  frustrationCount: number\n}\n\nexport function trackEventCounts({\n  lifeCycle,\n  isChildEvent,\n  onChange: callback = noop,\n}: {\n  lifeCycle: LifeCycle\n  isChildEvent: (event: RumActionEvent | RumErrorEvent | RumLongTaskEvent | RumResourceEvent) => boolean\n  onChange?: () => void\n}) {\n  const eventCounts: EventCounts = {\n    errorCount: 0,\n    longTaskCount: 0,\n    resourceCount: 0,\n    actionCount: 0,\n    frustrationCount: 0,\n  }\n\n  const subscription = lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event): void => {\n    if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event)) {\n      return\n    }\n    switch (event.type) {\n      case RumEventType.ERROR:\n        eventCounts.errorCount += 1\n        callback()\n        break\n      case RumEventType.ACTION:\n        eventCounts.actionCount += 1\n        if (event.action.frustration) {\n          eventCounts.frustrationCount += event.action.frustration.type.length\n        }\n        callback()\n        break\n      case RumEventType.LONG_TASK:\n        eventCounts.longTaskCount += 1\n        callback()\n        break\n      case RumEventType.RESOURCE:\n        if (!event._dd?.discarded) {\n          eventCounts.resourceCount += 1\n          callback()\n        }\n        break\n    }\n  })\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n    eventCounts,\n  }\n}\n","import type { Duration, RelativeTime, TimeoutId } from '@datadog/browser-core'\nimport { addEventListener, Observable, setTimeout, clearTimeout, monitor } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../domain/configuration'\nimport { hasValidResourceEntryDuration, isAllowedRequestUrl } from '../domain/resource/resourceUtils'\nimport { retrieveFirstInputTiming } from './firstInputPolyfill'\n\ntype RumPerformanceObserverConstructor = new (callback: PerformanceObserverCallback) => RumPerformanceObserver\n\nexport interface BrowserWindow extends Window {\n  PerformanceObserver: RumPerformanceObserverConstructor\n  performance: Performance & { interactionCount?: number }\n}\n\nexport interface RumPerformanceObserver extends PerformanceObserver {\n  observe(options?: PerformanceObserverInit & { durationThreshold?: number }): void\n}\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 performance entry\n// eslint-disable-next-line no-restricted-syntax\nexport enum RumPerformanceEntryType {\n  EVENT = 'event',\n  FIRST_INPUT = 'first-input',\n  LARGEST_CONTENTFUL_PAINT = 'largest-contentful-paint',\n  LAYOUT_SHIFT = 'layout-shift',\n  LONG_TASK = 'longtask',\n  LONG_ANIMATION_FRAME = 'long-animation-frame',\n  NAVIGATION = 'navigation',\n  PAINT = 'paint',\n  RESOURCE = 'resource',\n}\n\nexport interface RumPerformanceLongTaskTiming {\n  name: string\n  entryType: RumPerformanceEntryType.LONG_TASK\n  startTime: RelativeTime\n  duration: Duration\n  toJSON(): Omit<PerformanceEntry, 'toJSON'>\n}\n\nexport interface RumPerformanceResourceTiming {\n  entryType: RumPerformanceEntryType.RESOURCE\n  initiatorType: string\n  responseStatus?: number\n  name: string\n  startTime: RelativeTime\n  duration: Duration\n  fetchStart: RelativeTime\n  workerStart: RelativeTime\n  domainLookupStart: RelativeTime\n  domainLookupEnd: RelativeTime\n  connectStart: RelativeTime\n  secureConnectionStart: RelativeTime\n  connectEnd: RelativeTime\n  requestStart: RelativeTime\n  responseStart: RelativeTime\n  responseEnd: RelativeTime\n  redirectStart: RelativeTime\n  redirectEnd: RelativeTime\n  decodedBodySize: number\n  encodedBodySize: number\n  transferSize: number\n  nextHopProtocol?: string\n  renderBlockingStatus?: string\n  traceId?: string\n  deliveryType?: 'cache' | 'navigational-prefetch' | ''\n  toJSON(): Omit<PerformanceEntry, 'toJSON'>\n}\n\nexport interface RumPerformancePaintTiming {\n  entryType: RumPerformanceEntryType.PAINT\n  name: 'first-paint' | 'first-contentful-paint'\n  startTime: RelativeTime\n}\n\nexport interface RumPerformanceNavigationTiming extends Omit<RumPerformanceResourceTiming, 'entryType'> {\n  entryType: RumPerformanceEntryType.NAVIGATION\n  initiatorType: 'navigation'\n  name: string\n\n  domComplete: RelativeTime\n  domContentLoadedEventEnd: RelativeTime\n  domInteractive: RelativeTime\n  loadEventEnd: RelativeTime\n\n  toJSON(): Omit<RumPerformanceNavigationTiming, 'toJSON'>\n}\n\nexport interface RumLargestContentfulPaintTiming {\n  entryType: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT\n  startTime: RelativeTime\n  size: number\n  element?: Element\n  toJSON(): Omit<RumLargestContentfulPaintTiming, 'toJSON'>\n}\n\nexport interface RumFirstInputTiming {\n  entryType: RumPerformanceEntryType.FIRST_INPUT\n  startTime: RelativeTime\n  processingStart: RelativeTime\n  processingEnd: RelativeTime\n  duration: Duration\n  target?: Node\n  interactionId?: number\n  name: string\n}\n\nexport interface RumPerformanceEventTiming {\n  entryType: RumPerformanceEntryType.EVENT\n  startTime: RelativeTime\n  processingStart: RelativeTime\n  processingEnd: RelativeTime\n  duration: Duration\n  interactionId?: number\n  target?: Node\n  name: string\n}\n\nexport interface RumLayoutShiftAttribution {\n  node: Node | null\n  previousRect: DOMRectReadOnly\n  currentRect: DOMRectReadOnly\n}\n\nexport interface RumLayoutShiftTiming {\n  entryType: RumPerformanceEntryType.LAYOUT_SHIFT\n  startTime: RelativeTime\n  value: number\n  hadRecentInput: boolean\n  sources: RumLayoutShiftAttribution[]\n}\n\n// Documentation https://developer.chrome.com/docs/web-platform/long-animation-frames#better-attribution\nexport type RumPerformanceScriptTiming = {\n  duration: Duration\n  entryType: 'script'\n  executionStart: RelativeTime\n  forcedStyleAndLayoutDuration: Duration\n  invoker: string // e.g. \"https://static.datadoghq.com/static/c/93085/chunk-bc4db53278fd4c77a637.min.js\"\n  invokerType:\n    | 'user-callback'\n    | 'event-listener'\n    | 'resolve-promise'\n    | 'reject-promise'\n    | 'classic-script'\n    | 'module-script'\n  name: 'script'\n  pauseDuration: Duration\n  sourceCharPosition: number\n  sourceFunctionName: string\n  sourceURL: string\n  startTime: RelativeTime\n  window: Window\n  windowAttribution: string\n}\n\nexport interface RumPerformanceLongAnimationFrameTiming {\n  blockingDuration: Duration\n  duration: Duration\n  entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME\n  firstUIEventTimestamp: RelativeTime\n  name: 'long-animation-frame'\n  renderStart: RelativeTime\n  scripts: RumPerformanceScriptTiming[]\n  startTime: RelativeTime\n  styleAndLayoutStart: RelativeTime\n}\n\nexport type RumPerformanceEntry =\n  | RumPerformanceResourceTiming\n  | RumPerformanceLongTaskTiming\n  | RumPerformanceLongAnimationFrameTiming\n  | RumPerformancePaintTiming\n  | RumPerformanceNavigationTiming\n  | RumLargestContentfulPaintTiming\n  | RumFirstInputTiming\n  | RumPerformanceEventTiming\n  | RumLayoutShiftTiming\n\nexport type EntryTypeToReturnType = {\n  [RumPerformanceEntryType.EVENT]: RumPerformanceEventTiming\n  [RumPerformanceEntryType.FIRST_INPUT]: RumFirstInputTiming\n  [RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT]: RumLargestContentfulPaintTiming\n  [RumPerformanceEntryType.LAYOUT_SHIFT]: RumLayoutShiftTiming\n  [RumPerformanceEntryType.PAINT]: RumPerformancePaintTiming\n  [RumPerformanceEntryType.LONG_TASK]: RumPerformanceLongTaskTiming\n  [RumPerformanceEntryType.LONG_ANIMATION_FRAME]: RumPerformanceLongAnimationFrameTiming\n  [RumPerformanceEntryType.NAVIGATION]: RumPerformanceNavigationTiming\n  [RumPerformanceEntryType.RESOURCE]: RumPerformanceResourceTiming\n}\n\nexport function createPerformanceObservable<T extends RumPerformanceEntryType>(\n  configuration: RumConfiguration,\n  options: { type: T; buffered?: boolean; durationThreshold?: number }\n) {\n  return new Observable<Array<EntryTypeToReturnType[T]>>((observable) => {\n    if (!window.PerformanceObserver) {\n      return\n    }\n\n    const handlePerformanceEntries = (entries: PerformanceEntryList) => {\n      const rumPerformanceEntries = filterRumPerformanceEntries(entries as Array<EntryTypeToReturnType[T]>)\n      if (rumPerformanceEntries.length > 0) {\n        observable.notify(rumPerformanceEntries)\n      }\n    }\n\n    let timeoutId: TimeoutId | undefined\n    let isObserverInitializing = true\n    const observer = new PerformanceObserver(\n      monitor((entries) => {\n        // In Safari the performance observer callback is synchronous.\n        // Because the buffered performance entry list can be quite large we delay the computation to prevent the SDK from blocking the main thread on init\n        if (isObserverInitializing) {\n          timeoutId = setTimeout(() => handlePerformanceEntries(entries.getEntries()))\n        } else {\n          handlePerformanceEntries(entries.getEntries())\n        }\n      })\n    )\n    try {\n      observer.observe(options)\n    } catch {\n      // Some old browser versions (<= chrome 74 ) don't support the PerformanceObserver type and buffered options\n      // In these cases, fallback to getEntriesByType and PerformanceObserver with entryTypes\n      // TODO: remove this fallback in the next major version\n      const fallbackSupportedEntryTypes = [\n        RumPerformanceEntryType.RESOURCE,\n        RumPerformanceEntryType.NAVIGATION,\n        RumPerformanceEntryType.LONG_TASK,\n        RumPerformanceEntryType.PAINT,\n      ]\n      if (fallbackSupportedEntryTypes.includes(options.type)) {\n        if (options.buffered) {\n          timeoutId = setTimeout(() => handlePerformanceEntries(performance.getEntriesByType(options.type)))\n        }\n        try {\n          observer.observe({ entryTypes: [options.type] })\n        } catch {\n          // Old versions of Safari are throwing \"entryTypes contained only unsupported types\"\n          // errors when observing only unsupported entry types.\n          //\n          // We could use `supportPerformanceTimingEvent` to make sure we don't invoke\n          // `observer.observe` with an unsupported entry type, but Safari 11 and 12 don't support\n          // `Performance.supportedEntryTypes`, so doing so would lose support for these versions\n          // even if they do support the entry type.\n          return\n        }\n      }\n    }\n    isObserverInitializing = false\n\n    manageResourceTimingBufferFull(configuration)\n\n    let stopFirstInputTiming: (() => void) | undefined\n    if (\n      !supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT) &&\n      options.type === RumPerformanceEntryType.FIRST_INPUT\n    ) {\n      ;({ stop: stopFirstInputTiming } = retrieveFirstInputTiming(configuration, (timing) => {\n        handlePerformanceEntries([timing])\n      }))\n    }\n\n    return () => {\n      observer.disconnect()\n      if (stopFirstInputTiming) {\n        stopFirstInputTiming()\n      }\n      clearTimeout(timeoutId)\n    }\n  })\n}\n\nlet resourceTimingBufferFullListener: { stop: () => void }\nfunction manageResourceTimingBufferFull(configuration: RumConfiguration) {\n  if (!resourceTimingBufferFullListener && supportPerformanceObject() && 'addEventListener' in performance) {\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n    resourceTimingBufferFullListener = addEventListener(configuration, performance, 'resourcetimingbufferfull', () => {\n      performance.clearResourceTimings()\n    })\n  }\n  return () => {\n    resourceTimingBufferFullListener?.stop()\n  }\n}\n\nfunction supportPerformanceObject() {\n  return window.performance !== undefined && 'getEntries' in performance\n}\n\nexport function supportPerformanceTimingEvent(entryType: RumPerformanceEntryType) {\n  return (\n    window.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes !== undefined &&\n    PerformanceObserver.supportedEntryTypes.includes(entryType)\n  )\n}\n\nfunction filterRumPerformanceEntries<T extends RumPerformanceEntryType>(entries: Array<EntryTypeToReturnType[T]>) {\n  return entries.filter((entry) => !isForbiddenResource(entry))\n}\n\nfunction isForbiddenResource(entry: RumPerformanceEntry) {\n  return (\n    entry.entryType === RumPerformanceEntryType.RESOURCE &&\n    (!isAllowedRequestUrl(entry.name) || !hasValidResourceEntryDuration(entry))\n  )\n}\n","import type { Duration, RelativeTime } from '@datadog/browser-core'\nimport { addEventListeners, dateNow, DOM_EVENT, relativeNow } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../domain/configuration'\n\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nexport function retrieveFirstInputTiming(\n  configuration: RumConfiguration,\n  callback: (timing: PerformanceEventTiming) => void\n) {\n  const startTimeStamp = dateNow()\n  let timingSent = false\n\n  const { stop: removeEventListeners } = addEventListeners(\n    configuration,\n    window,\n    [DOM_EVENT.CLICK, DOM_EVENT.MOUSE_DOWN, DOM_EVENT.KEY_DOWN, DOM_EVENT.TOUCH_START, DOM_EVENT.POINTER_DOWN],\n    (evt) => {\n      // Only count cancelable events, which should trigger behavior important to the user.\n      if (!evt.cancelable) {\n        return\n      }\n\n      // This timing will be used to compute the \"first Input delay\", which is the delta between\n      // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n      // (e.g. performance.now()).\n      const timing: PerformanceEventTiming = {\n        entryType: 'first-input',\n        processingStart: relativeNow(),\n        processingEnd: relativeNow(),\n        startTime: evt.timeStamp as RelativeTime,\n        duration: 0 as Duration, // arbitrary value to avoid nullable duration and simplify INP logic\n        name: '',\n        cancelable: false,\n        target: null,\n        toJSON: () => ({}),\n      }\n\n      if (evt.type === DOM_EVENT.POINTER_DOWN) {\n        sendTimingIfPointerIsNotCancelled(configuration, timing)\n      } else {\n        sendTiming(timing)\n      }\n    },\n    { passive: true, capture: true }\n  )\n\n  return { stop: removeEventListeners }\n\n  /**\n   * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n   * We differentiate these cases based on whether or not we see a pointercancel event, which are\n   * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n   * scrolling and pinch/zooming.\n   */\n  function sendTimingIfPointerIsNotCancelled(configuration: RumConfiguration, timing: PerformanceEventTiming) {\n    addEventListeners(\n      configuration,\n      window,\n      [DOM_EVENT.POINTER_UP, DOM_EVENT.POINTER_CANCEL],\n      (event) => {\n        if (event.type === DOM_EVENT.POINTER_UP) {\n          sendTiming(timing)\n        }\n      },\n      { once: true }\n    )\n  }\n\n  function sendTiming(timing: PerformanceEventTiming) {\n    if (!timingSent) {\n      timingSent = true\n      removeEventListeners()\n      // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n      // the time between now and when the page was loaded.\n      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n      const delay = timing.processingStart - timing.startTime\n      if (delay >= 0 && delay < dateNow() - startTimeStamp) {\n        callback(timing)\n      }\n    }\n  }\n}\n","import type { Subscription, TimeoutId, TimeStamp } from '@datadog/browser-core'\nimport { matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout } from '@datadog/browser-core'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../browser/performanceObservable'\nimport type { RumConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\n\n// Delay to wait for a page activity to validate the tracking process\nexport const PAGE_ACTIVITY_VALIDATION_DELAY = 100\n// Delay to wait after a page activity to end the tracking process\nexport const PAGE_ACTIVITY_END_DELAY = 100\n\nexport interface PageActivityEvent {\n  isBusy: boolean\n}\n\nexport type PageActivityEndEvent = { hadActivity: true; end: TimeStamp } | { hadActivity: false }\n\n/**\n * Wait for the page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitPageActivityEnd(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  pageActivityEndCallback: (event: PageActivityEndEvent) => void,\n  maxDuration?: number\n) {\n  const pageActivityObservable = createPageActivityObservable(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration\n  )\n  return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration)\n}\n\nexport function doWaitPageActivityEnd(\n  pageActivityObservable: Observable<PageActivityEvent>,\n  pageActivityEndCallback: (event: PageActivityEndEvent) => void,\n  maxDuration?: number\n) {\n  let pageActivityEndTimeoutId: TimeoutId\n  let hasCompleted = false\n\n  const validationTimeoutId = setTimeout(\n    monitor(() => complete({ hadActivity: false })),\n    PAGE_ACTIVITY_VALIDATION_DELAY\n  )\n  const maxDurationTimeoutId =\n    maxDuration !== undefined\n      ? setTimeout(\n          monitor(() => complete({ hadActivity: true, end: timeStampNow() })),\n          maxDuration\n        )\n      : undefined\n\n  const pageActivitySubscription = pageActivityObservable.subscribe(({ isBusy }) => {\n    clearTimeout(validationTimeoutId)\n    clearTimeout(pageActivityEndTimeoutId)\n    const lastChangeTime = timeStampNow()\n    if (!isBusy) {\n      pageActivityEndTimeoutId = setTimeout(\n        monitor(() => complete({ hadActivity: true, end: lastChangeTime })),\n        PAGE_ACTIVITY_END_DELAY\n      )\n    }\n  })\n\n  const stop = () => {\n    hasCompleted = true\n    clearTimeout(validationTimeoutId)\n    clearTimeout(pageActivityEndTimeoutId)\n    clearTimeout(maxDurationTimeoutId)\n    pageActivitySubscription.unsubscribe()\n  }\n\n  function complete(event: PageActivityEndEvent) {\n    if (hasCompleted) {\n      return\n    }\n    stop()\n    pageActivityEndCallback(event)\n  }\n  return { stop }\n}\n\nexport function createPageActivityObservable(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration\n): Observable<PageActivityEvent> {\n  return new Observable<PageActivityEvent>((observable) => {\n    const subscriptions: Subscription[] = []\n    let firstRequestIndex: undefined | number\n    let pendingRequestsCount = 0\n\n    subscriptions.push(\n      domMutationObservable.subscribe(notifyPageActivity),\n      windowOpenObservable.subscribe(notifyPageActivity),\n      createPerformanceObservable(configuration, { type: RumPerformanceEntryType.RESOURCE }).subscribe((entries) => {\n        if (entries.some((entry) => !isExcludedUrl(configuration, entry.name))) {\n          notifyPageActivity()\n        }\n      }),\n      lifeCycle.subscribe(LifeCycleEventType.REQUEST_STARTED, (startEvent) => {\n        if (isExcludedUrl(configuration, startEvent.url)) {\n          return\n        }\n        if (firstRequestIndex === undefined) {\n          firstRequestIndex = startEvent.requestIndex\n        }\n        pendingRequestsCount += 1\n        notifyPageActivity()\n      }),\n      lifeCycle.subscribe(LifeCycleEventType.REQUEST_COMPLETED, (request) => {\n        if (\n          isExcludedUrl(configuration, request.url) ||\n          firstRequestIndex === undefined ||\n          // If the request started before the tracking start, ignore it\n          request.requestIndex < firstRequestIndex\n        ) {\n          return\n        }\n        pendingRequestsCount -= 1\n        notifyPageActivity()\n      })\n    )\n\n    return () => {\n      subscriptions.forEach((s) => s.unsubscribe())\n    }\n\n    function notifyPageActivity() {\n      observable.notify({ isBusy: pendingRequestsCount > 0 })\n    }\n  })\n}\n\nfunction isExcludedUrl(configuration: RumConfiguration, requestUrl: string): boolean {\n  return matchList(configuration.excludedActivityUrls, requestUrl)\n}\n","export function isTextNode(node: Node): node is Text {\n  return node.nodeType === Node.TEXT_NODE\n}\n\nexport function isCommentNode(node: Node): node is Comment {\n  return node.nodeType === Node.COMMENT_NODE\n}\n\nexport function isElementNode(node: Node): node is Element {\n  return node.nodeType === Node.ELEMENT_NODE\n}\n\nexport function isNodeShadowHost(node: Node): node is Element & { shadowRoot: ShadowRoot } {\n  return isElementNode(node) && Boolean(node.shadowRoot)\n}\n\nexport function isNodeShadowRoot(node: Node): node is ShadowRoot {\n  const shadowRoot = node as ShadowRoot\n  return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host)\n}\n\nexport function hasChildNodes(node: Node) {\n  return node.childNodes.length > 0 || isNodeShadowHost(node)\n}\n\nexport function forEachChildNodes(node: Node, callback: (child: Node) => void) {\n  let child = node.firstChild\n\n  while (child) {\n    callback(child)\n\n    child = child.nextSibling\n  }\n\n  if (isNodeShadowHost(node)) {\n    callback(node.shadowRoot)\n  }\n}\n\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node: Node): Node | null {\n  return isNodeShadowRoot(node) ? node.host : node.parentNode\n}\n","import { DefaultPrivacyLevel } from '@datadog/browser-core'\nimport { isElementNode, getParentNode, isTextNode } from '../browser/htmlDomUtils'\n\nexport const NodePrivacyLevel = {\n  IGNORE: 'ignore',\n  HIDDEN: 'hidden',\n  ALLOW: DefaultPrivacyLevel.ALLOW,\n  MASK: DefaultPrivacyLevel.MASK,\n  MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n} as const\nexport type NodePrivacyLevel = (typeof NodePrivacyLevel)[keyof typeof NodePrivacyLevel]\n\nexport const PRIVACY_ATTR_NAME = 'data-dd-privacy'\n\n// Privacy Attrs\nexport const PRIVACY_ATTR_VALUE_ALLOW = 'allow'\nexport const PRIVACY_ATTR_VALUE_MASK = 'mask'\nexport const PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input'\nexport const PRIVACY_ATTR_VALUE_HIDDEN = 'hidden'\n\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport const PRIVACY_CLASS_PREFIX = 'dd-privacy-'\n\n// Private Replacement Templates\nexport const CENSORED_STRING_MARK = '***'\nexport const CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=='\n\nexport const FORM_PRIVATE_TAG_NAMES: { [tagName: string]: true } = {\n  INPUT: true,\n  OUTPUT: true,\n  TEXTAREA: true,\n  SELECT: true,\n  OPTION: true,\n  DATALIST: true,\n  OPTGROUP: true,\n}\n\nconst TEXT_MASKING_CHAR = 'x'\n\nexport type NodePrivacyLevelCache = Map<Node, NodePrivacyLevel>\n\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(\n  node: Node,\n  defaultPrivacyLevel: NodePrivacyLevel,\n  cache?: NodePrivacyLevelCache\n): NodePrivacyLevel {\n  if (cache && cache.has(node)) {\n    return cache.get(node)!\n  }\n  const parentNode = getParentNode(node)\n  const parentNodePrivacyLevel = parentNode\n    ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel, cache)\n    : defaultPrivacyLevel\n  const selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node)\n  const nodePrivacyLevel = reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel)\n  if (cache) {\n    cache.set(node, nodePrivacyLevel)\n  }\n  return nodePrivacyLevel\n}\n\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(\n  childPrivacyLevel: NodePrivacyLevel | undefined,\n  parentNodePrivacyLevel: NodePrivacyLevel\n): NodePrivacyLevel {\n  switch (parentNodePrivacyLevel) {\n    // These values cannot be overridden\n    case NodePrivacyLevel.HIDDEN:\n    case NodePrivacyLevel.IGNORE:\n      return parentNodePrivacyLevel\n  }\n  switch (childPrivacyLevel) {\n    case NodePrivacyLevel.ALLOW:\n    case NodePrivacyLevel.MASK:\n    case NodePrivacyLevel.MASK_USER_INPUT:\n    case NodePrivacyLevel.HIDDEN:\n    case NodePrivacyLevel.IGNORE:\n      return childPrivacyLevel\n    default:\n      return parentNodePrivacyLevel\n  }\n}\n\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node: Node): NodePrivacyLevel | undefined {\n  // Only Element types can have a privacy level set\n  if (!isElementNode(node)) {\n    return\n  }\n\n  // Overrules for replay purpose\n  if (node.tagName === 'BASE') {\n    return NodePrivacyLevel.ALLOW\n  }\n\n  // Overrules to enforce end-user protection\n  if (node.tagName === 'INPUT') {\n    const inputElement = node as HTMLInputElement\n    if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n      return NodePrivacyLevel.MASK\n    }\n    if (inputElement.type === 'hidden') {\n      return NodePrivacyLevel.MASK\n    }\n    const autocomplete = inputElement.getAttribute('autocomplete')\n    // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year/new-password/current-password]\n    if (autocomplete && (autocomplete.startsWith('cc-') || autocomplete.endsWith('-password'))) {\n      return NodePrivacyLevel.MASK\n    }\n  }\n\n  // Check HTML privacy attributes and classes\n  if (node.matches(getPrivacySelector(NodePrivacyLevel.HIDDEN))) {\n    return NodePrivacyLevel.HIDDEN\n  }\n\n  if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK))) {\n    return NodePrivacyLevel.MASK\n  }\n\n  if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK_USER_INPUT))) {\n    return NodePrivacyLevel.MASK_USER_INPUT\n  }\n\n  if (node.matches(getPrivacySelector(NodePrivacyLevel.ALLOW))) {\n    return NodePrivacyLevel.ALLOW\n  }\n\n  if (shouldIgnoreElement(node)) {\n    return NodePrivacyLevel.IGNORE\n  }\n}\n\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node: Node, privacyLevel: NodePrivacyLevel) {\n  switch (privacyLevel) {\n    case NodePrivacyLevel.MASK:\n    case NodePrivacyLevel.HIDDEN:\n    case NodePrivacyLevel.IGNORE:\n      return true\n    case NodePrivacyLevel.MASK_USER_INPUT:\n      return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node)\n    default:\n      return false\n  }\n}\n\nfunction isFormElement(node: Node | null): boolean {\n  if (!node || node.nodeType !== node.ELEMENT_NODE) {\n    return false\n  }\n  const element = node as HTMLInputElement\n  if (element.tagName === 'INPUT') {\n    switch (element.type) {\n      case 'button':\n      case 'color':\n      case 'reset':\n      case 'submit':\n        return false\n    }\n  }\n  return !!FORM_PRIVATE_TAG_NAMES[element.tagName]\n}\n\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport const censorText = (text: string) => text.replace(/\\S/g, TEXT_MASKING_CHAR)\n\nexport function getTextContent(\n  textNode: Node,\n  ignoreWhiteSpace: boolean,\n  parentNodePrivacyLevel: NodePrivacyLevel\n): string | undefined {\n  // The parent node may not be a html element which has a tagName attribute.\n  // So just let it be undefined which is ok in this use case.\n  const parentTagName = textNode.parentElement?.tagName\n  let textContent = textNode.textContent || ''\n\n  if (ignoreWhiteSpace && !textContent.trim()) {\n    return\n  }\n\n  const nodePrivacyLevel = parentNodePrivacyLevel\n\n  const isScript = parentTagName === 'SCRIPT'\n\n  if (isScript) {\n    // For perf reasons, we don't record script (heuristic)\n    textContent = CENSORED_STRING_MARK\n  } else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    // Should never occur, but just in case, we set to CENSORED_MARK.\n    textContent = CENSORED_STRING_MARK\n  } else if (shouldMaskNode(textNode, nodePrivacyLevel)) {\n    if (\n      // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n      parentTagName === 'DATALIST' ||\n      parentTagName === 'SELECT' ||\n      parentTagName === 'OPTGROUP'\n    ) {\n      if (!textContent.trim()) {\n        return\n      }\n    } else if (parentTagName === 'OPTION') {\n      // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n      textContent = CENSORED_STRING_MARK\n    } else {\n      textContent = censorText(textContent)\n    }\n  }\n  return textContent\n}\n\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element: Element): boolean {\n  if (element.nodeName === 'SCRIPT') {\n    return true\n  }\n\n  if (element.nodeName === 'LINK') {\n    const relAttribute = getLowerCaseAttribute('rel')\n    return (\n      // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n      (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||\n      // Favicons\n      relAttribute === 'shortcut icon' ||\n      relAttribute === 'icon'\n    )\n  }\n\n  if (element.nodeName === 'META') {\n    const nameAttribute = getLowerCaseAttribute('name')\n    const relAttribute = getLowerCaseAttribute('rel')\n    const propertyAttribute = getLowerCaseAttribute('property')\n    return (\n      // Favicons\n      /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n      nameAttribute === 'application-name' ||\n      relAttribute === 'icon' ||\n      relAttribute === 'apple-touch-icon' ||\n      relAttribute === 'shortcut icon' ||\n      // Description\n      nameAttribute === 'keywords' ||\n      nameAttribute === 'description' ||\n      // Social\n      /^(og|twitter|fb):/.test(propertyAttribute) ||\n      /^(og|twitter):/.test(nameAttribute) ||\n      nameAttribute === 'pinterest' ||\n      // Robots\n      nameAttribute === 'robots' ||\n      nameAttribute === 'googlebot' ||\n      nameAttribute === 'bingbot' ||\n      // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n      // X-Translated-By\n      element.hasAttribute('http-equiv') ||\n      // Authorship\n      nameAttribute === 'author' ||\n      nameAttribute === 'generator' ||\n      nameAttribute === 'framework' ||\n      nameAttribute === 'publisher' ||\n      nameAttribute === 'progid' ||\n      /^article:/.test(propertyAttribute) ||\n      /^product:/.test(propertyAttribute) ||\n      // Verification\n      nameAttribute === 'google-site-verification' ||\n      nameAttribute === 'yandex-verification' ||\n      nameAttribute === 'csrf-token' ||\n      nameAttribute === 'p:domain_verify' ||\n      nameAttribute === 'verify-v1' ||\n      nameAttribute === 'verification' ||\n      nameAttribute === 'shopify-checkout-api-token'\n    )\n  }\n\n  function getLowerCaseAttribute(name: string) {\n    return (element.getAttribute(name) || '').toLowerCase()\n  }\n\n  return false\n}\n\nexport function getPrivacySelector(privacyLevel: string) {\n  return `[${PRIVACY_ATTR_NAME}=\"${privacyLevel}\"], .${PRIVACY_CLASS_PREFIX}${privacyLevel}`\n}\n","import { safeTruncate } from '@datadog/browser-core'\nimport { NodePrivacyLevel, getPrivacySelector } from '../privacy'\nimport type { RumConfiguration } from '../configuration'\n\n/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nexport const DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name'\nexport const ACTION_NAME_PLACEHOLDER = 'Masked Element'\nexport const enum ActionNameSource {\n  CUSTOM_ATTRIBUTE = 'custom_attribute',\n  MASK_PLACEHOLDER = 'mask_placeholder',\n  TEXT_CONTENT = 'text_content',\n  STANDARD_ATTRIBUTE = 'standard_attribute',\n  BLANK = 'blank',\n}\ntype ActionName = {\n  name: string\n  nameSource: ActionNameSource\n}\n\nexport function getActionNameFromElement(\n  element: Element,\n  { enablePrivacyForActionName, actionNameAttribute: userProgrammaticAttribute }: RumConfiguration,\n  nodePrivacyLevel?: NodePrivacyLevel\n): ActionName {\n  // Proceed to get the action name in two steps:\n  // * first, get the name programmatically, explicitly defined by the user.\n  // * then, if privacy is set to mask, return a placeholder for the undefined.\n  // * if privacy is not set to mask, use strategies that are known to return good results.\n  //   Those strategies will be used on the element and a few parents, but it's likely that they won't succeed at all.\n  // * if no name is found this way, use strategies returning less accurate names as a fallback.\n  //   Those are much likely to succeed.\n  const defaultActionName =\n    getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE) ||\n    (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute))\n\n  if (defaultActionName) {\n    return { name: defaultActionName, nameSource: ActionNameSource.CUSTOM_ATTRIBUTE }\n  } else if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n    return { name: ACTION_NAME_PLACEHOLDER, nameSource: ActionNameSource.MASK_PLACEHOLDER }\n  }\n\n  return (\n    getActionNameFromElementForStrategies(\n      element,\n      userProgrammaticAttribute,\n      priorityStrategies,\n      enablePrivacyForActionName\n    ) ||\n    getActionNameFromElementForStrategies(\n      element,\n      userProgrammaticAttribute,\n      fallbackStrategies,\n      enablePrivacyForActionName\n    ) || { name: '', nameSource: ActionNameSource.BLANK }\n  )\n}\n\nfunction getActionNameFromElementProgrammatically(targetElement: Element, programmaticAttribute: string) {\n  // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n  // without limit. It is up to the user to declare a relevant naming strategy.\n  const elementWithAttribute = targetElement.closest(`[${programmaticAttribute}]`)\n\n  if (!elementWithAttribute) {\n    return\n  }\n  const name = elementWithAttribute.getAttribute(programmaticAttribute)!\n  return truncate(normalizeWhitespace(name.trim()))\n}\n\ntype NameStrategy = (\n  element: Element | HTMLElement | HTMLInputElement | HTMLSelectElement,\n  userProgrammaticAttribute: string | undefined,\n  privacyEnabledActionName?: boolean\n) => ActionName | undefined | null\n\nconst priorityStrategies: NameStrategy[] = [\n  // associated LABEL text\n  (element, userProgrammaticAttribute) => {\n    if ('labels' in element && element.labels && element.labels.length > 0) {\n      return getActionNameFromTextualContent(element.labels[0], userProgrammaticAttribute)\n    }\n  },\n  // INPUT button (and associated) value\n  (element) => {\n    if (element.nodeName === 'INPUT') {\n      const input = element as HTMLInputElement\n      const type = input.getAttribute('type')\n      if (type === 'button' || type === 'submit' || type === 'reset') {\n        return { name: input.value, nameSource: ActionNameSource.TEXT_CONTENT }\n      }\n    }\n  },\n  // BUTTON, LABEL or button-like element text\n  (element, userProgrammaticAttribute, privacyEnabledActionName) => {\n    if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n      return getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName)\n    }\n  },\n  (element) => getActionNameFromStandardAttribute(element, 'aria-label'),\n  // associated element text designated by the aria-labelledby attribute\n  (element, userProgrammaticAttribute, privacyEnabledActionName) => {\n    const labelledByAttribute = element.getAttribute('aria-labelledby')\n    if (labelledByAttribute) {\n      return {\n        name: labelledByAttribute\n          .split(/\\s+/)\n          .map((id) => getElementById(element, id))\n          .filter((label): label is HTMLElement => Boolean(label))\n          .map((element) => getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName))\n          .join(' '),\n        nameSource: ActionNameSource.TEXT_CONTENT,\n      }\n    }\n  },\n  (element) => getActionNameFromStandardAttribute(element, 'alt'),\n  (element) => getActionNameFromStandardAttribute(element, 'name'),\n  (element) => getActionNameFromStandardAttribute(element, 'title'),\n  (element) => getActionNameFromStandardAttribute(element, 'placeholder'),\n  // SELECT first OPTION text\n  (element, userProgrammaticAttribute) => {\n    if ('options' in element && element.options.length > 0) {\n      return getActionNameFromTextualContent(element.options[0], userProgrammaticAttribute)\n    }\n  },\n]\n\nconst fallbackStrategies: NameStrategy[] = [\n  (element, userProgrammaticAttribute, privacyEnabledActionName) =>\n    getActionNameFromTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName),\n]\n\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nconst MAX_PARENTS_TO_CONSIDER = 10\nfunction getActionNameFromElementForStrategies(\n  targetElement: Element,\n  userProgrammaticAttribute: string | undefined,\n  strategies: NameStrategy[],\n  privacyEnabledActionName?: boolean\n) {\n  let element: Element | null = targetElement\n  let recursionCounter = 0\n  while (\n    recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n    element &&\n    element.nodeName !== 'BODY' &&\n    element.nodeName !== 'HTML' &&\n    element.nodeName !== 'HEAD'\n  ) {\n    for (const strategy of strategies) {\n      const actionName = strategy(element, userProgrammaticAttribute, privacyEnabledActionName)\n      if (actionName) {\n        const { name, nameSource } = actionName\n        const trimmedName = name && name.trim()\n        if (trimmedName) {\n          return { name: truncate(normalizeWhitespace(trimmedName)), nameSource }\n        }\n      }\n    }\n    // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n    // be reconsidered in the future.\n    if (element.nodeName === 'FORM') {\n      break\n    }\n    element = element.parentElement\n    recursionCounter += 1\n  }\n}\n\nfunction normalizeWhitespace(s: string) {\n  return s.replace(/\\s+/g, ' ')\n}\n\nfunction truncate(s: string) {\n  return s.length > 100 ? `${safeTruncate(s, 100)} [...]` : s\n}\n\nfunction getElementById(refElement: Element, id: string) {\n  // Use the element ownerDocument here, because tests are executed in an iframe, so\n  // document.getElementById won't work.\n  return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null\n}\n\nfunction getActionNameFromStandardAttribute(element: Element | HTMLElement, attribute: string): ActionName {\n  return {\n    name: element.getAttribute(attribute) || '',\n    nameSource: ActionNameSource.STANDARD_ATTRIBUTE,\n  }\n}\n\nfunction getActionNameFromTextualContent(\n  element: Element | HTMLElement,\n  userProgrammaticAttribute: string | undefined,\n  privacyEnabledActionName?: boolean\n): ActionName {\n  return {\n    name: getTextualContent(element, userProgrammaticAttribute, privacyEnabledActionName) || '',\n    nameSource: ActionNameSource.TEXT_CONTENT,\n  }\n}\n\nfunction getTextualContent(\n  element: Element | HTMLElement,\n  userProgrammaticAttribute: string | undefined,\n  privacyEnabledActionName?: boolean\n) {\n  if ((element as HTMLElement).isContentEditable) {\n    return\n  }\n\n  if ('innerText' in element) {\n    let text = element.innerText\n\n    const removeTextFromElements = (query: string) => {\n      const list = element.querySelectorAll<Element | HTMLElement>(query)\n      for (let index = 0; index < list.length; index += 1) {\n        const element = list[index]\n        if ('innerText' in element) {\n          const textToReplace = element.innerText\n          if (textToReplace && textToReplace.trim().length > 0) {\n            text = text.replace(textToReplace, '')\n          }\n        }\n      }\n    }\n\n    // remove the text of elements with programmatic attribute value\n    removeTextFromElements(`[${DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE}]`)\n\n    if (userProgrammaticAttribute) {\n      removeTextFromElements(`[${userProgrammaticAttribute}]`)\n    }\n\n    if (privacyEnabledActionName) {\n      // remove the text of elements with privacy override\n      removeTextFromElements(\n        `${getPrivacySelector(NodePrivacyLevel.HIDDEN)}, ${getPrivacySelector(NodePrivacyLevel.MASK)}`\n      )\n    }\n\n    return text\n  }\n\n  return element.textContent\n}\n","import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/getActionNameFromElement'\n\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport const STABLE_ATTRIBUTES = [\n  DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n  // Common test attributes (list provided by google recorder)\n  'data-testid',\n  'data-test',\n  'data-qa',\n  'data-cy',\n  'data-test-id',\n  'data-qa-id',\n  'data-testing',\n  // FullStory decorator attributes:\n  'data-component',\n  'data-element',\n  'data-source-file',\n]\n\ntype SelectorGetter = (element: Element, actionNameAttribute: string | undefined) => string | undefined\n\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nconst GLOBALLY_UNIQUE_SELECTOR_GETTERS: SelectorGetter[] = [getStableAttributeSelector, getIDSelector]\n\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nconst UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS: SelectorGetter[] = [\n  getStableAttributeSelector,\n  getClassSelector,\n  getTagNameSelector,\n]\n\nexport function getSelectorFromElement(\n  targetElement: Element,\n  actionNameAttribute: string | undefined\n): string | undefined {\n  if (!isConnected(targetElement)) {\n    // We cannot compute a selector for a detached element, as we don't have access to all of its\n    // parents, and we cannot determine if it's unique in the document.\n    return\n  }\n  let targetElementSelector: string | undefined\n  let currentElement: Element | null = targetElement\n\n  while (currentElement && currentElement.nodeName !== 'HTML') {\n    const globallyUniqueSelector = findSelector(\n      currentElement,\n      GLOBALLY_UNIQUE_SELECTOR_GETTERS,\n      isSelectorUniqueGlobally,\n      actionNameAttribute,\n      targetElementSelector\n    )\n    if (globallyUniqueSelector) {\n      return globallyUniqueSelector\n    }\n\n    const uniqueSelectorAmongChildren = findSelector(\n      currentElement,\n      UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS,\n      isSelectorUniqueAmongSiblings,\n      actionNameAttribute,\n      targetElementSelector\n    )\n    targetElementSelector =\n      uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector)\n\n    currentElement = currentElement.parentElement\n  }\n\n  return targetElementSelector\n}\n\nfunction isGeneratedValue(value: string) {\n  // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n  // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n  // present.\n  //\n  // Here, we use the same strategy: if the value contains a digit, we consider it generated. This\n  // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n  // CSS selectors so it should be fine most of the time.\n  return /[0-9]/.test(value)\n}\n\nfunction getIDSelector(element: Element): string | undefined {\n  if (element.id && !isGeneratedValue(element.id)) {\n    return `#${CSS.escape(element.id)}`\n  }\n}\n\nfunction getClassSelector(element: Element): string | undefined {\n  if (element.tagName === 'BODY') {\n    return\n  }\n  const classList = element.classList\n  for (let i = 0; i < classList.length; i += 1) {\n    const className = classList[i]\n    if (isGeneratedValue(className)) {\n      continue\n    }\n\n    return `${CSS.escape(element.tagName)}.${CSS.escape(className)}`\n  }\n}\n\nfunction getTagNameSelector(element: Element): string {\n  return CSS.escape(element.tagName)\n}\n\nfunction getStableAttributeSelector(element: Element, actionNameAttribute: string | undefined): string | undefined {\n  if (actionNameAttribute) {\n    const selector = getAttributeSelector(actionNameAttribute)\n    if (selector) {\n      return selector\n    }\n  }\n\n  for (const attributeName of STABLE_ATTRIBUTES) {\n    const selector = getAttributeSelector(attributeName)\n    if (selector) {\n      return selector\n    }\n  }\n\n  function getAttributeSelector(attributeName: string) {\n    if (element.hasAttribute(attributeName)) {\n      return `${CSS.escape(element.tagName)}[${attributeName}=\"${CSS.escape(element.getAttribute(attributeName)!)}\"]`\n    }\n  }\n}\n\nfunction getPositionSelector(element: Element): string {\n  let sibling = element.parentElement!.firstElementChild\n  let elementIndex = 1\n\n  while (sibling && sibling !== element) {\n    if (sibling.tagName === element.tagName) {\n      elementIndex += 1\n    }\n    sibling = sibling.nextElementSibling\n  }\n\n  return `${CSS.escape(element.tagName)}:nth-of-type(${elementIndex})`\n}\n\nfunction findSelector(\n  element: Element,\n  selectorGetters: SelectorGetter[],\n  predicate: (element: Element, elementSelector: string, childSelector: string | undefined) => boolean,\n  actionNameAttribute: string | undefined,\n  childSelector: string | undefined\n) {\n  for (const selectorGetter of selectorGetters) {\n    const elementSelector = selectorGetter(element, actionNameAttribute)\n    if (!elementSelector) {\n      continue\n    }\n    if (predicate(element, elementSelector, childSelector)) {\n      return combineSelector(elementSelector, childSelector)\n    }\n  }\n}\n\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(\n  element: Element,\n  elementSelector: string,\n  childSelector: string | undefined\n): boolean {\n  return element.ownerDocument.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1\n}\n\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > CHILD_SELECTOR\" returns a single element.\n *\n * @param {Element} currentElement - the element being considered while iterating over the target\n * element ancestors.\n *\n * @param {string} currentElementSelector - a selector that matches the current element. That\n * selector is not a composed selector (i.e. it might be a single tag name, class name...).\n *\n * @param {string|undefined} childSelector - child selector is a selector that targets a descendant\n * of the current element. When undefined, the current element is the target element.\n *\n * # Scope selector usage\n *\n * When composed together, the final selector will be joined with `>` operators to make sure we\n * target direct descendants at each level. In this function, we'll use `querySelector` to check if\n * a selector matches descendants of the current element. But by default, the query selector match\n * elements at any level. Example:\n *\n * ```html\n * <main>\n *   <div>\n *     <span></span>\n *   </div>\n *   <marquee>\n *     <div>\n *       <span></span>\n *     </div>\n *   </marquee>\n * </main>\n * ```\n *\n * `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the\n * selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`\n * operator (`MAIN > DIV > SPAN`).\n *\n * To avoid this, we can use the `:scope` selector to make sure the selector starts from the current\n * sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).\n *\n * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT CHILD_SELECTOR\" returns a single element), regardless of whether the selector is\n * a direct descendant of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\n *\n * [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope\n *\n * # Performance considerations\n *\n * We compute selectors in performance-critical operations (ex: during a click), so we need to make\n * sure the function is as fast as possible. We observed that naively using `querySelectorAll` to\n * check if the selector matches more than 1 element is quite expensive, so we want to avoid it.\n *\n * Because we are iterating the DOM upward and we use that function at every level, we know the\n * child selector is already unique among the current element children, so we don't need to check\n * for the current element subtree.\n *\n * Instead, we can focus on the current element siblings. If we find a single element matching the\n * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`\n * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.\n */\nexport function isSelectorUniqueAmongSiblings(\n  currentElement: Element,\n  currentElementSelector: string,\n  childSelector: string | undefined\n): boolean {\n  let isSiblingMatching: (sibling: Element) => boolean\n\n  if (childSelector === undefined) {\n    // If the child selector is undefined (meaning `currentElement` is the target element, not one\n    // of its ancestor), we need to use `matches` to check if the sibling is matching the selector,\n    // as `querySelector` only returns a descendant of the element.\n    isSiblingMatching = (sibling) => sibling.matches(currentElementSelector)\n  } else {\n    const scopedSelector = supportScopeSelector()\n      ? combineSelector(`${currentElementSelector}:scope`, childSelector)\n      : combineSelector(currentElementSelector, childSelector)\n    isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null\n  }\n\n  const parent = currentElement.parentElement!\n  let sibling = parent.firstElementChild\n  while (sibling) {\n    if (sibling !== currentElement && isSiblingMatching(sibling)) {\n      return false\n    }\n    sibling = sibling.nextElementSibling\n  }\n\n  return true\n}\n\nfunction combineSelector(parent: string, child: string | undefined): string {\n  return child ? `${parent}>${child}` : parent\n}\n\nlet supportScopeSelectorCache: boolean | undefined\nexport function supportScopeSelector() {\n  if (supportScopeSelectorCache === undefined) {\n    try {\n      document.querySelector(':scope')\n      supportScopeSelectorCache = true\n    } catch {\n      supportScopeSelectorCache = false\n    }\n  }\n  return supportScopeSelectorCache\n}\n\n/**\n * Polyfill-utility for the `isConnected` property not supported in Edge <=18\n */\nfunction isConnected(element: Element): boolean {\n  if (\n    'isConnected' in\n    // cast is to make sure `element` is not inferred as `never` after the check\n    (element as { isConnected?: boolean })\n  ) {\n    return element.isConnected\n  }\n\n  return element.ownerDocument.documentElement.contains(element)\n}\n","import type { TimeoutId } from '@datadog/browser-core'\nimport { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core'\nimport type { Click } from './trackClickActions'\n\nexport interface ClickChain {\n  tryAppend: (click: Click) => boolean\n  stop: () => void\n}\n\nexport const MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND\nexport const MAX_DISTANCE_BETWEEN_CLICKS = 100\n\nconst enum ClickChainStatus {\n  WaitingForMoreClicks,\n  WaitingForClicksToStop,\n  Finalized,\n}\n\nexport function createClickChain(firstClick: Click, onFinalize: (clicks: Click[]) => void): ClickChain {\n  const bufferedClicks: Click[] = []\n  let status = ClickChainStatus.WaitingForMoreClicks\n  let maxDurationBetweenClicksTimeoutId: TimeoutId | undefined\n  appendClick(firstClick)\n\n  function appendClick(click: Click) {\n    click.stopObservable.subscribe(tryFinalize)\n    bufferedClicks.push(click)\n    clearTimeout(maxDurationBetweenClicksTimeoutId)\n    maxDurationBetweenClicksTimeoutId = setTimeout(dontAcceptMoreClick, MAX_DURATION_BETWEEN_CLICKS)\n  }\n\n  function tryFinalize() {\n    if (status === ClickChainStatus.WaitingForClicksToStop && bufferedClicks.every((click) => click.isStopped())) {\n      status = ClickChainStatus.Finalized\n      onFinalize(bufferedClicks)\n    }\n  }\n\n  function dontAcceptMoreClick() {\n    clearTimeout(maxDurationBetweenClicksTimeoutId)\n    if (status === ClickChainStatus.WaitingForMoreClicks) {\n      status = ClickChainStatus.WaitingForClicksToStop\n      tryFinalize()\n    }\n  }\n\n  return {\n    tryAppend: (click) => {\n      if (status !== ClickChainStatus.WaitingForMoreClicks) {\n        return false\n      }\n\n      if (\n        bufferedClicks.length > 0 &&\n        !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)\n      ) {\n        dontAcceptMoreClick()\n        return false\n      }\n\n      appendClick(click)\n      return true\n    },\n    stop: () => {\n      dontAcceptMoreClick()\n    },\n  }\n}\n\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first: MouseEvent, second: MouseEvent) {\n  return (\n    first.target === second.target &&\n    mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n    first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS\n  )\n}\n\nfunction mouseEventDistance(origin: MouseEvent, other: MouseEvent) {\n  return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2))\n}\n","import { addEventListener, DOM_EVENT } from '@datadog/browser-core'\nimport type { RelativeTime } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\n\nexport type ExtraPointerEventFields = {\n  target: Element\n  timeStamp: RelativeTime\n}\nexport type MouseEventOnElement = PointerEvent & ExtraPointerEventFields\n\nexport interface UserActivity {\n  selection: boolean\n  input: boolean\n  scroll: boolean\n}\nexport interface ActionEventsHooks<ClickContext> {\n  onPointerDown: (event: MouseEventOnElement) => ClickContext | undefined\n  onPointerUp: (context: ClickContext, event: MouseEventOnElement, getUserActivity: () => UserActivity) => void\n}\n\nexport function listenActionEvents<ClickContext>(\n  configuration: RumConfiguration,\n  { onPointerDown, onPointerUp }: ActionEventsHooks<ClickContext>\n) {\n  let selectionEmptyAtPointerDown: boolean\n  let userActivity: UserActivity = {\n    selection: false,\n    input: false,\n    scroll: false,\n  }\n  let clickContext: ClickContext | undefined\n\n  const listeners = [\n    addEventListener(\n      configuration,\n      window,\n      DOM_EVENT.POINTER_DOWN,\n      (event: PointerEvent) => {\n        if (isValidPointerEvent(event)) {\n          selectionEmptyAtPointerDown = isSelectionEmpty()\n          userActivity = {\n            selection: false,\n            input: false,\n            scroll: false,\n          }\n          clickContext = onPointerDown(event)\n        }\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      configuration,\n      window,\n      DOM_EVENT.SELECTION_CHANGE,\n      () => {\n        if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n          userActivity.selection = true\n        }\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      configuration,\n      window,\n      DOM_EVENT.SCROLL,\n      () => {\n        userActivity.scroll = true\n      },\n      { capture: true, passive: true }\n    ),\n\n    addEventListener(\n      configuration,\n      window,\n      DOM_EVENT.POINTER_UP,\n      (event: PointerEvent) => {\n        if (isValidPointerEvent(event) && clickContext) {\n          // Use a scoped variable to make sure the value is not changed by other clicks\n          const localUserActivity = userActivity\n          onPointerUp(clickContext, event, () => localUserActivity)\n          clickContext = undefined\n        }\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      configuration,\n      window,\n      DOM_EVENT.INPUT,\n      () => {\n        userActivity.input = true\n      },\n      { capture: true }\n    ),\n  ]\n\n  return {\n    stop: () => {\n      listeners.forEach((listener) => listener.stop())\n    },\n  }\n}\n\nfunction isSelectionEmpty(): boolean {\n  const selection = window.getSelection()\n  return !selection || selection.isCollapsed\n}\n\nfunction isValidPointerEvent(event: PointerEvent): event is MouseEventOnElement {\n  return (\n    event.target instanceof Element &&\n    // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n    // the future.\n    event.isPrimary !== false\n  )\n}\n","import { ONE_SECOND } from '@datadog/browser-core'\nimport { FrustrationType } from '../../rawRumEvent.types'\nimport type { Click } from './trackClickActions'\n\nconst MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3\n\nexport function computeFrustration(clicks: Click[], rageClick: Click) {\n  if (isRage(clicks)) {\n    rageClick.addFrustration(FrustrationType.RAGE_CLICK)\n    if (clicks.some(isDead)) {\n      rageClick.addFrustration(FrustrationType.DEAD_CLICK)\n    }\n    if (rageClick.hasError) {\n      rageClick.addFrustration(FrustrationType.ERROR_CLICK)\n    }\n    return { isRage: true }\n  }\n\n  const hasSelectionChanged = clicks.some((click) => click.getUserActivity().selection)\n  clicks.forEach((click) => {\n    if (click.hasError) {\n      click.addFrustration(FrustrationType.ERROR_CLICK)\n    }\n    if (\n      isDead(click) &&\n      // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n      !hasSelectionChanged\n    ) {\n      click.addFrustration(FrustrationType.DEAD_CLICK)\n    }\n  })\n  return { isRage: false }\n}\n\nexport function isRage(clicks: Click[]) {\n  if (clicks.some((click) => click.getUserActivity().selection || click.getUserActivity().scroll)) {\n    return false\n  }\n  for (let i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n    if (\n      clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n      ONE_SECOND\n    ) {\n      return true\n    }\n  }\n  return false\n}\n\nconst DEAD_CLICK_EXCLUDE_SELECTOR =\n  // inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n  // inputs (using a negative selector is shorter here)\n  'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n  'textarea,' +\n  'select,' +\n  // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n  '[contenteditable],' +\n  '[contenteditable] *,' +\n  // canvas, as there is no good way to detect activity occurring on them\n  'canvas,' +\n  // links that are interactive (have an href attribute) or any of their descendants, as they can\n  // open a new tab or navigate to a hash without triggering a meaningful event\n  'a[href],' +\n  'a[href] *'\n\nexport function isDead(click: Click) {\n  if (click.hasPageActivity || click.getUserActivity().input || click.getUserActivity().scroll) {\n    return false\n  }\n  return !click.event.target.matches(DEAD_CLICK_EXCLUDE_SELECTOR)\n}\n","import { elapsed, ONE_SECOND, relativeNow } from '@datadog/browser-core'\nimport type { RelativeTime } from '@datadog/browser-core'\n\n// Maximum duration for click actions\nexport const CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND\nexport const interactionSelectorCache = new Map<RelativeTime, string>()\n\nexport function getInteractionSelector(relativeTimestamp: RelativeTime) {\n  const selector = interactionSelectorCache.get(relativeTimestamp)\n  interactionSelectorCache.delete(relativeTimestamp)\n  return selector\n}\n\nexport function updateInteractionSelector(relativeTimestamp: RelativeTime, selector: string) {\n  interactionSelectorCache.set(relativeTimestamp, selector)\n  interactionSelectorCache.forEach((_, relativeTimestamp) => {\n    if (elapsed(relativeTimestamp, relativeNow()) > CLICK_ACTION_MAX_DURATION) {\n      interactionSelectorCache.delete(relativeTimestamp)\n    }\n  })\n}\n","import type { Duration, ClocksState, RelativeTime, TimeStamp, ValueHistory } from '@datadog/browser-core'\nimport {\n  timeStampNow,\n  Observable,\n  getRelativeTime,\n  ONE_MINUTE,\n  generateUUID,\n  clocksNow,\n  elapsed,\n  createValueHistory,\n} from '@datadog/browser-core'\nimport type { FrustrationType } from '../../rawRumEvent.types'\nimport { ActionType } from '../../rawRumEvent.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { trackEventCounts } from '../trackEventCounts'\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../waitPageActivityEnd'\nimport { getSelectorFromElement } from '../getSelectorFromElement'\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '../privacy'\nimport type { RumConfiguration } from '../configuration'\nimport type { ClickChain } from './clickChain'\nimport { createClickChain } from './clickChain'\nimport { getActionNameFromElement } from './getActionNameFromElement'\nimport type { MouseEventOnElement, UserActivity } from './listenActionEvents'\nimport { listenActionEvents } from './listenActionEvents'\nimport { computeFrustration } from './computeFrustration'\nimport { CLICK_ACTION_MAX_DURATION, updateInteractionSelector } from './interactionSelectorCache'\n\ninterface ActionCounts {\n  errorCount: number\n  longTaskCount: number\n  resourceCount: number\n}\n\nexport interface ClickAction {\n  type: ActionType.CLICK\n  id: string\n  name: string\n  nameSource: string\n  target?: {\n    selector: string | undefined\n    width: number\n    height: number\n  }\n  position?: { x: number; y: number }\n  startClocks: ClocksState\n  duration?: Duration\n  counts: ActionCounts\n  event: MouseEventOnElement\n  frustrationTypes: FrustrationType[]\n  events: Event[]\n}\n\nexport interface ActionContexts {\n  findActionId: (startTime?: RelativeTime) => string | string[] | undefined\n}\n\ntype ClickActionIdHistory = ValueHistory<ClickAction['id']>\n\nexport const ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE // arbitrary\n\nexport function trackClickActions(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration\n) {\n  const history: ClickActionIdHistory = createValueHistory({ expireDelay: ACTION_CONTEXT_TIME_OUT_DELAY })\n  const stopObservable = new Observable<void>()\n  let currentClickChain: ClickChain | undefined\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    history.reset()\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, stopClickChain)\n\n  const { stop: stopActionEventsListener } = listenActionEvents<{\n    clickActionBase: ClickActionBase\n    hadActivityOnPointerDown: () => boolean\n  }>(configuration, {\n    onPointerDown: (pointerDownEvent) =>\n      processPointerDown(configuration, lifeCycle, domMutationObservable, pointerDownEvent, windowOpenObservable),\n    onPointerUp: ({ clickActionBase, hadActivityOnPointerDown }, startEvent, getUserActivity) => {\n      startClickAction(\n        configuration,\n        lifeCycle,\n        domMutationObservable,\n        windowOpenObservable,\n        history,\n        stopObservable,\n        appendClickToClickChain,\n        clickActionBase,\n        startEvent,\n        getUserActivity,\n        hadActivityOnPointerDown\n      )\n    },\n  })\n\n  const actionContexts: ActionContexts = {\n    findActionId: (startTime?: RelativeTime) => history.findAll(startTime),\n  }\n\n  return {\n    stop: () => {\n      stopClickChain()\n      stopObservable.notify()\n      stopActionEventsListener()\n    },\n    actionContexts,\n  }\n\n  function appendClickToClickChain(click: Click) {\n    if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n      const rageClick = click.clone()\n      currentClickChain = createClickChain(click, (clicks) => {\n        finalizeClicks(clicks, rageClick)\n      })\n    }\n  }\n\n  function stopClickChain() {\n    if (currentClickChain) {\n      currentClickChain.stop()\n    }\n  }\n}\n\nfunction processPointerDown(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  pointerDownEvent: MouseEventOnElement,\n  windowOpenObservable: Observable<void>\n) {\n  const nodePrivacyLevel = configuration.enablePrivacyForActionName\n    ? getNodePrivacyLevel(pointerDownEvent.target, configuration.defaultPrivacyLevel)\n    : NodePrivacyLevel.ALLOW\n\n  if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    return undefined\n  }\n\n  const clickActionBase = computeClickActionBase(pointerDownEvent, nodePrivacyLevel, configuration)\n\n  let hadActivityOnPointerDown = false\n\n  waitPageActivityEnd(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    (pageActivityEndEvent) => {\n      hadActivityOnPointerDown = pageActivityEndEvent.hadActivity\n    },\n    // We don't care about the activity duration, we just want to know whether an activity did happen\n    // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n    PAGE_ACTIVITY_VALIDATION_DELAY\n  )\n\n  return { clickActionBase, hadActivityOnPointerDown: () => hadActivityOnPointerDown }\n}\n\nfunction startClickAction(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  history: ClickActionIdHistory,\n  stopObservable: Observable<void>,\n  appendClickToClickChain: (click: Click) => void,\n  clickActionBase: ClickActionBase,\n  startEvent: MouseEventOnElement,\n  getUserActivity: () => UserActivity,\n  hadActivityOnPointerDown: () => boolean\n) {\n  const click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent)\n  appendClickToClickChain(click)\n\n  const selector = clickActionBase?.target?.selector\n  if (selector) {\n    updateInteractionSelector(startEvent.timeStamp, selector)\n  }\n\n  const { stop: stopWaitPageActivityEnd } = waitPageActivityEnd(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    (pageActivityEndEvent) => {\n      if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n        // If the clock is looking weird, just discard the click\n        click.discard()\n      } else {\n        if (pageActivityEndEvent.hadActivity) {\n          click.stop(pageActivityEndEvent.end)\n        } else if (hadActivityOnPointerDown()) {\n          click.stop(\n            // using the click start as activity end, so the click will have some activity but its\n            // duration will be 0 (as the activity started before the click start)\n            click.startClocks.timeStamp\n          )\n        } else {\n          click.stop()\n        }\n      }\n    },\n    CLICK_ACTION_MAX_DURATION\n  )\n\n  const viewEndedSubscription = lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, ({ endClocks }) => {\n    click.stop(endClocks.timeStamp)\n  })\n\n  const stopSubscription = stopObservable.subscribe(() => {\n    click.stop()\n  })\n\n  click.stopObservable.subscribe(() => {\n    viewEndedSubscription.unsubscribe()\n    stopWaitPageActivityEnd()\n    stopSubscription.unsubscribe()\n  })\n}\n\ntype ClickActionBase = Pick<ClickAction, 'type' | 'name' | 'nameSource' | 'target' | 'position'>\n\nfunction computeClickActionBase(\n  event: MouseEventOnElement,\n  nodePrivacyLevel: NodePrivacyLevel,\n  configuration: RumConfiguration\n): ClickActionBase {\n  const rect = event.target.getBoundingClientRect()\n  const selector = getSelectorFromElement(event.target, configuration.actionNameAttribute)\n  if (selector) {\n    updateInteractionSelector(event.timeStamp, selector)\n  }\n  const actionName = getActionNameFromElement(event.target, configuration, nodePrivacyLevel)\n\n  return {\n    type: ActionType.CLICK,\n    target: {\n      width: Math.round(rect.width),\n      height: Math.round(rect.height),\n      selector,\n    },\n    position: {\n      // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n      x: Math.round(event.clientX - rect.left),\n      y: Math.round(event.clientY - rect.top),\n    },\n    name: actionName.name,\n    nameSource: actionName.nameSource,\n  }\n}\n\nconst enum ClickStatus {\n  // Initial state, the click is still ongoing.\n  ONGOING,\n  // The click is no more ongoing but still needs to be validated or discarded.\n  STOPPED,\n  // Final state, the click has been stopped and validated or discarded.\n  FINALIZED,\n}\n\nexport type Click = ReturnType<typeof newClick>\n\nfunction newClick(\n  lifeCycle: LifeCycle,\n  history: ClickActionIdHistory,\n  getUserActivity: () => UserActivity,\n  clickActionBase: ClickActionBase,\n  startEvent: MouseEventOnElement\n) {\n  const id = generateUUID()\n  const startClocks = clocksNow()\n  const historyEntry = history.add(id, startClocks.relative)\n  const eventCountsSubscription = trackEventCounts({\n    lifeCycle,\n    isChildEvent: (event) =>\n      event.action !== undefined &&\n      (Array.isArray(event.action.id) ? event.action.id.includes(id) : event.action.id === id),\n  })\n  let status = ClickStatus.ONGOING\n  let activityEndTime: undefined | TimeStamp\n  const frustrationTypes: FrustrationType[] = []\n  const stopObservable = new Observable<void>()\n\n  function stop(newActivityEndTime?: TimeStamp) {\n    if (status !== ClickStatus.ONGOING) {\n      return\n    }\n    activityEndTime = newActivityEndTime\n    status = ClickStatus.STOPPED\n    if (activityEndTime) {\n      historyEntry.close(getRelativeTime(activityEndTime))\n    } else {\n      historyEntry.remove()\n    }\n    eventCountsSubscription.stop()\n    stopObservable.notify()\n  }\n\n  return {\n    event: startEvent,\n    stop,\n    stopObservable,\n\n    get hasError() {\n      return eventCountsSubscription.eventCounts.errorCount > 0\n    },\n    get hasPageActivity() {\n      return activityEndTime !== undefined\n    },\n    getUserActivity,\n    addFrustration: (frustrationType: FrustrationType) => {\n      frustrationTypes.push(frustrationType)\n    },\n    startClocks,\n\n    isStopped: () => status === ClickStatus.STOPPED || status === ClickStatus.FINALIZED,\n\n    clone: () => newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent),\n\n    validate: (domEvents?: Event[]) => {\n      stop()\n      if (status !== ClickStatus.STOPPED) {\n        return\n      }\n\n      const { resourceCount, errorCount, longTaskCount } = eventCountsSubscription.eventCounts\n      const clickAction: ClickAction = {\n        duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n        startClocks,\n        id,\n        frustrationTypes,\n        counts: {\n          resourceCount,\n          errorCount,\n          longTaskCount,\n        },\n        events: domEvents ?? [startEvent],\n        event: startEvent,\n        ...clickActionBase,\n      }\n\n      lifeCycle.notify(LifeCycleEventType.AUTO_ACTION_COMPLETED, clickAction)\n      status = ClickStatus.FINALIZED\n    },\n\n    discard: () => {\n      stop()\n      status = ClickStatus.FINALIZED\n    },\n  }\n}\n\nexport function finalizeClicks(clicks: Click[], rageClick: Click) {\n  const { isRage } = computeFrustration(clicks, rageClick)\n  if (isRage) {\n    clicks.forEach((click) => click.discard())\n    rageClick.stop(timeStampNow())\n    rageClick.validate(clicks.map((click) => click.event))\n  } else {\n    rageClick.discard()\n    clicks.forEach((click) => click.validate())\n  }\n}\n","import type { ClocksState, Context, Observable } from '@datadog/browser-core'\nimport {\n  noop,\n  combine,\n  toServerDuration,\n  generateUUID,\n  ExperimentalFeature,\n  isExperimentalFeatureEnabled,\n} from '@datadog/browser-core'\nimport { discardNegativeDuration } from '../discardNegativeDuration'\nimport type { RawRumActionEvent } from '../../rawRumEvent.types'\nimport { ActionType, RumEventType } from '../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { RumConfiguration } from '../configuration'\nimport type { CommonContext } from '../contexts/commonContext'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport { PageState } from '../contexts/pageStateHistory'\nimport type { RumActionEventDomainContext } from '../../domainContext.types'\nimport type { ActionContexts, ClickAction } from './trackClickActions'\nimport { trackClickActions } from './trackClickActions'\n\nexport type { ActionContexts }\n\nexport interface CustomAction {\n  type: ActionType.CUSTOM\n  name: string\n  startClocks: ClocksState\n  context?: Context\n  handlingStack?: string\n}\n\nexport type AutoAction = ClickAction\n\nexport function startActionCollection(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  pageStateHistory: PageStateHistory\n) {\n  lifeCycle.subscribe(LifeCycleEventType.AUTO_ACTION_COMPLETED, (action) =>\n    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processAction(action, pageStateHistory))\n  )\n\n  let actionContexts: ActionContexts = { findActionId: noop as () => undefined }\n  let stop: () => void = noop\n\n  if (configuration.trackUserInteractions) {\n    ;({ actionContexts, stop } = trackClickActions(\n      lifeCycle,\n      domMutationObservable,\n      windowOpenObservable,\n      configuration\n    ))\n  }\n\n  return {\n    addAction: (action: CustomAction, savedCommonContext?: CommonContext) => {\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        savedCommonContext,\n        ...processAction(action, pageStateHistory),\n      })\n    },\n    actionContexts,\n    stop,\n  }\n}\n\nfunction processAction(\n  action: AutoAction | CustomAction,\n  pageStateHistory: PageStateHistory\n): RawRumEventCollectedData<RawRumActionEvent> {\n  const autoActionProperties = isAutoAction(action)\n    ? {\n        action: {\n          id: action.id,\n          loading_time: discardNegativeDuration(toServerDuration(action.duration)),\n          frustration: {\n            type: action.frustrationTypes,\n          },\n          error: {\n            count: action.counts.errorCount,\n          },\n          long_task: {\n            count: action.counts.longTaskCount,\n          },\n          resource: {\n            count: action.counts.resourceCount,\n          },\n        },\n        _dd: {\n          action: {\n            target: action.target,\n            position: action.position,\n            name_source: isExperimentalFeatureEnabled(ExperimentalFeature.ACTION_NAME_MASKING)\n              ? action.nameSource\n              : undefined,\n          },\n        },\n      }\n    : undefined\n  const customerContext = !isAutoAction(action) ? action.context : undefined\n  const actionEvent: RawRumActionEvent = combine(\n    {\n      action: {\n        id: generateUUID(),\n        target: {\n          name: action.name,\n        },\n        type: action.type,\n      },\n      date: action.startClocks.timeStamp,\n      type: RumEventType.ACTION as const,\n      view: { in_foreground: pageStateHistory.wasInPageStateAt(PageState.ACTIVE, action.startClocks.relative) },\n    },\n    autoActionProperties\n  )\n\n  const domainContext: RumActionEventDomainContext = isAutoAction(action) ? { events: action.events } : {}\n\n  if (!isAutoAction(action) && action.handlingStack) {\n    domainContext.handlingStack = action.handlingStack\n  }\n\n  return {\n    customerContext,\n    rawRumEvent: actionEvent,\n    startTime: action.startClocks.relative,\n    domainContext,\n  }\n}\n\nfunction isAutoAction(action: AutoAction | CustomAction): action is AutoAction {\n  return action.type !== ActionType.CUSTOM\n}\n","import { flattenErrorCauses, isError, tryToGetFingerprint } from '../error/error'\nimport { mergeObservables, Observable } from '../../tools/observable'\nimport { ConsoleApiName, globalConsole } from '../../tools/display'\nimport { callMonitored } from '../../tools/monitor'\nimport { sanitize } from '../../tools/serialisation/sanitize'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport type { RawError } from '../error/error.types'\nimport { ErrorHandling, ErrorSource } from '../error/error.types'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { createHandlingStack, toStackTraceString, formatErrorMessage } from '../../tools/stackTrace/handlingStack'\nimport { clocksNow } from '../../tools/utils/timeUtils'\n\nexport type ConsoleLog = NonErrorConsoleLog | ErrorConsoleLog\n\ninterface NonErrorConsoleLog extends ConsoleLogBase {\n  api: Exclude<ConsoleApiName, typeof ConsoleApiName.error>\n  error: undefined\n}\n\nexport interface ErrorConsoleLog extends ConsoleLogBase {\n  api: typeof ConsoleApiName.error\n  error: RawError\n}\n\ninterface ConsoleLogBase {\n  message: string\n  api: ConsoleApiName\n  handlingStack: string\n}\n\ntype ConsoleLogForApi<T extends ConsoleApiName> = T extends typeof ConsoleApiName.error\n  ? ErrorConsoleLog\n  : NonErrorConsoleLog\n\nlet consoleObservablesByApi: { [K in ConsoleApiName]?: Observable<ConsoleLogForApi<K>> } = {}\n\nexport function initConsoleObservable<T extends ConsoleApiName[]>(apis: T): Observable<ConsoleLogForApi<T[number]>> {\n  const consoleObservables = apis.map((api) => {\n    if (!consoleObservablesByApi[api]) {\n      consoleObservablesByApi[api] = createConsoleObservable(api) as any // we are sure that the observable created for this api will yield the expected ConsoleLog type\n    }\n    return consoleObservablesByApi[api] as unknown as Observable<ConsoleLogForApi<T[number]>>\n  })\n\n  return mergeObservables(...consoleObservables)\n}\n\nexport function resetConsoleObservable() {\n  consoleObservablesByApi = {}\n}\n\nfunction createConsoleObservable(api: ConsoleApiName) {\n  return new Observable<ConsoleLog>((observable) => {\n    const originalConsoleApi = globalConsole[api]\n\n    globalConsole[api] = (...params: unknown[]) => {\n      originalConsoleApi.apply(console, params)\n      const handlingStack = createHandlingStack()\n\n      callMonitored(() => {\n        observable.notify(buildConsoleLog(params, api, handlingStack))\n      })\n    }\n\n    return () => {\n      globalConsole[api] = originalConsoleApi\n    }\n  })\n}\n\nfunction buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {\n  const message = params.map((param) => formatConsoleParameters(param)).join(' ')\n  let error: RawError | undefined\n\n  if (api === ConsoleApiName.error) {\n    const firstErrorParam = params.find(isError)\n\n    error = {\n      stack: firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined,\n      fingerprint: tryToGetFingerprint(firstErrorParam),\n      causes: firstErrorParam ? flattenErrorCauses(firstErrorParam, 'console') : undefined,\n      startClocks: clocksNow(),\n      message,\n      source: ErrorSource.CONSOLE,\n      handling: ErrorHandling.HANDLED,\n      handlingStack,\n    }\n  }\n\n  return {\n    api,\n    message,\n    error,\n    handlingStack,\n  } as ConsoleLog\n}\n\nfunction formatConsoleParameters(param: unknown) {\n  if (typeof param === 'string') {\n    return sanitize(param)\n  }\n  if (isError(param)) {\n    return formatErrorMessage(computeStackTrace(param))\n  }\n  return jsonStringify(sanitize(param), undefined, 2)\n}\n","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 { safeTruncate } from '../../tools/utils/stringUtils'\nimport type { Configuration } from '../configuration'\nimport type { RawError } from '../error/error.types'\nimport { ErrorHandling, ErrorSource } from '../error/error.types'\nimport { clocksNow } from '../../tools/utils/timeUtils'\nimport type { ReportType, InterventionReport, DeprecationReport } from './browser.types'\n\nexport const RawReportType = {\n  intervention: 'intervention',\n  deprecation: 'deprecation',\n  cspViolation: 'csp_violation',\n} as const\n\nexport type RawReportType = (typeof RawReportType)[keyof typeof RawReportType]\n\nexport type RawReportError = RawError & {\n  originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport\n}\n\nexport function initReportObservable(configuration: Configuration, apis: RawReportType[]) {\n  const observables: Array<Observable<RawReportError>> = []\n\n  if (apis.includes(RawReportType.cspViolation)) {\n    observables.push(createCspViolationReportObservable(configuration))\n  }\n\n  const reportTypes = apis.filter((api: RawReportType): api is ReportType => api !== RawReportType.cspViolation)\n  if (reportTypes.length) {\n    observables.push(createReportObservable(reportTypes))\n  }\n\n  return mergeObservables(...observables)\n}\n\nfunction createReportObservable(reportTypes: ReportType[]) {\n  return new Observable<RawReportError>((observable) => {\n    if (!window.ReportingObserver) {\n      return\n    }\n\n    const handleReports = monitor((reports: Array<DeprecationReport | InterventionReport>, _: ReportingObserver) =>\n      reports.forEach((report) => observable.notify(buildRawReportErrorFromReport(report)))\n    ) as ReportingObserverCallback\n\n    const observer = new window.ReportingObserver(handleReports, {\n      types: reportTypes,\n      buffered: true,\n    })\n\n    observer.observe()\n    return () => {\n      observer.disconnect()\n    }\n  })\n}\n\nfunction createCspViolationReportObservable(configuration: Configuration) {\n  return new Observable<RawReportError>((observable) => {\n    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {\n      observable.notify(buildRawReportErrorFromCspViolation(event))\n    })\n\n    return stop\n  })\n}\n\nfunction buildRawReportErrorFromReport(report: DeprecationReport | InterventionReport): RawReportError {\n  const { type, body } = report\n\n  return buildRawReportError({\n    type: body.id,\n    message: `${type}: ${body.message}`,\n    originalError: report,\n    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n  })\n}\n\nfunction buildRawReportErrorFromCspViolation(event: SecurityPolicyViolationEvent): RawReportError {\n  const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`\n  return buildRawReportError({\n    type: event.effectiveDirective,\n    message: `${RawReportType.cspViolation}: ${message}`,\n    originalError: event,\n    csp: {\n      disposition: event.disposition,\n    },\n    stack: buildStack(\n      event.effectiveDirective,\n      event.originalPolicy\n        ? `${message} of the policy \"${safeTruncate(event.originalPolicy, 100, '...')}\"`\n        : 'no policy',\n      event.sourceFile,\n      event.lineNumber,\n      event.columnNumber\n    ),\n  })\n}\n\nfunction buildRawReportError(partial: Omit<RawReportError, 'startClocks' | 'source' | 'handling'>): RawReportError {\n  return {\n    startClocks: clocksNow(),\n    source: ErrorSource.REPORT,\n    handling: ErrorHandling.UNHANDLED,\n    ...partial,\n  }\n}\n\nfunction buildStack(\n  name: string,\n  message: string,\n  sourceFile: string | null,\n  lineNumber: number | null,\n  columnNumber: number | null\n): string | undefined {\n  return sourceFile\n    ? toStackTraceString({\n        name,\n        message,\n        stack: [\n          {\n            func: '?',\n            url: sourceFile,\n            line: lineNumber ?? undefined,\n            column: columnNumber ?? undefined,\n          },\n        ],\n      })\n    : undefined\n}\n","import type { Context, RawError, ClocksState } from '@datadog/browser-core'\nimport {\n  ErrorSource,\n  generateUUID,\n  computeRawError,\n  ErrorHandling,\n  computeStackTrace,\n  Observable,\n  trackRuntimeError,\n  NonErrorPrefix,\n  isError,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport type { RawRumErrorEvent } from '../../rawRumEvent.types'\nimport { RumEventType } from '../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { CommonContext } from '../contexts/commonContext'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport { PageState } from '../contexts/pageStateHistory'\nimport type { RumErrorEventDomainContext } from '../../domainContext.types'\nimport { trackConsoleError } from './trackConsoleError'\nimport { trackReportError } from './trackReportError'\n\nexport interface ProvidedError {\n  startClocks: ClocksState\n  error: unknown\n  context?: Context\n  handlingStack: string\n  componentStack?: string\n}\n\nexport function startErrorCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  pageStateHistory: PageStateHistory\n) {\n  const errorObservable = new Observable<RawError>()\n\n  trackConsoleError(errorObservable)\n  trackRuntimeError(errorObservable)\n  trackReportError(configuration, errorObservable)\n\n  errorObservable.subscribe((error) => lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error }))\n\n  return doStartErrorCollection(lifeCycle, pageStateHistory)\n}\n\nexport function doStartErrorCollection(lifeCycle: LifeCycle, pageStateHistory: PageStateHistory) {\n  lifeCycle.subscribe(LifeCycleEventType.RAW_ERROR_COLLECTED, ({ error, customerContext, savedCommonContext }) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n      customerContext,\n      savedCommonContext,\n      ...processError(error, pageStateHistory),\n    })\n  })\n\n  return {\n    addError: (\n      { error, handlingStack, componentStack, startClocks, context: customerContext }: ProvidedError,\n      savedCommonContext?: CommonContext\n    ) => {\n      const stackTrace = isError(error) ? computeStackTrace(error) : undefined\n      const rawError = computeRawError({\n        stackTrace,\n        originalError: error,\n        handlingStack,\n        componentStack,\n        startClocks,\n        nonErrorPrefix: NonErrorPrefix.PROVIDED,\n        source: ErrorSource.CUSTOM,\n        handling: ErrorHandling.HANDLED,\n      })\n\n      lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, {\n        customerContext,\n        savedCommonContext,\n        error: rawError,\n      })\n    },\n  }\n}\n\nfunction processError(error: RawError, pageStateHistory: PageStateHistory): RawRumEventCollectedData<RawRumErrorEvent> {\n  const rawRumEvent: RawRumErrorEvent = {\n    date: error.startClocks.timeStamp,\n    error: {\n      id: generateUUID(),\n      message: error.message,\n      source: error.source,\n      stack: error.stack,\n      handling_stack: error.handlingStack,\n      component_stack: error.componentStack,\n      type: error.type,\n      handling: error.handling,\n      causes: error.causes,\n      source_type: 'browser',\n      fingerprint: error.fingerprint,\n      csp: error.csp,\n    },\n    type: RumEventType.ERROR as const,\n    view: { in_foreground: pageStateHistory.wasInPageStateAt(PageState.ACTIVE, error.startClocks.relative) },\n  }\n\n  const domainContext: RumErrorEventDomainContext = {\n    error: error.originalError,\n    handlingStack: error.handlingStack,\n  }\n\n  return {\n    rawRumEvent,\n    startTime: error.startClocks.relative,\n    domainContext,\n  }\n}\n","import type { Observable, RawError } from '@datadog/browser-core'\nimport { initConsoleObservable, ConsoleApiName } from '@datadog/browser-core'\n\nexport function trackConsoleError(errorObservable: Observable<RawError>) {\n  const subscription = initConsoleObservable([ConsoleApiName.error]).subscribe((consoleLog) =>\n    errorObservable.notify(consoleLog.error)\n  )\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n  }\n}\n","import { instrumentMethod } from '../../tools/instrumentMethod'\nimport type { Observable } from '../../tools/observable'\nimport { clocksNow } from '../../tools/utils/timeUtils'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTrace, computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'\nimport { computeRawError, isError } from './error'\nimport type { RawError } from './error.types'\nimport { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'\n\nexport type UnhandledErrorCallback = (stackTrace: StackTrace, originalError?: any) => any\n\nexport function trackRuntimeError(errorObservable: Observable<RawError>) {\n  const handleRuntimeError = (stackTrace: StackTrace, originalError?: any) => {\n    const rawError = computeRawError({\n      stackTrace,\n      originalError,\n      startClocks: clocksNow(),\n      nonErrorPrefix: NonErrorPrefix.UNCAUGHT,\n      source: ErrorSource.SOURCE,\n      handling: ErrorHandling.UNHANDLED,\n    })\n    errorObservable.notify(rawError)\n  }\n  const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)\n  const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)\n\n  return {\n    stop: () => {\n      stopInstrumentingOnError()\n      stopInstrumentingOnUnhandledRejection()\n    },\n  }\n}\n\nexport function instrumentOnError(callback: UnhandledErrorCallback) {\n  return instrumentMethod(window, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {\n    let stackTrace\n    if (isError(errorObj)) {\n      stackTrace = computeStackTrace(errorObj)\n    } else {\n      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)\n    }\n    callback(stackTrace, errorObj ?? messageObj)\n  })\n}\n\nexport function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {\n  return instrumentMethod(window, 'onunhandledrejection', ({ parameters: [e] }) => {\n    const reason = e.reason || 'Empty reason'\n    const stack = computeStackTrace(reason)\n    callback(stack, reason)\n  })\n}\n","import type { Observable, RawError } from '@datadog/browser-core'\nimport { initReportObservable, RawReportType } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\n\nexport function trackReportError(configuration: RumConfiguration, errorObservable: Observable<RawError>) {\n  const subscription = initReportObservable(configuration, [\n    RawReportType.cspViolation,\n    RawReportType.intervention,\n  ]).subscribe((rawError) => errorObservable.notify(rawError))\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n  }\n}\n","import { ONE_SECOND } from './utils/timeUtils'\nimport { requestIdleCallback } from './requestIdleCallback'\n\n/**\n * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long\n * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose\n * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt\n * performance.\n */\nconst IDLE_CALLBACK_TIMEOUT = ONE_SECOND\n\n/**\n * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is\n * reached. We should not run tasks for too long as it will hurt performance, but we should still\n * run some tasks to avoid postponing them forever.\n *\n * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.\n */\nexport const MAX_EXECUTION_TIME_ON_TIMEOUT = 30\n\nexport interface TaskQueue {\n  push(task: Task): void\n}\n\ntype Task = () => void\n\nexport function createTaskQueue(): TaskQueue {\n  const pendingTasks: Task[] = []\n\n  function run(deadline: IdleDeadline) {\n    let executionTimeRemaining: () => number\n    if (deadline.didTimeout) {\n      const start = performance.now()\n      executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)\n    } else {\n      executionTimeRemaining = deadline.timeRemaining.bind(deadline)\n    }\n\n    while (executionTimeRemaining() > 0 && pendingTasks.length) {\n      pendingTasks.shift()!()\n    }\n\n    if (pendingTasks.length) {\n      scheduleNextRun()\n    }\n  }\n\n  function scheduleNextRun() {\n    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })\n  }\n\n  return {\n    push(task) {\n      if (pendingTasks.push(task) === 1) {\n        scheduleNextRun()\n      }\n    },\n  }\n}\n","import type { Duration, RelativeTime } from '@datadog/browser-core'\nimport { addDuration } from '@datadog/browser-core'\nimport type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'\nimport type { RequestCompleteEvent } from '../requestCollection'\nimport { hasValidResourceEntryDuration, hasValidResourceEntryTimings } from './resourceUtils'\n\ninterface Timing {\n  startTime: RelativeTime\n  duration: Duration\n}\n\nconst alreadyMatchedEntries = new WeakSet<PerformanceEntry>()\n\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - filter out timing that were already matched to a request\n * - then, if a single timing match, return the timing\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestResourceEntry(request: RequestCompleteEvent) {\n  if (!performance || !('getEntriesByName' in performance)) {\n    return\n  }\n  const sameNameEntries = performance.getEntriesByName(request.url, 'resource') as RumPerformanceResourceTiming[]\n\n  if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n    return\n  }\n\n  const candidates = sameNameEntries\n    .filter((entry) => !alreadyMatchedEntries.has(entry))\n    .filter((entry) => hasValidResourceEntryDuration(entry) && hasValidResourceEntryTimings(entry))\n    .filter((entry) =>\n      isBetween(\n        entry,\n        request.startClocks.relative,\n        endTime({ startTime: request.startClocks.relative, duration: request.duration })\n      )\n    )\n\n  if (candidates.length === 1) {\n    alreadyMatchedEntries.add(candidates[0])\n\n    return candidates[0].toJSON() as RumPerformanceResourceTiming\n  }\n\n  return\n}\n\nfunction endTime(timing: Timing) {\n  return addDuration(timing.startTime, timing.duration)\n}\n\nfunction isBetween(timing: Timing, start: RelativeTime, end: RelativeTime) {\n  const errorMargin = 1 as Duration\n  return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin)\n}\n","import type { TimeStamp } from '@datadog/browser-core'\nimport { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core'\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils'\n\ninterface DocumentTraceData {\n  traceId: string\n  traceTime: TimeStamp\n}\n\nexport const INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE\n\nexport function getDocumentTraceId(document: Document): string | undefined {\n  const data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document)\n\n  if (!data || data.traceTime <= dateNow() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n    return undefined\n  }\n\n  return data.traceId\n}\n\nexport function getDocumentTraceDataFromMeta(document: Document): DocumentTraceData | undefined {\n  const traceIdMeta = document.querySelector<HTMLMetaElement>('meta[name=dd-trace-id]')\n  const traceTimeMeta = document.querySelector<HTMLMetaElement>('meta[name=dd-trace-time]')\n  return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content)\n}\n\nexport function getDocumentTraceDataFromComment(document: Document): DocumentTraceData | undefined {\n  const comment = findTraceComment(document)\n  if (!comment) {\n    return undefined\n  }\n  return createDocumentTraceData(\n    findCommaSeparatedValue(comment, 'trace-id'),\n    findCommaSeparatedValue(comment, 'trace-time')\n  )\n}\n\nexport function createDocumentTraceData(\n  traceId: string | undefined | null,\n  rawTraceTime: string | undefined | null\n): DocumentTraceData | undefined {\n  const traceTime = rawTraceTime && (Number(rawTraceTime) as TimeStamp)\n  if (!traceId || !traceTime) {\n    return undefined\n  }\n\n  return {\n    traceId,\n    traceTime,\n  }\n}\n\nexport function findTraceComment(document: Document): string | undefined {\n  // 1. Try to find the comment as a direct child of the document\n  // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n  // value is not an array or string (here, a NodeList).\n  for (let i = 0; i < document.childNodes.length; i += 1) {\n    const comment = getTraceCommentFromNode(document.childNodes[i])\n    if (comment) {\n      return comment\n    }\n  }\n\n  // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n  // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n  // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n  // reverse order, stopping if we come across a non-text node.\n  if (document.body) {\n    for (let i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n      const node = document.body.childNodes[i]\n      const comment = getTraceCommentFromNode(node)\n      if (comment) {\n        return comment\n      }\n      if (!isTextNode(node)) {\n        break\n      }\n    }\n  }\n}\n\nfunction getTraceCommentFromNode(node: Node | null) {\n  if (node && isCommentNode(node)) {\n    const match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data)\n    if (match) {\n      return match[1]\n    }\n  }\n}\n","import type { RelativeTime, TimeStamp } from '@datadog/browser-core'\nimport { getRelativeTime, isNumber } from '@datadog/browser-core'\nimport {\n  RumPerformanceEntryType,\n  supportPerformanceTimingEvent,\n  type RumPerformanceNavigationTiming,\n} from './performanceObservable'\n\nexport function getNavigationEntry(): RumPerformanceNavigationTiming {\n  if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n    const navigationEntry = performance.getEntriesByType(\n      RumPerformanceEntryType.NAVIGATION\n    )[0] as unknown as RumPerformanceNavigationTiming\n    if (navigationEntry) {\n      return navigationEntry\n    }\n  }\n\n  const timings = computeTimingsFromDeprecatedPerformanceTiming()\n  const entry: RumPerformanceNavigationTiming = {\n    entryType: RumPerformanceEntryType.NAVIGATION as const,\n    initiatorType: 'navigation' as const,\n    name: window.location.href,\n    startTime: 0 as RelativeTime,\n    duration: timings.responseEnd,\n    decodedBodySize: 0,\n    encodedBodySize: 0,\n    transferSize: 0,\n    workerStart: 0 as RelativeTime,\n    toJSON: () => ({ ...entry, toJSON: undefined }),\n    ...timings,\n  }\n\n  return entry\n}\n\nexport type TimingsFromDeprecatedPerformanceTiming = {\n  -readonly [key in keyof Omit<PerformanceTiming, 'toJSON'>]: RelativeTime\n}\n\nexport function computeTimingsFromDeprecatedPerformanceTiming() {\n  const result: Partial<TimingsFromDeprecatedPerformanceTiming> = {}\n  const timing = performance.timing\n\n  for (const key in timing) {\n    if (isNumber(timing[key as keyof PerformanceTiming])) {\n      const numberKey = key as keyof TimingsFromDeprecatedPerformanceTiming\n      const timingElement = timing[numberKey] as TimeStamp\n      result[numberKey] = timingElement === 0 ? (0 as RelativeTime) : getRelativeTime(timingElement)\n    }\n  }\n  return result as TimingsFromDeprecatedPerformanceTiming\n}\n","import { runOnReadyState } from '@datadog/browser-core'\nimport { RumPerformanceEntryType } from '../../browser/performanceObservable'\nimport type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'\nimport type { RumConfiguration } from '../configuration'\nimport { getDocumentTraceId } from '../tracing/getDocumentTraceId'\nimport { getNavigationEntry } from '../../browser/performanceUtils'\nimport { FAKE_INITIAL_DOCUMENT } from './resourceUtils'\n\nexport function retrieveInitialDocumentResourceTiming(\n  configuration: RumConfiguration,\n  callback: (timing: RumPerformanceResourceTiming) => void\n) {\n  runOnReadyState(configuration, 'interactive', () => {\n    const entry: RumPerformanceResourceTiming = Object.assign(getNavigationEntry().toJSON(), {\n      entryType: RumPerformanceEntryType.RESOURCE as const,\n      initiatorType: FAKE_INITIAL_DOCUMENT,\n      traceId: getDocumentTraceId(document),\n      toJSON: () => ({ ...entry, toJSON: undefined }),\n    })\n    callback(entry)\n  })\n}\n","import type { ClocksState, Duration } from '@datadog/browser-core'\nimport {\n  combine,\n  generateUUID,\n  RequestType,\n  ResourceType,\n  toServerDuration,\n  relativeToClocks,\n  createTaskQueue,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport {\n  RumPerformanceEntryType,\n  createPerformanceObservable,\n  type RumPerformanceResourceTiming,\n} from '../../browser/performanceObservable'\nimport type { RumXhrResourceEventDomainContext, RumFetchResourceEventDomainContext } from '../../domainContext.types'\nimport type { RawRumResourceEvent } from '../../rawRumEvent.types'\nimport { RumEventType } from '../../rawRumEvent.types'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { RawRumEventCollectedData, LifeCycle } from '../lifeCycle'\nimport type { RequestCompleteEvent } from '../requestCollection'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport { PageState } from '../contexts/pageStateHistory'\nimport { createSpanIdentifier } from '../tracing/identifier'\nimport { matchRequestResourceEntry } from './matchRequestResourceEntry'\nimport {\n  computeResourceEntryDetails,\n  computeResourceEntryDuration,\n  computeResourceEntryType,\n  computeResourceEntrySize,\n  computeResourceEntryProtocol,\n  computeResourceEntryDeliveryType,\n  isResourceEntryRequestType,\n  isLongDataUrl,\n  sanitizeDataUrl,\n} from './resourceUtils'\nimport { retrieveInitialDocumentResourceTiming } from './retrieveInitialDocumentResourceTiming'\n\nexport function startResourceCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  pageStateHistory: PageStateHistory,\n  taskQueue = createTaskQueue(),\n  retrieveInitialDocumentResourceTimingImpl = retrieveInitialDocumentResourceTiming\n) {\n  lifeCycle.subscribe(LifeCycleEventType.REQUEST_COMPLETED, (request: RequestCompleteEvent) => {\n    handleResource(() => processRequest(request, configuration, pageStateHistory))\n  })\n\n  const performanceResourceSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.RESOURCE,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      if (!isResourceEntryRequestType(entry)) {\n        handleResource(() => processResourceEntry(entry, configuration))\n      }\n    }\n  })\n\n  retrieveInitialDocumentResourceTimingImpl(configuration, (timing) => {\n    handleResource(() => processResourceEntry(timing, configuration))\n  })\n\n  function handleResource(computeRawEvent: () => RawRumEventCollectedData<RawRumResourceEvent> | undefined) {\n    taskQueue.push(() => {\n      const rawEvent = computeRawEvent()\n      if (rawEvent) {\n        lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, rawEvent)\n      }\n    })\n  }\n\n  return {\n    stop: () => {\n      performanceResourceSubscription.unsubscribe()\n    },\n  }\n}\n\nfunction processRequest(\n  request: RequestCompleteEvent,\n  configuration: RumConfiguration,\n  pageStateHistory: PageStateHistory\n): RawRumEventCollectedData<RawRumResourceEvent> | undefined {\n  const matchingTiming = matchRequestResourceEntry(request)\n  const startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks\n  const tracingInfo = computeRequestTracingInfo(request, configuration)\n  if (!configuration.trackResources && !tracingInfo) {\n    return\n  }\n\n  const type = request.type === RequestType.XHR ? ResourceType.XHR : ResourceType.FETCH\n\n  const correspondingTimingOverrides = matchingTiming ? computeResourceEntryMetrics(matchingTiming) : undefined\n\n  const duration = computeRequestDuration(pageStateHistory, startClocks, request.duration)\n\n  const resourceEvent = combine(\n    {\n      date: startClocks.timeStamp,\n      resource: {\n        id: generateUUID(),\n        type,\n        duration,\n        method: request.method,\n        status_code: request.status,\n        protocol: matchingTiming && computeResourceEntryProtocol(matchingTiming),\n        url: isLongDataUrl(request.url) ? sanitizeDataUrl(request.url) : request.url,\n        delivery_type: matchingTiming && computeResourceEntryDeliveryType(matchingTiming),\n      },\n      type: RumEventType.RESOURCE as const,\n      _dd: {\n        discarded: !configuration.trackResources,\n      },\n    },\n    tracingInfo,\n    correspondingTimingOverrides\n  )\n\n  return {\n    startTime: startClocks.relative,\n    rawRumEvent: resourceEvent,\n    domainContext: {\n      performanceEntry: matchingTiming,\n      xhr: request.xhr,\n      response: request.response,\n      requestInput: request.input,\n      requestInit: request.init,\n      error: request.error,\n      isAborted: request.isAborted,\n      handlingStack: request.handlingStack,\n    } as RumFetchResourceEventDomainContext | RumXhrResourceEventDomainContext,\n  }\n}\n\nfunction processResourceEntry(\n  entry: RumPerformanceResourceTiming,\n  configuration: RumConfiguration\n): RawRumEventCollectedData<RawRumResourceEvent> | undefined {\n  const startClocks = relativeToClocks(entry.startTime)\n  const tracingInfo = computeResourceEntryTracingInfo(entry, configuration)\n  if (!configuration.trackResources && !tracingInfo) {\n    return\n  }\n\n  const type = computeResourceEntryType(entry)\n  const entryMetrics = computeResourceEntryMetrics(entry)\n\n  const resourceEvent = combine(\n    {\n      date: startClocks.timeStamp,\n      resource: {\n        id: generateUUID(),\n        type,\n        url: entry.name,\n        status_code: discardZeroStatus(entry.responseStatus),\n        protocol: computeResourceEntryProtocol(entry),\n        delivery_type: computeResourceEntryDeliveryType(entry),\n      },\n      type: RumEventType.RESOURCE as const,\n      _dd: {\n        discarded: !configuration.trackResources,\n      },\n    },\n    tracingInfo,\n    entryMetrics\n  )\n  return {\n    startTime: startClocks.relative,\n    rawRumEvent: resourceEvent,\n    domainContext: {\n      performanceEntry: entry,\n    },\n  }\n}\n\nfunction computeResourceEntryMetrics(entry: RumPerformanceResourceTiming) {\n  const { renderBlockingStatus } = entry\n  return {\n    resource: {\n      duration: computeResourceEntryDuration(entry),\n      render_blocking_status: renderBlockingStatus,\n      ...computeResourceEntrySize(entry),\n      ...computeResourceEntryDetails(entry),\n    },\n  }\n}\n\nfunction computeRequestTracingInfo(request: RequestCompleteEvent, configuration: RumConfiguration) {\n  const hasBeenTraced = request.traceSampled && request.traceId && request.spanId\n  if (!hasBeenTraced) {\n    return undefined\n  }\n  return {\n    _dd: {\n      span_id: request.spanId!.toString(),\n      trace_id: request.traceId!.toString(),\n      rule_psr: configuration.rulePsr,\n    },\n  }\n}\n\nfunction computeResourceEntryTracingInfo(entry: RumPerformanceResourceTiming, configuration: RumConfiguration) {\n  const hasBeenTraced = entry.traceId\n  if (!hasBeenTraced) {\n    return undefined\n  }\n  return {\n    _dd: {\n      trace_id: entry.traceId,\n      span_id: createSpanIdentifier().toString(),\n      rule_psr: configuration.rulePsr,\n    },\n  }\n}\n\nfunction computeRequestDuration(pageStateHistory: PageStateHistory, startClocks: ClocksState, duration: Duration) {\n  return !pageStateHistory.wasInPageStateDuringPeriod(PageState.FROZEN, startClocks.relative, duration)\n    ? toServerDuration(duration)\n    : undefined\n}\n\n/**\n * The status is 0 for cross-origin resources without CORS headers, so the status is meaningless, and we shouldn't report it\n * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus#cross-origin_response_status_codes\n */\nfunction discardZeroStatus(statusCode: number | undefined): number | undefined {\n  return statusCode === 0 ? undefined : statusCode\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport { ONE_MINUTE } from '@datadog/browser-core'\nimport type { RumPerformancePaintTiming } from '../../../browser/performanceObservable'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable'\nimport type { RumConfiguration } from '../../configuration'\nimport type { FirstHidden } from './trackFirstHidden'\n\n// Discard FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE\n\nexport function trackFirstContentfulPaint(\n  configuration: RumConfiguration,\n  firstHidden: FirstHidden,\n  callback: (fcpTiming: RelativeTime) => void\n) {\n  const performanceSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.PAINT,\n    buffered: true,\n  }).subscribe((entries) => {\n    const fcpEntry = entries.find(\n      (entry): entry is RumPerformancePaintTiming =>\n        entry.name === 'first-contentful-paint' &&\n        entry.startTime < firstHidden.timeStamp &&\n        entry.startTime < FCP_MAXIMUM_DELAY\n    )\n    if (fcpEntry) {\n      callback(fcpEntry.startTime)\n    }\n  })\n  return {\n    stop: performanceSubscription.unsubscribe,\n  }\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport { DOM_EVENT, ONE_MINUTE, addEventListeners, findLast } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../../configuration'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable'\nimport type { RumLargestContentfulPaintTiming } from '../../../browser/performanceObservable'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport type { FirstHidden } from './trackFirstHidden'\n\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE\n\nexport interface LargestContentfulPaint {\n  value: RelativeTime\n  targetSelector?: string\n}\n\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts\n */\nexport function trackLargestContentfulPaint(\n  configuration: RumConfiguration,\n  firstHidden: FirstHidden,\n  eventTarget: Window,\n  callback: (largestContentfulPaint: LargestContentfulPaint) => void\n) {\n  // Ignore entries that come after the first user interaction. According to the documentation, the\n  // browser should not send largest-contentful-paint entries after a user interact with the page,\n  // but the web-vitals reference implementation uses this as a safeguard.\n  let firstInteractionTimestamp = Infinity\n  const { stop: stopEventListener } = addEventListeners(\n    configuration,\n    eventTarget,\n    [DOM_EVENT.POINTER_DOWN, DOM_EVENT.KEY_DOWN],\n    (event) => {\n      firstInteractionTimestamp = event.timeStamp\n    },\n    { capture: true, once: true }\n  )\n\n  let biggestLcpSize = 0\n  const performanceLcpSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n    buffered: true,\n  }).subscribe((entries) => {\n    const lcpEntry = findLast(\n      entries,\n      (entry): entry is RumLargestContentfulPaintTiming =>\n        entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n        entry.startTime < firstInteractionTimestamp &&\n        entry.startTime < firstHidden.timeStamp &&\n        entry.startTime < LCP_MAXIMUM_DELAY &&\n        // Ensure to get the LCP entry with the biggest size, see\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655\n        entry.size > biggestLcpSize\n    )\n\n    if (lcpEntry) {\n      let lcpTargetSelector\n      if (lcpEntry.element) {\n        lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute)\n      }\n\n      callback({\n        value: lcpEntry.startTime,\n        targetSelector: lcpTargetSelector,\n      })\n      biggestLcpSize = lcpEntry.size\n    }\n  })\n\n  return {\n    stop: () => {\n      stopEventListener()\n      performanceLcpSubscription.unsubscribe()\n    },\n  }\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport { addEventListeners, DOM_EVENT } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../../configuration'\n\nexport type FirstHidden = ReturnType<typeof trackFirstHidden>\n\nexport function trackFirstHidden(configuration: RumConfiguration, eventTarget: Window = window) {\n  let timeStamp: RelativeTime\n  let stopListeners: () => void | undefined\n\n  if (document.visibilityState === 'hidden') {\n    timeStamp = 0 as RelativeTime\n  } else {\n    timeStamp = Infinity as RelativeTime\n    ;({ stop: stopListeners } = addEventListeners(\n      configuration,\n      eventTarget,\n      [DOM_EVENT.PAGE_HIDE, DOM_EVENT.VISIBILITY_CHANGE],\n      (event) => {\n        if (event.type === DOM_EVENT.PAGE_HIDE || document.visibilityState === 'hidden') {\n          timeStamp = event.timeStamp as RelativeTime\n          stopListeners()\n        }\n      },\n      { capture: true }\n    ))\n  }\n\n  return {\n    get timeStamp() {\n      return timeStamp\n    },\n    stop() {\n      stopListeners?.()\n    },\n  }\n}\n","import type { Duration } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../../configuration'\nimport { trackFirstContentfulPaint } from './trackFirstContentfulPaint'\nimport type { FirstInput } from './trackFirstInput'\nimport { trackFirstInput } from './trackFirstInput'\nimport type { NavigationTimings } from './trackNavigationTimings'\nimport { trackNavigationTimings } from './trackNavigationTimings'\nimport type { LargestContentfulPaint } from './trackLargestContentfulPaint'\nimport { trackLargestContentfulPaint } from './trackLargestContentfulPaint'\nimport { trackFirstHidden } from './trackFirstHidden'\n\nexport interface InitialViewMetrics {\n  firstContentfulPaint?: Duration\n  navigationTimings?: NavigationTimings\n  largestContentfulPaint?: LargestContentfulPaint\n  firstInput?: FirstInput\n}\n\nexport function trackInitialViewMetrics(\n  configuration: RumConfiguration,\n  setLoadEvent: (loadEnd: Duration) => void,\n  scheduleViewUpdate: () => void\n) {\n  const initialViewMetrics: InitialViewMetrics = {}\n\n  const { stop: stopNavigationTracking } = trackNavigationTimings(configuration, (navigationTimings) => {\n    setLoadEvent(navigationTimings.loadEvent)\n    initialViewMetrics.navigationTimings = navigationTimings\n    scheduleViewUpdate()\n  })\n\n  const firstHidden = trackFirstHidden(configuration)\n  const { stop: stopFCPTracking } = trackFirstContentfulPaint(configuration, firstHidden, (firstContentfulPaint) => {\n    initialViewMetrics.firstContentfulPaint = firstContentfulPaint\n    scheduleViewUpdate()\n  })\n\n  const { stop: stopLCPTracking } = trackLargestContentfulPaint(\n    configuration,\n    firstHidden,\n    window,\n    (largestContentfulPaint) => {\n      initialViewMetrics.largestContentfulPaint = largestContentfulPaint\n      scheduleViewUpdate()\n    }\n  )\n\n  const { stop: stopFIDTracking } = trackFirstInput(configuration, firstHidden, (firstInput) => {\n    initialViewMetrics.firstInput = firstInput\n    scheduleViewUpdate()\n  })\n\n  function stop() {\n    stopNavigationTracking()\n    stopFCPTracking()\n    stopLCPTracking()\n    stopFIDTracking()\n    firstHidden.stop()\n  }\n\n  return {\n    stop,\n    initialViewMetrics,\n  }\n}\n","import type { Duration, TimeoutId } from '@datadog/browser-core'\nimport { setTimeout, relativeNow, runOnReadyState, clearTimeout } from '@datadog/browser-core'\nimport type { RumPerformanceNavigationTiming } from '../../../browser/performanceObservable'\nimport type { RumConfiguration } from '../../configuration'\nimport { getNavigationEntry } from '../../../browser/performanceUtils'\n\nexport interface NavigationTimings {\n  domComplete: Duration\n  domContentLoaded: Duration\n  domInteractive: Duration\n  loadEvent: Duration\n  firstByte: Duration | undefined\n}\n\n// This is a subset of \"RumPerformanceNavigationTiming\" that only contains the relevant fields for\n// computing navigation timings. This is useful to mock the navigation entry in tests.\nexport type RelevantNavigationTiming = Pick<\n  RumPerformanceNavigationTiming,\n  'domComplete' | 'domContentLoadedEventEnd' | 'domInteractive' | 'loadEventEnd' | 'responseStart'\n>\n\nexport function trackNavigationTimings(\n  configuration: RumConfiguration,\n  callback: (timings: NavigationTimings) => void,\n  getNavigationEntryImpl: () => RelevantNavigationTiming = getNavigationEntry\n) {\n  return waitAfterLoadEvent(configuration, () => {\n    const entry = getNavigationEntryImpl()\n\n    if (!isIncompleteNavigation(entry)) {\n      callback(processNavigationEntry(entry))\n    }\n  })\n}\n\nfunction processNavigationEntry(entry: RelevantNavigationTiming): NavigationTimings {\n  return {\n    domComplete: entry.domComplete,\n    domContentLoaded: entry.domContentLoadedEventEnd,\n    domInteractive: entry.domInteractive,\n    loadEvent: entry.loadEventEnd,\n    // In some cases the value reported is negative or is larger\n    // than the current page time. Ignore these cases:\n    // https://github.com/GoogleChrome/web-vitals/issues/137\n    // https://github.com/GoogleChrome/web-vitals/issues/162\n    firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\n  }\n}\n\nfunction isIncompleteNavigation(entry: RelevantNavigationTiming) {\n  return entry.loadEventEnd <= 0\n}\n\nfunction waitAfterLoadEvent(configuration: RumConfiguration, callback: () => void) {\n  let timeoutId: TimeoutId | undefined\n  const { stop: stopOnReadyState } = runOnReadyState(configuration, 'complete', () => {\n    // Invoke the callback a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n    timeoutId = setTimeout(() => callback())\n  })\n  return {\n    stop: () => {\n      stopOnReadyState()\n      clearTimeout(timeoutId)\n    },\n  }\n}\n","import type { Duration, RelativeTime } from '@datadog/browser-core'\nimport { elapsed } from '@datadog/browser-core'\nimport { isElementNode } from '../../../browser/htmlDomUtils'\nimport type { RumConfiguration } from '../../configuration'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable'\nimport type { RumFirstInputTiming } from '../../../browser/performanceObservable'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport type { FirstHidden } from './trackFirstHidden'\n\nexport interface FirstInput {\n  delay: Duration\n  time: RelativeTime\n  targetSelector?: string\n}\n\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInput(\n  configuration: RumConfiguration,\n  firstHidden: FirstHidden,\n  callback: (firstInput: FirstInput) => void\n) {\n  const performanceFirstInputSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.FIRST_INPUT,\n    buffered: true,\n  }).subscribe((entries) => {\n    const firstInputEntry = entries.find(\n      (entry): entry is RumFirstInputTiming => entry.startTime < firstHidden.timeStamp\n    )\n    if (firstInputEntry) {\n      const firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart)\n      let firstInputTargetSelector\n\n      if (firstInputEntry.target && isElementNode(firstInputEntry.target)) {\n        firstInputTargetSelector = getSelectorFromElement(firstInputEntry.target, configuration.actionNameAttribute)\n      }\n\n      callback({\n        // Ensure firstInputDelay to be positive, see\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n        delay: firstInputDelay >= 0 ? firstInputDelay : (0 as Duration),\n        time: firstInputEntry.startTime,\n        targetSelector: firstInputTargetSelector,\n      })\n    }\n  })\n\n  return {\n    stop: () => {\n      performanceFirstInputSubscription.unsubscribe()\n    },\n  }\n}\n","import { round, ONE_SECOND, noop, elapsed } from '@datadog/browser-core'\nimport type { Duration, RelativeTime, WeakRef, WeakRefConstructor } from '@datadog/browser-core'\nimport { isElementNode } from '../../../browser/htmlDomUtils'\nimport type { RumLayoutShiftAttribution, RumLayoutShiftTiming } from '../../../browser/performanceObservable'\nimport {\n  supportPerformanceTimingEvent,\n  RumPerformanceEntryType,\n  createPerformanceObservable,\n} from '../../../browser/performanceObservable'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport type { RumConfiguration } from '../../configuration'\nimport type { RumRect } from '../../../rumEvent.types'\n\ndeclare const WeakRef: WeakRefConstructor\n\nexport interface CumulativeLayoutShift {\n  value: number\n  targetSelector?: string\n  time?: Duration\n  previousRect?: RumRect\n  currentRect?: RumRect\n}\n\ninterface LayoutShiftInstance {\n  target: WeakRef<Element> | undefined\n  time: Duration\n  previousRect: DOMRectReadOnly | undefined\n  currentRect: DOMRectReadOnly | undefined\n}\n\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nexport function trackCumulativeLayoutShift(\n  configuration: RumConfiguration,\n  viewStart: RelativeTime,\n  callback: (cumulativeLayoutShift: CumulativeLayoutShift) => void\n) {\n  if (!isLayoutShiftSupported()) {\n    return {\n      stop: noop,\n    }\n  }\n\n  let maxClsValue = 0\n  let biggestShift: LayoutShiftInstance | undefined\n\n  // if no layout shift happen the value should be reported as 0\n  callback({\n    value: 0,\n  })\n\n  const window = slidingSessionWindow()\n  const performanceSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.LAYOUT_SHIFT,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      if (entry.hadRecentInput || entry.startTime < viewStart) {\n        continue\n      }\n\n      const { cumulatedValue, isMaxValue } = window.update(entry)\n\n      if (isMaxValue) {\n        const attribution = getFirstElementAttribution(entry.sources)\n        biggestShift = {\n          target: attribution?.node ? new WeakRef(attribution.node) : undefined,\n          time: elapsed(viewStart, entry.startTime),\n          previousRect: attribution?.previousRect,\n          currentRect: attribution?.currentRect,\n        }\n      }\n\n      if (cumulatedValue > maxClsValue) {\n        maxClsValue = cumulatedValue\n        const target = biggestShift?.target?.deref()\n\n        callback({\n          value: round(maxClsValue, 4),\n          targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),\n          time: biggestShift?.time,\n          previousRect: biggestShift?.previousRect ? asRumRect(biggestShift.previousRect) : undefined,\n          currentRect: biggestShift?.currentRect ? asRumRect(biggestShift.currentRect) : undefined,\n        })\n      }\n    }\n  })\n\n  return {\n    stop: () => {\n      performanceSubscription.unsubscribe()\n    },\n  }\n}\n\nfunction getFirstElementAttribution(\n  sources: RumLayoutShiftAttribution[]\n): (RumLayoutShiftAttribution & { node: Element }) | undefined {\n  return sources.find(\n    (source): source is RumLayoutShiftAttribution & { node: Element } => !!source.node && isElementNode(source.node)\n  )\n}\n\nfunction asRumRect({ x, y, width, height }: DOMRectReadOnly): RumRect {\n  return { x, y, width, height }\n}\n\nexport const MAX_WINDOW_DURATION = 5 * ONE_SECOND\nconst MAX_UPDATE_GAP = ONE_SECOND\n\nfunction slidingSessionWindow() {\n  let cumulatedValue = 0\n  let startTime: RelativeTime\n  let endTime: RelativeTime\n  let maxValue = 0\n\n  return {\n    update: (entry: RumLayoutShiftTiming) => {\n      const shouldCreateNewWindow =\n        startTime === undefined ||\n        entry.startTime - endTime >= MAX_UPDATE_GAP ||\n        entry.startTime - startTime >= MAX_WINDOW_DURATION\n\n      let isMaxValue: boolean\n\n      if (shouldCreateNewWindow) {\n        startTime = endTime = entry.startTime\n        maxValue = cumulatedValue = entry.value\n        isMaxValue = true\n      } else {\n        cumulatedValue += entry.value\n        endTime = entry.startTime\n        isMaxValue = entry.value > maxValue\n\n        if (isMaxValue) {\n          maxValue = entry.value\n        }\n      }\n\n      return {\n        cumulatedValue,\n        isMaxValue,\n      }\n    },\n  }\n}\n\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n  return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window\n}\n","/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\n\nimport { monitor } from '@datadog/browser-core'\nimport type {\n  BrowserWindow,\n  RumPerformanceEventTiming,\n  RumPerformanceObserver,\n} from '../../../browser/performanceObservable'\n\nlet observer: RumPerformanceObserver | undefined\n\nlet interactionCountEstimate = 0\nlet minKnownInteractionId = Infinity\nlet maxKnownInteractionId = 0\n\nexport function initInteractionCountPolyfill() {\n  if ('interactionCount' in performance || observer) {\n    return\n  }\n\n  observer = new (window as BrowserWindow).PerformanceObserver(\n    monitor((entries: PerformanceObserverEntryList) => {\n      entries.getEntries().forEach((e) => {\n        const entry = e as unknown as RumPerformanceEventTiming\n\n        if (entry.interactionId) {\n          minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId)\n          maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId)\n\n          interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1\n        }\n      })\n    })\n  )\n\n  observer.observe({ type: 'event', buffered: true, durationThreshold: 0 })\n}\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport const getInteractionCount = () =>\n  observer ? interactionCountEstimate : (window as BrowserWindow).performance.interactionCount! || 0\n","import { elapsed, noop, ONE_MINUTE } from '@datadog/browser-core'\nimport type { Duration, RelativeTime } from '@datadog/browser-core'\nimport {\n  createPerformanceObservable,\n  RumPerformanceEntryType,\n  supportPerformanceTimingEvent,\n} from '../../../browser/performanceObservable'\nimport type { RumFirstInputTiming, RumPerformanceEventTiming } from '../../../browser/performanceObservable'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport { isElementNode } from '../../../browser/htmlDomUtils'\nimport { getInteractionSelector } from '../../action/interactionSelectorCache'\nimport type { RumConfiguration } from '../../configuration'\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill'\n\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nconst MAX_INTERACTION_ENTRIES = 10\n// Arbitrary value to cap INP outliers\nexport const MAX_INP_VALUE = (1 * ONE_MINUTE) as Duration\n\nexport interface InteractionToNextPaint {\n  value: Duration\n  targetSelector?: string\n  time?: Duration\n}\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(\n  configuration: RumConfiguration,\n  viewStart: RelativeTime,\n  viewLoadingType: ViewLoadingType\n) {\n  if (!isInteractionToNextPaintSupported()) {\n    return {\n      getInteractionToNextPaint: () => undefined,\n      setViewEnd: noop,\n      stop: noop,\n    }\n  }\n\n  const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType)\n\n  let viewEnd = Infinity as RelativeTime\n\n  const longestInteractions = trackLongestInteractions(getViewInteractionCount)\n  let interactionToNextPaint = -1 as Duration\n  let interactionToNextPaintTargetSelector: string | undefined\n  let interactionToNextPaintStartTime: Duration | undefined\n\n  function handleEntries(entries: Array<RumPerformanceEventTiming | RumFirstInputTiming>) {\n    for (const entry of entries) {\n      if (\n        entry.interactionId &&\n        // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).\n        entry.startTime >= viewStart &&\n        entry.startTime <= viewEnd\n      ) {\n        longestInteractions.process(entry)\n      }\n    }\n\n    const newInteraction = longestInteractions.estimateP98Interaction()\n    if (newInteraction && newInteraction.duration !== interactionToNextPaint) {\n      interactionToNextPaint = newInteraction.duration\n      interactionToNextPaintStartTime = elapsed(viewStart, newInteraction.startTime)\n      interactionToNextPaintTargetSelector = getInteractionSelector(newInteraction.startTime)\n      if (!interactionToNextPaintTargetSelector && newInteraction.target && isElementNode(newInteraction.target)) {\n        interactionToNextPaintTargetSelector = getSelectorFromElement(\n          newInteraction.target,\n          configuration.actionNameAttribute\n        )\n      }\n    }\n  }\n\n  const firstInputSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.FIRST_INPUT,\n    buffered: true,\n  }).subscribe(handleEntries)\n\n  const eventSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.EVENT,\n    // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n    // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L202-L210\n    durationThreshold: 40,\n    buffered: true,\n  }).subscribe(handleEntries)\n\n  return {\n    getInteractionToNextPaint: (): InteractionToNextPaint | undefined => {\n      // If no INP duration where captured because of the performanceObserver 40ms threshold\n      // but the view interaction count > 0 then report 0\n      if (interactionToNextPaint >= 0) {\n        return {\n          value: Math.min(interactionToNextPaint, MAX_INP_VALUE) as Duration,\n          targetSelector: interactionToNextPaintTargetSelector,\n          time: interactionToNextPaintStartTime,\n        }\n      } else if (getViewInteractionCount()) {\n        return {\n          value: 0 as Duration,\n        }\n      }\n    },\n    setViewEnd: (viewEndTime: RelativeTime) => {\n      viewEnd = viewEndTime\n      stopViewInteractionCount()\n    },\n    stop: () => {\n      eventSubscription.unsubscribe()\n      firstInputSubscription.unsubscribe()\n    },\n  }\n}\n\nfunction trackLongestInteractions(getViewInteractionCount: () => number) {\n  const longestInteractions: Array<RumPerformanceEventTiming | RumFirstInputTiming> = []\n\n  function sortAndTrimLongestInteractions() {\n    longestInteractions.sort((a, b) => b.duration - a.duration).splice(MAX_INTERACTION_ENTRIES)\n  }\n\n  return {\n    /**\n     * Process the performance entry:\n     * - if its duration is long enough, add the performance entry to the list of worst interactions\n     * - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions\n     */\n    process(entry: RumPerformanceEventTiming | RumFirstInputTiming) {\n      const interactionIndex = longestInteractions.findIndex(\n        (interaction) => entry.interactionId === interaction.interactionId\n      )\n\n      const minLongestInteraction = longestInteractions[longestInteractions.length - 1]\n\n      if (interactionIndex !== -1) {\n        if (entry.duration > longestInteractions[interactionIndex].duration) {\n          longestInteractions[interactionIndex] = entry\n          sortAndTrimLongestInteractions()\n        }\n      } else if (\n        longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n        entry.duration > minLongestInteraction.duration\n      ) {\n        longestInteractions.push(entry)\n        sortAndTrimLongestInteractions()\n      }\n    },\n    /**\n     * Compute the p98 longest interaction.\n     * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n     */\n    estimateP98Interaction(): RumPerformanceEventTiming | RumFirstInputTiming | undefined {\n      const interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50))\n      return longestInteractions[interactionIndex]\n    },\n  }\n}\n\nexport function trackViewInteractionCount(viewLoadingType: ViewLoadingType) {\n  initInteractionCountPolyfill()\n  const previousInteractionCount = viewLoadingType === ViewLoadingType.INITIAL_LOAD ? 0 : getInteractionCount()\n  let state: { stopped: false } | { stopped: true; interactionCount: number } = { stopped: false }\n\n  function computeViewInteractionCount() {\n    return getInteractionCount() - previousInteractionCount\n  }\n\n  return {\n    getViewInteractionCount: () => {\n      if (state.stopped) {\n        return state.interactionCount\n      }\n\n      return computeViewInteractionCount()\n    },\n    stopViewInteractionCount: () => {\n      state = { stopped: true, interactionCount: computeViewInteractionCount() }\n    },\n  }\n}\n\nexport function isInteractionToNextPaintSupported() {\n  return (\n    supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n    window.PerformanceEventTiming &&\n    'interactionId' in PerformanceEventTiming.prototype\n  )\n}\n","export function getScrollX() {\n  let scrollX\n  const visual = window.visualViewport\n  if (visual) {\n    scrollX = visual.pageLeft - visual.offsetLeft\n  } else if (window.scrollX !== undefined) {\n    scrollX = window.scrollX\n  } else {\n    scrollX = window.pageXOffset || 0\n  }\n  return Math.round(scrollX)\n}\n\nexport function getScrollY() {\n  let scrollY\n  const visual = window.visualViewport\n  if (visual) {\n    scrollY = visual.pageTop - visual.offsetTop\n  } else if (window.scrollY !== undefined) {\n    scrollY = window.scrollY\n  } else {\n    scrollY = window.pageYOffset || 0\n  }\n  return Math.round(scrollY)\n}\n","import { Observable, throttle, addEventListener, DOM_EVENT } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../domain/configuration'\n\nexport interface ViewportDimension {\n  height: number\n  width: number\n}\n\nlet viewportObservable: Observable<ViewportDimension> | undefined\n\nexport function initViewportObservable(configuration: RumConfiguration) {\n  if (!viewportObservable) {\n    viewportObservable = createViewportObservable(configuration)\n  }\n  return viewportObservable\n}\n\nexport function createViewportObservable(configuration: RumConfiguration) {\n  return new Observable<ViewportDimension>((observable) => {\n    const { throttled: updateDimension } = throttle(() => {\n      observable.notify(getViewportDimension())\n    }, 200)\n\n    return addEventListener(configuration, window, DOM_EVENT.RESIZE, updateDimension, { capture: true, passive: true })\n      .stop\n  })\n}\n\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension(): ViewportDimension {\n  const visual = window.visualViewport\n  if (visual) {\n    return {\n      width: Number(visual.width * visual.scale),\n      height: Number(visual.height * visual.scale),\n    }\n  }\n\n  return {\n    width: Number(window.innerWidth || 0),\n    height: Number(window.innerHeight || 0),\n  }\n}\n","import type { ClocksState, Duration } from '@datadog/browser-core'\nimport {\n  Observable,\n  ONE_SECOND,\n  elapsed,\n  relativeNow,\n  throttle,\n  addEventListener,\n  DOM_EVENT,\n  monitor,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../../configuration'\nimport { getScrollY } from '../../../browser/scroll'\nimport { getViewportDimension } from '../../../browser/viewportObservable'\n\n/** Arbitrary scroll throttle duration */\nexport const THROTTLE_SCROLL_DURATION = ONE_SECOND\n\nexport interface ScrollMetrics {\n  maxDepth: number\n  maxScrollHeight: number\n  maxDepthScrollTop: number\n  maxScrollHeightTime: Duration\n}\n\nexport function trackScrollMetrics(\n  configuration: RumConfiguration,\n  viewStart: ClocksState,\n  callback: (scrollMetrics: ScrollMetrics) => void,\n  scrollValues = createScrollValuesObservable(configuration)\n) {\n  let maxScrollDepth = 0\n  let maxScrollHeight = 0\n  let maxScrollHeightTime = 0 as Duration\n\n  const subscription = scrollValues.subscribe(({ scrollDepth, scrollTop, scrollHeight }) => {\n    let shouldUpdate = false\n\n    if (scrollDepth > maxScrollDepth) {\n      maxScrollDepth = scrollDepth\n      shouldUpdate = true\n    }\n\n    if (scrollHeight > maxScrollHeight) {\n      maxScrollHeight = scrollHeight\n      const now = relativeNow()\n      maxScrollHeightTime = elapsed(viewStart.relative, now)\n      shouldUpdate = true\n    }\n\n    if (shouldUpdate) {\n      callback({\n        maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n        maxDepthScrollTop: scrollTop,\n        maxScrollHeight,\n        maxScrollHeightTime,\n      })\n    }\n  })\n\n  return {\n    stop: () => subscription.unsubscribe(),\n  }\n}\n\nexport interface ScrollValues {\n  scrollDepth: number\n  scrollTop: number\n  scrollHeight: number\n}\n\nexport function computeScrollValues() {\n  const scrollTop = getScrollY()\n\n  const { height } = getViewportDimension()\n\n  const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight)\n\n  const scrollDepth = Math.round(height + scrollTop)\n\n  return {\n    scrollHeight,\n    scrollDepth,\n    scrollTop,\n  }\n}\n\nexport function createScrollValuesObservable(\n  configuration: RumConfiguration,\n  throttleDuration = THROTTLE_SCROLL_DURATION\n): Observable<ScrollValues> {\n  return new Observable<ScrollValues>((observable) => {\n    function notify() {\n      observable.notify(computeScrollValues())\n    }\n\n    if (window.ResizeObserver) {\n      const throttledNotify = throttle(notify, throttleDuration, {\n        leading: false,\n        trailing: true,\n      })\n\n      const observerTarget = document.scrollingElement || document.documentElement\n      const resizeObserver = new ResizeObserver(monitor(throttledNotify.throttled))\n      if (observerTarget) {\n        resizeObserver.observe(observerTarget)\n      }\n      const eventListener = addEventListener(configuration, window, DOM_EVENT.SCROLL, throttledNotify.throttled, {\n        passive: true,\n      })\n\n      return () => {\n        throttledNotify.cancel()\n        resizeObserver.disconnect()\n        eventListener.stop()\n      }\n    }\n  })\n}\n","import type { ClocksState, Duration, Observable } from '@datadog/browser-core'\nimport type { ViewLoadingType } from '../../../rawRumEvent.types'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport type { CumulativeLayoutShift } from './trackCumulativeLayoutShift'\nimport { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift'\nimport type { InteractionToNextPaint } from './trackInteractionToNextPaint'\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint'\nimport { trackLoadingTime } from './trackLoadingTime'\nimport type { ScrollMetrics } from './trackScrollMetrics'\nimport { trackScrollMetrics } from './trackScrollMetrics'\n\nexport interface CommonViewMetrics {\n  loadingTime?: Duration\n  cumulativeLayoutShift?: CumulativeLayoutShift\n  interactionToNextPaint?: InteractionToNextPaint\n  scroll?: ScrollMetrics\n}\n\nexport function trackCommonViewMetrics(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  scheduleViewUpdate: () => void,\n  loadingType: ViewLoadingType,\n  viewStart: ClocksState\n) {\n  const commonViewMetrics: CommonViewMetrics = {}\n\n  const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    loadingType,\n    viewStart,\n    (newLoadingTime) => {\n      commonViewMetrics.loadingTime = newLoadingTime\n      scheduleViewUpdate()\n    }\n  )\n\n  const { stop: stopScrollMetricsTracking } = trackScrollMetrics(configuration, viewStart, (newScrollMetrics) => {\n    commonViewMetrics.scroll = newScrollMetrics\n  })\n\n  const { stop: stopCLSTracking } = trackCumulativeLayoutShift(\n    configuration,\n    viewStart.relative,\n    (cumulativeLayoutShift) => {\n      commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift\n      scheduleViewUpdate()\n    }\n  )\n\n  const {\n    stop: stopINPTracking,\n    getInteractionToNextPaint,\n    setViewEnd,\n  } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType)\n\n  return {\n    stop: () => {\n      stopLoadingTimeTracking()\n      stopCLSTracking()\n      stopScrollMetricsTracking()\n    },\n    stopINPTracking,\n    setLoadEvent,\n    setViewEnd,\n    getCommonViewMetrics: () => {\n      commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint()\n      return commonViewMetrics\n    },\n  }\n}\n","import type { ClocksState, Duration, Observable } from '@datadog/browser-core'\nimport { elapsed } from '@datadog/browser-core'\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\nimport { trackFirstHidden } from './trackFirstHidden'\n\nexport function trackLoadingTime(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  loadType: ViewLoadingType,\n  viewStart: ClocksState,\n  callback: (loadingTime: Duration) => void\n) {\n  let isWaitingForLoadEvent = loadType === ViewLoadingType.INITIAL_LOAD\n  let isWaitingForActivityLoadingTime = true\n  const loadingTimeCandidates: Duration[] = []\n  const firstHidden = trackFirstHidden(configuration)\n\n  function invokeCallbackIfAllCandidatesAreReceived() {\n    if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n      const loadingTime = Math.max(...loadingTimeCandidates)\n      if (loadingTime < firstHidden.timeStamp) {\n        callback(loadingTime as Duration)\n      }\n    }\n  }\n\n  const { stop } = waitPageActivityEnd(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    (event) => {\n      if (isWaitingForActivityLoadingTime) {\n        isWaitingForActivityLoadingTime = false\n        if (event.hadActivity) {\n          loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end))\n        }\n        invokeCallbackIfAllCandidatesAreReceived()\n      }\n    }\n  )\n\n  return {\n    stop: () => {\n      stop()\n      firstHidden.stop()\n    },\n    setLoadEvent: (loadEvent: Duration) => {\n      if (isWaitingForLoadEvent) {\n        isWaitingForLoadEvent = false\n        loadingTimeCandidates.push(loadEvent)\n        invokeCallbackIfAllCandidatesAreReceived()\n      }\n    },\n  }\n}\n","import type {\n  Duration,\n  ClocksState,\n  TimeStamp,\n  Subscription,\n  RelativeTime,\n  Context,\n  ContextValue,\n} from '@datadog/browser-core'\nimport {\n  noop,\n  PageExitReason,\n  shallowClone,\n  elapsed,\n  generateUUID,\n  ONE_MINUTE,\n  throttle,\n  clocksNow,\n  clocksOrigin,\n  timeStampNow,\n  display,\n  looksLikeRelativeTime,\n  setInterval,\n  clearInterval,\n  setTimeout,\n  Observable,\n  createContextManager,\n} from '@datadog/browser-core'\nimport type { ViewCustomTimings } from '../../rawRumEvent.types'\nimport { ViewLoadingType } from '../../rawRumEvent.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { EventCounts } from '../trackEventCounts'\nimport type { LocationChange } from '../../browser/locationChangeObservable'\nimport type { RumConfiguration, RumInitConfiguration } from '../configuration'\nimport { trackViewEventCounts } from './trackViewEventCounts'\nimport { trackInitialViewMetrics } from './viewMetrics/trackInitialViewMetrics'\nimport type { InitialViewMetrics } from './viewMetrics/trackInitialViewMetrics'\nimport type { CommonViewMetrics } from './viewMetrics/trackCommonViewMetrics'\nimport { trackCommonViewMetrics } from './viewMetrics/trackCommonViewMetrics'\n\nexport interface ViewEvent {\n  id: string\n  name?: string\n  service?: string\n  version?: string\n  context?: Context\n  location: Readonly<Location>\n  commonViewMetrics: CommonViewMetrics\n  initialViewMetrics: InitialViewMetrics\n  customTimings: ViewCustomTimings\n  eventCounts: EventCounts\n  documentVersion: number\n  startClocks: ClocksState\n  duration: Duration\n  isActive: boolean\n  sessionIsActive: boolean\n  loadingType: ViewLoadingType\n}\n\nexport interface ViewCreatedEvent {\n  id: string\n  name?: string\n  service?: string\n  version?: string\n  context?: Context\n  startClocks: ClocksState\n}\n\nexport interface ViewEndedEvent {\n  endClocks: ClocksState\n}\n\nexport const THROTTLE_VIEW_UPDATE_PERIOD = 3000\nexport const SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE\n\n// Some events or metrics can be captured after the end of the view. To avoid missing those;\n// an arbitrary delay is added for stopping their tracking after the view ends.\n//\n// Ideally, we would not stop and keep tracking events or metrics until the end of the session.\n// But this might have a small performance impact if there are many many views.\n// So let's have a fairly short delay improving the situation in most cases and avoid impacting performances too much.\nexport const KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE\n\nexport interface ViewOptions {\n  name?: string\n  service?: RumInitConfiguration['service']\n  version?: RumInitConfiguration['version']\n  context?: Context\n}\n\nexport function trackViews(\n  location: Location,\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  locationChangeObservable: Observable<LocationChange>,\n  areViewsTrackedAutomatically: boolean,\n  initialViewOptions?: ViewOptions\n) {\n  const activeViews: Set<ReturnType<typeof newView>> = new Set()\n  let currentView = startNewView(ViewLoadingType.INITIAL_LOAD, clocksOrigin(), initialViewOptions)\n\n  startViewLifeCycle()\n\n  let locationChangeSubscription: Subscription\n  if (areViewsTrackedAutomatically) {\n    locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable)\n  }\n\n  function startNewView(loadingType: ViewLoadingType, startClocks?: ClocksState, viewOptions?: ViewOptions) {\n    const newlyCreatedView = newView(\n      lifeCycle,\n      domMutationObservable,\n      windowOpenObservable,\n      configuration,\n      location,\n      loadingType,\n      startClocks,\n      viewOptions\n    )\n    activeViews.add(newlyCreatedView)\n    newlyCreatedView.stopObservable.subscribe(() => {\n      activeViews.delete(newlyCreatedView)\n    })\n    return newlyCreatedView\n  }\n\n  function startViewLifeCycle() {\n    lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n      // Renew view on session renewal\n      currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, undefined, {\n        name: currentView.name,\n        service: currentView.service,\n        version: currentView.version,\n        context: currentView.contextManager.getContext(),\n      })\n    })\n\n    lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {\n      currentView.end({ sessionIsActive: false })\n    })\n\n    // End the current view on page unload\n    lifeCycle.subscribe(LifeCycleEventType.PAGE_EXITED, (pageExitEvent) => {\n      if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n        currentView.end()\n      }\n    })\n  }\n\n  function renewViewOnLocationChange(locationChangeObservable: Observable<LocationChange>) {\n    return locationChangeObservable.subscribe(({ oldLocation, newLocation }) => {\n      if (areDifferentLocation(oldLocation, newLocation)) {\n        currentView.end()\n        currentView = startNewView(ViewLoadingType.ROUTE_CHANGE)\n      }\n    })\n  }\n\n  return {\n    addTiming: (name: string, time: RelativeTime | TimeStamp = timeStampNow()) => {\n      currentView.addTiming(name, time)\n    },\n    startView: (options?: ViewOptions, startClocks?: ClocksState) => {\n      currentView.end({ endClocks: startClocks })\n      currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, startClocks, options)\n    },\n    setViewContext: (context: Context) => {\n      currentView.contextManager.setContext(context)\n    },\n    setViewContextProperty: (key: string, value: ContextValue) => {\n      currentView.contextManager.setContextProperty(key, value)\n    },\n    setViewName: (name: string) => {\n      currentView.setViewName(name)\n    },\n    getViewContext: () => currentView.contextManager.getContext(),\n\n    stop: () => {\n      if (locationChangeSubscription) {\n        locationChangeSubscription.unsubscribe()\n      }\n      currentView.end()\n      activeViews.forEach((view) => view.stop())\n    },\n  }\n}\n\nfunction newView(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  initialLocation: Location,\n  loadingType: ViewLoadingType,\n  startClocks: ClocksState = clocksNow(),\n  viewOptions?: ViewOptions\n) {\n  // Setup initial values\n  const id = generateUUID()\n  const stopObservable = new Observable<void>()\n  const customTimings: ViewCustomTimings = {}\n  let documentVersion = 0\n  let endClocks: ClocksState | undefined\n  const location = shallowClone(initialLocation)\n  const contextManager = createContextManager()\n\n  let sessionIsActive = true\n  let name: string | undefined\n  let service: string | undefined\n  let version: string | undefined\n  let context: Context | undefined\n\n  if (viewOptions) {\n    name = viewOptions.name\n    service = viewOptions.service || undefined\n    version = viewOptions.version || undefined\n    if (viewOptions.context) {\n      context = viewOptions.context\n      // use ContextManager to update the context so we always sanitize it\n      contextManager.setContext(context)\n    }\n  }\n\n  const viewCreatedEvent = {\n    id,\n    name,\n    startClocks,\n    service,\n    version,\n    context,\n  }\n  lifeCycle.notify(LifeCycleEventType.BEFORE_VIEW_CREATED, viewCreatedEvent)\n  lifeCycle.notify(LifeCycleEventType.VIEW_CREATED, viewCreatedEvent)\n\n  // Update the view every time the measures are changing\n  const { throttled: scheduleViewUpdate, cancel: cancelScheduleViewUpdate } = throttle(\n    triggerViewUpdate,\n    THROTTLE_VIEW_UPDATE_PERIOD,\n    {\n      leading: false,\n    }\n  )\n\n  const {\n    setLoadEvent,\n    setViewEnd,\n    stop: stopCommonViewMetricsTracking,\n    stopINPTracking,\n    getCommonViewMetrics,\n  } = trackCommonViewMetrics(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    scheduleViewUpdate,\n    loadingType,\n    startClocks\n  )\n\n  const { stop: stopInitialViewMetricsTracking, initialViewMetrics } =\n    loadingType === ViewLoadingType.INITIAL_LOAD\n      ? trackInitialViewMetrics(configuration, setLoadEvent, scheduleViewUpdate)\n      : { stop: noop, initialViewMetrics: {} as InitialViewMetrics }\n\n  const { stop: stopEventCountsTracking, eventCounts } = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate)\n\n  // Session keep alive\n  const keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL)\n\n  // Initial view update\n  triggerViewUpdate()\n  contextManager.changeObservable.subscribe(triggerViewUpdate)\n\n  function triggerViewUpdate() {\n    cancelScheduleViewUpdate()\n    documentVersion += 1\n    const currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp\n    lifeCycle.notify(LifeCycleEventType.VIEW_UPDATED, {\n      customTimings,\n      documentVersion,\n      id,\n      name,\n      service,\n      version,\n      context: contextManager.getContext(),\n      loadingType,\n      location,\n      startClocks,\n      commonViewMetrics: getCommonViewMetrics(),\n      initialViewMetrics,\n      duration: elapsed(startClocks.timeStamp, currentEnd),\n      isActive: endClocks === undefined,\n      sessionIsActive,\n      eventCounts,\n    })\n  }\n\n  return {\n    get name() {\n      return name\n    },\n    service,\n    version,\n    contextManager,\n    stopObservable,\n    end(options: { endClocks?: ClocksState; sessionIsActive?: boolean } = {}) {\n      if (endClocks) {\n        // view already ended\n        return\n      }\n      endClocks = options.endClocks ?? clocksNow()\n      sessionIsActive = options.sessionIsActive ?? true\n\n      lifeCycle.notify(LifeCycleEventType.VIEW_ENDED, { endClocks })\n      lifeCycle.notify(LifeCycleEventType.AFTER_VIEW_ENDED, { endClocks })\n      clearInterval(keepAliveIntervalId)\n      setViewEnd(endClocks.relative)\n      stopCommonViewMetricsTracking()\n      triggerViewUpdate()\n      setTimeout(() => {\n        this.stop()\n      }, KEEP_TRACKING_AFTER_VIEW_DELAY)\n    },\n    stop() {\n      stopInitialViewMetricsTracking()\n      stopEventCountsTracking()\n      stopINPTracking()\n      stopObservable.notify()\n    },\n    addTiming(name: string, time: RelativeTime | TimeStamp) {\n      if (endClocks) {\n        return\n      }\n      const relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time)\n      customTimings[sanitizeTiming(name)] = relativeTime\n      scheduleViewUpdate()\n    },\n    setViewName(updatedName: string) {\n      name = updatedName\n      triggerViewUpdate()\n    },\n  }\n}\n\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name: string) {\n  const sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_')\n  if (sanitized !== name) {\n    display.warn(`Invalid timing name: ${name}, sanitized to: ${sanitized}`)\n  }\n  return sanitized\n}\n\nfunction areDifferentLocation(currentLocation: Location, otherLocation: Location) {\n  return (\n    currentLocation.pathname !== otherLocation.pathname ||\n    (!isHashAnAnchor(otherLocation.hash) &&\n      getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash))\n  )\n}\n\nfunction isHashAnAnchor(hash: string) {\n  const correspondingId = hash.substring(1)\n  // check if the correspondingId is empty because on Firefox an empty string passed to getElementById() prints a consol warning\n  return correspondingId !== '' && !!document.getElementById(correspondingId)\n}\n\nfunction getPathFromHash(hash: string) {\n  const index = hash.indexOf('?')\n  return index < 0 ? hash : hash.slice(0, index)\n}\n","import type { Duration, ServerDuration, Observable } from '@datadog/browser-core'\nimport { isEmptyObject, mapValues, toServerDuration } from '@datadog/browser-core'\nimport { discardNegativeDuration } from '../discardNegativeDuration'\nimport type { RecorderApi } from '../../boot/rumPublicApi'\nimport type { RawRumViewEvent, ViewPerformanceData } from '../../rawRumEvent.types'\nimport { RumEventType } from '../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { LocationChange } from '../../browser/locationChangeObservable'\nimport type { RumConfiguration } from '../configuration'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport type { ViewEvent, ViewOptions } from './trackViews'\nimport { trackViews } from './trackViews'\nimport type { CommonViewMetrics } from './viewMetrics/trackCommonViewMetrics'\nimport type { InitialViewMetrics } from './viewMetrics/trackInitialViewMetrics'\n\nexport function startViewCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  location: Location,\n  domMutationObservable: Observable<void>,\n  pageOpenObserable: Observable<void>,\n  locationChangeObservable: Observable<LocationChange>,\n  pageStateHistory: PageStateHistory,\n  recorderApi: RecorderApi,\n  initialViewOptions?: ViewOptions\n) {\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_UPDATED, (view) =>\n    lifeCycle.notify(\n      LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n      processViewUpdate(view, configuration, recorderApi, pageStateHistory)\n    )\n  )\n  return trackViews(\n    location,\n    lifeCycle,\n    domMutationObservable,\n    pageOpenObserable,\n    configuration,\n    locationChangeObservable,\n    !configuration.trackViewsManually,\n    initialViewOptions\n  )\n}\n\nfunction processViewUpdate(\n  view: ViewEvent,\n  configuration: RumConfiguration,\n  recorderApi: RecorderApi,\n  pageStateHistory: PageStateHistory\n): RawRumEventCollectedData<RawRumViewEvent> {\n  const replayStats = recorderApi.getReplayStats(view.id)\n  const pageStates = pageStateHistory.findAll(view.startClocks.relative, view.duration)\n  const viewEvent: RawRumViewEvent = {\n    _dd: {\n      document_version: view.documentVersion,\n      replay_stats: replayStats,\n      page_states: pageStates,\n      configuration: {\n        start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,\n      },\n    },\n    date: view.startClocks.timeStamp,\n    type: RumEventType.VIEW,\n    view: {\n      action: {\n        count: view.eventCounts.actionCount,\n      },\n      frustration: {\n        count: view.eventCounts.frustrationCount,\n      },\n      cumulative_layout_shift: view.commonViewMetrics.cumulativeLayoutShift?.value,\n      cumulative_layout_shift_time: toServerDuration(view.commonViewMetrics.cumulativeLayoutShift?.time),\n      cumulative_layout_shift_target_selector: view.commonViewMetrics.cumulativeLayoutShift?.targetSelector,\n      first_byte: toServerDuration(view.initialViewMetrics.navigationTimings?.firstByte),\n      dom_complete: toServerDuration(view.initialViewMetrics.navigationTimings?.domComplete),\n      dom_content_loaded: toServerDuration(view.initialViewMetrics.navigationTimings?.domContentLoaded),\n      dom_interactive: toServerDuration(view.initialViewMetrics.navigationTimings?.domInteractive),\n      error: {\n        count: view.eventCounts.errorCount,\n      },\n      first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),\n      first_input_delay: toServerDuration(view.initialViewMetrics.firstInput?.delay),\n      first_input_time: toServerDuration(view.initialViewMetrics.firstInput?.time),\n      first_input_target_selector: view.initialViewMetrics.firstInput?.targetSelector,\n      interaction_to_next_paint: toServerDuration(view.commonViewMetrics.interactionToNextPaint?.value),\n      interaction_to_next_paint_time: toServerDuration(view.commonViewMetrics.interactionToNextPaint?.time),\n      interaction_to_next_paint_target_selector: view.commonViewMetrics.interactionToNextPaint?.targetSelector,\n      is_active: view.isActive,\n      name: view.name,\n      largest_contentful_paint: toServerDuration(view.initialViewMetrics.largestContentfulPaint?.value),\n      largest_contentful_paint_target_selector: view.initialViewMetrics.largestContentfulPaint?.targetSelector,\n      load_event: toServerDuration(view.initialViewMetrics.navigationTimings?.loadEvent),\n      loading_time: discardNegativeDuration(toServerDuration(view.commonViewMetrics.loadingTime)),\n      loading_type: view.loadingType,\n      long_task: {\n        count: view.eventCounts.longTaskCount,\n      },\n      performance: computeViewPerformanceData(view.commonViewMetrics, view.initialViewMetrics),\n      resource: {\n        count: view.eventCounts.resourceCount,\n      },\n      time_spent: toServerDuration(view.duration),\n    },\n    display: view.commonViewMetrics.scroll\n      ? {\n          scroll: {\n            max_depth: view.commonViewMetrics.scroll.maxDepth,\n            max_depth_scroll_top: view.commonViewMetrics.scroll.maxDepthScrollTop,\n            max_scroll_height: view.commonViewMetrics.scroll.maxScrollHeight,\n            max_scroll_height_time: toServerDuration(view.commonViewMetrics.scroll.maxScrollHeightTime),\n          },\n        }\n      : undefined,\n    session: {\n      has_replay: replayStats ? true : undefined,\n      is_active: view.sessionIsActive ? undefined : false,\n    },\n    privacy: {\n      replay_level: configuration.defaultPrivacyLevel,\n    },\n  }\n  if (!isEmptyObject(view.customTimings)) {\n    viewEvent.view.custom_timings = mapValues(\n      view.customTimings,\n      toServerDuration as (duration: Duration) => ServerDuration\n    )\n  }\n\n  return {\n    rawRumEvent: viewEvent,\n    startTime: view.startClocks.relative,\n    domainContext: {\n      location: view.location,\n    },\n  }\n}\n\nfunction computeViewPerformanceData(\n  { cumulativeLayoutShift, interactionToNextPaint }: CommonViewMetrics,\n  { firstContentfulPaint, firstInput, largestContentfulPaint }: InitialViewMetrics\n): ViewPerformanceData {\n  return {\n    cls: cumulativeLayoutShift && {\n      score: cumulativeLayoutShift.value,\n      timestamp: toServerDuration(cumulativeLayoutShift.time),\n      target_selector: cumulativeLayoutShift.targetSelector,\n      previous_rect: cumulativeLayoutShift.previousRect,\n      current_rect: cumulativeLayoutShift.currentRect,\n    },\n    fcp: firstContentfulPaint && { timestamp: toServerDuration(firstContentfulPaint) },\n    fid: firstInput && {\n      duration: toServerDuration(firstInput.delay),\n      timestamp: toServerDuration(firstInput.time),\n      target_selector: firstInput.targetSelector,\n    },\n    inp: interactionToNextPaint && {\n      duration: toServerDuration(interactionToNextPaint.value),\n      timestamp: toServerDuration(interactionToNextPaint.time),\n      target_selector: interactionToNextPaint.targetSelector,\n    },\n    lcp: largestContentfulPaint && {\n      timestamp: toServerDuration(largestContentfulPaint.value),\n      target_selector: largestContentfulPaint.targetSelector,\n    },\n  }\n}\n","import type { LifeCycle } from '../lifeCycle'\nimport { trackEventCounts } from '../trackEventCounts'\n\nexport function trackViewEventCounts(lifeCycle: LifeCycle, viewId: string, onChange: () => void) {\n  const { stop, eventCounts } = trackEventCounts({\n    lifeCycle,\n    isChildEvent: (event) => event.view.id === viewId,\n    onChange,\n  })\n\n  return {\n    stop,\n    eventCounts,\n  }\n}\n","import { Observable } from '../../tools/observable'\nimport type { Context } from '../../tools/serialisation/context'\nimport { createValueHistory } from '../../tools/valueHistory'\nimport type { RelativeTime } from '../../tools/utils/timeUtils'\nimport { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils'\nimport { DOM_EVENT, addEventListener, addEventListeners } from '../../browser/addEventListener'\nimport { clearInterval, setInterval } from '../../tools/timer'\nimport type { Configuration } from '../configuration'\nimport type { TrackingConsentState } from '../trackingConsent'\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants'\nimport { startSessionStore } from './sessionStore'\nimport type { SessionState } from './sessionState'\n\nexport interface SessionManager<TrackingType extends string> {\n  findSession: (\n    startTime?: RelativeTime,\n    options?: { returnInactive: boolean }\n  ) => SessionContext<TrackingType> | undefined\n  renewObservable: Observable<void>\n  expireObservable: Observable<void>\n  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>\n  expire: () => void\n  updateSessionState: (state: Partial<SessionState>) => void\n}\n\nexport interface SessionContext<TrackingType extends string> extends Context {\n  id: string\n  trackingType: TrackingType\n  isReplayForced: boolean\n  anonymousId: string | undefined\n}\n\nexport const VISIBILITY_CHECK_DELAY = ONE_MINUTE\nconst SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY\nlet stopCallbacks: Array<() => void> = []\n\nexport function startSessionManager<TrackingType extends string>(\n  configuration: Configuration,\n  productKey: string,\n  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean },\n  trackingConsentState: TrackingConsentState\n): SessionManager<TrackingType> {\n  const renewObservable = new Observable<void>()\n  const expireObservable = new Observable<void>()\n\n  // TODO - Improve configuration type and remove assertion\n  const sessionStore = startSessionStore(\n    configuration.sessionStoreStrategyType!,\n    configuration,\n    productKey,\n    computeSessionState\n  )\n  stopCallbacks.push(() => sessionStore.stop())\n\n  const sessionContextHistory = createValueHistory<SessionContext<TrackingType>>({\n    expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,\n  })\n  stopCallbacks.push(() => sessionContextHistory.stop())\n\n  sessionStore.renewObservable.subscribe(() => {\n    sessionContextHistory.add(buildSessionContext(), relativeNow())\n    renewObservable.notify()\n  })\n  sessionStore.expireObservable.subscribe(() => {\n    expireObservable.notify()\n    sessionContextHistory.closeActive(relativeNow())\n  })\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\n  trackingConsentState.observable.subscribe(() => {\n    if (trackingConsentState.isGranted()) {\n      sessionStore.expandOrRenewSession()\n    } else {\n      sessionStore.expire()\n    }\n  })\n\n  trackActivity(configuration, () => {\n    if (trackingConsentState.isGranted()) {\n      sessionStore.expandOrRenewSession()\n    }\n  })\n  trackVisibility(configuration, () => sessionStore.expandSession())\n  trackResume(configuration, () => sessionStore.restartSession())\n\n  function buildSessionContext() {\n    return {\n      id: sessionStore.getSession().id!,\n      trackingType: sessionStore.getSession()[productKey] as TrackingType,\n      isReplayForced: !!sessionStore.getSession().forcedReplay,\n      anonymousId: sessionStore.getSession().anonymousId,\n    }\n  }\n\n  return {\n    findSession: (startTime, options) => sessionContextHistory.find(startTime, options),\n    renewObservable,\n    expireObservable,\n    sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,\n    expire: sessionStore.expire,\n    updateSessionState: sessionStore.updateSessionState,\n  }\n}\n\nexport function stopSessionManager() {\n  stopCallbacks.forEach((e) => e())\n  stopCallbacks = []\n}\n\nfunction trackActivity(configuration: Configuration, expandOrRenewSession: () => void) {\n  const { stop } = addEventListeners(\n    configuration,\n    window,\n    [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],\n    expandOrRenewSession,\n    { capture: true, passive: true }\n  )\n  stopCallbacks.push(stop)\n}\n\nfunction trackVisibility(configuration: Configuration, expandSession: () => void) {\n  const expandSessionWhenVisible = () => {\n    if (document.visibilityState === 'visible') {\n      expandSession()\n    }\n  }\n\n  const { stop } = addEventListener(configuration, document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)\n  stopCallbacks.push(stop)\n\n  const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)\n  stopCallbacks.push(() => {\n    clearInterval(visibilityCheckInterval)\n  })\n}\n\nfunction trackResume(configuration: Configuration, cb: () => void) {\n  const { stop } = addEventListener(configuration, window, DOM_EVENT.RESUME, cb, { capture: true })\n  stopCallbacks.push(stop)\n}\n","import type { RelativeTime, TrackingConsentState } from '@datadog/browser-core'\nimport {\n  BridgeCapability,\n  Observable,\n  bridgeSupports,\n  noop,\n  performDraw,\n  startSessionManager,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\n\nexport const RUM_SESSION_KEY = 'rum'\n\nexport interface RumSessionManager {\n  findTrackedSession: (startTime?: RelativeTime) => RumSession | undefined\n  expire: () => void\n  expireObservable: Observable<void>\n  setForcedReplay: () => void\n}\n\nexport type RumSession = {\n  id: string\n  sessionReplay: SessionReplayState\n  anonymousId?: string\n}\n\nexport const enum RumTrackingType {\n  NOT_TRACKED = '0',\n  TRACKED_WITH_SESSION_REPLAY = '1',\n  TRACKED_WITHOUT_SESSION_REPLAY = '2',\n}\n\nexport const enum SessionReplayState {\n  OFF,\n  SAMPLED,\n  FORCED,\n}\n\nexport function startRumSessionManager(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  trackingConsentState: TrackingConsentState\n): RumSessionManager {\n  const sessionManager = startSessionManager(\n    configuration,\n    RUM_SESSION_KEY,\n    (rawTrackingType) => computeSessionState(configuration, rawTrackingType),\n    trackingConsentState\n  )\n\n  sessionManager.expireObservable.subscribe(() => {\n    lifeCycle.notify(LifeCycleEventType.SESSION_EXPIRED)\n  })\n\n  sessionManager.renewObservable.subscribe(() => {\n    lifeCycle.notify(LifeCycleEventType.SESSION_RENEWED)\n  })\n\n  sessionManager.sessionStateUpdateObservable.subscribe(({ previousState, newState }) => {\n    if (!previousState.forcedReplay && newState.forcedReplay) {\n      const sessionEntity = sessionManager.findSession()\n      if (sessionEntity) {\n        sessionEntity.isReplayForced = true\n      }\n    }\n  })\n  return {\n    findTrackedSession: (startTime) => {\n      const session = sessionManager.findSession(startTime)\n      if (!session || !isTypeTracked(session.trackingType)) {\n        return\n      }\n      return {\n        id: session.id,\n        sessionReplay:\n          session.trackingType === RumTrackingType.TRACKED_WITH_SESSION_REPLAY\n            ? SessionReplayState.SAMPLED\n            : session.isReplayForced\n              ? SessionReplayState.FORCED\n              : SessionReplayState.OFF,\n        anonymousId: session.anonymousId,\n      }\n    },\n    expire: sessionManager.expire,\n    expireObservable: sessionManager.expireObservable,\n    setForcedReplay: () => sessionManager.updateSessionState({ forcedReplay: '1' }),\n  }\n}\n\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub(): RumSessionManager {\n  const session: RumSession = {\n    id: '00000000-aaaa-0000-aaaa-000000000000',\n    sessionReplay: bridgeSupports(BridgeCapability.RECORDS) ? SessionReplayState.SAMPLED : SessionReplayState.OFF,\n  }\n  return {\n    findTrackedSession: () => session,\n    expire: noop,\n    expireObservable: new Observable(),\n    setForcedReplay: noop,\n  }\n}\n\nfunction computeSessionState(configuration: RumConfiguration, rawTrackingType?: string) {\n  let trackingType: RumTrackingType\n  if (hasValidRumSession(rawTrackingType)) {\n    trackingType = rawTrackingType\n  } else if (!performDraw(configuration.sessionSampleRate)) {\n    trackingType = RumTrackingType.NOT_TRACKED\n  } else if (!performDraw(configuration.sessionReplaySampleRate)) {\n    trackingType = RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY\n  } else {\n    trackingType = RumTrackingType.TRACKED_WITH_SESSION_REPLAY\n  }\n  return {\n    trackingType,\n    isTracked: isTypeTracked(trackingType),\n  }\n}\n\nfunction hasValidRumSession(trackingType?: string): trackingType is RumTrackingType {\n  return (\n    trackingType === RumTrackingType.NOT_TRACKED ||\n    trackingType === RumTrackingType.TRACKED_WITH_SESSION_REPLAY ||\n    trackingType === RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY\n  )\n}\n\nfunction isTypeTracked(rumSessionType: RumTrackingType | undefined) {\n  return (\n    rumSessionType === RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY ||\n    rumSessionType === RumTrackingType.TRACKED_WITH_SESSION_REPLAY\n  )\n}\n","import { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../tools/display'\nimport type { Context } from '../tools/serialisation/context'\nimport { objectValues } from '../tools/utils/polyfills'\nimport { isPageExitReason } from '../browser/pageExitObservable'\nimport { jsonStringify } from '../tools/serialisation/jsonStringify'\nimport type { Encoder, EncoderResult } from '../tools/encoder'\nimport { computeBytesCount } from '../tools/utils/byteUtils'\nimport type { HttpRequest, Payload } from './httpRequest'\nimport type { FlushController, FlushEvent } from './flushController'\n\nexport interface Batch {\n  flushController: FlushController\n  add: (message: Context) => void\n  upsert: (message: Context, key: string) => void\n  stop: () => void\n}\n\nexport function createBatch({\n  encoder,\n  request,\n  flushController,\n  messageBytesLimit,\n}: {\n  encoder: Encoder\n  request: HttpRequest\n  flushController: FlushController\n  messageBytesLimit: number\n}): Batch {\n  let upsertBuffer: { [key: string]: string } = {}\n  const flushSubscription = flushController.flushObservable.subscribe((event) => flush(event))\n\n  function push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {\n    flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)\n\n    if (key !== undefined) {\n      upsertBuffer[key] = serializedMessage\n      flushController.notifyAfterAddMessage()\n    } else {\n      encoder.write(encoder.isEmpty ? serializedMessage : `\\n${serializedMessage}`, (realMessageBytesCount) => {\n        flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)\n      })\n    }\n  }\n\n  function hasMessageFor(key?: string): key is string {\n    return key !== undefined && upsertBuffer[key] !== undefined\n  }\n\n  function remove(key: string) {\n    const removedMessage = upsertBuffer[key]\n    delete upsertBuffer[key]\n    const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage)\n    flushController.notifyAfterRemoveMessage(messageBytesCount)\n  }\n\n  function addOrUpdate(message: Context, key?: string) {\n    const serializedMessage = jsonStringify(message)!\n\n    const estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage)\n\n    if (estimatedMessageBytesCount >= messageBytesLimit) {\n      display.warn(\n        `Discarded a message whose size was bigger than the maximum allowed size ${messageBytesLimit}KB. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#technical-limitations`\n      )\n      return\n    }\n\n    if (hasMessageFor(key)) {\n      remove(key)\n    }\n\n    push(serializedMessage, estimatedMessageBytesCount, key)\n  }\n\n  function flush(event: FlushEvent) {\n    const upsertMessages = objectValues(upsertBuffer).join('\\n')\n    upsertBuffer = {}\n\n    const isPageExit = isPageExitReason(event.reason)\n    const send = isPageExit ? request.sendOnExit : request.send\n\n    if (\n      isPageExit &&\n      // Note: checking that the encoder is async is not strictly needed, but it's an optimization:\n      // if the encoder is async we need to send two requests in some cases (one for encoded data\n      // and the other for non-encoded data). But if it's not async, we don't have to worry about\n      // it and always send a single request.\n      encoder.isAsync\n    ) {\n      const encoderResult = encoder.finishSync()\n\n      // Send encoded messages\n      if (encoderResult.outputBytesCount) {\n        send(formatPayloadFromEncoder(encoderResult))\n      }\n\n      // Send messages that are not yet encoded at this point\n      const pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\\n')\n      if (pendingMessages) {\n        send({\n          data: pendingMessages,\n          bytesCount: computeBytesCount(pendingMessages),\n        })\n      }\n    } else {\n      if (upsertMessages) {\n        encoder.write(encoder.isEmpty ? upsertMessages : `\\n${upsertMessages}`)\n      }\n      encoder.finish((encoderResult) => {\n        send(formatPayloadFromEncoder(encoderResult))\n      })\n    }\n  }\n\n  return {\n    flushController,\n    add: addOrUpdate,\n    upsert: addOrUpdate,\n    stop: flushSubscription.unsubscribe,\n  }\n}\n\nfunction formatPayloadFromEncoder(encoderResult: EncoderResult): Payload {\n  let data: string | Blob\n  if (typeof encoderResult.output === 'string') {\n    data = encoderResult.output\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\n  return {\n    data,\n    bytesCount: encoderResult.outputBytesCount,\n    encoding: encoderResult.encoding,\n  }\n}\n","import type { PageExitEvent, PageExitReason } from '../browser/pageExitObservable'\nimport { Observable } from '../tools/observable'\nimport type { TimeoutId } from '../tools/timer'\nimport { clearTimeout, setTimeout } from '../tools/timer'\nimport type { Duration } from '../tools/utils/timeUtils'\n\nexport type FlushReason = PageExitReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'\n\nexport type FlushController = ReturnType<typeof createFlushController>\nexport interface FlushEvent {\n  reason: FlushReason\n  bytesCount: number\n  messagesCount: number\n}\n\ninterface FlushControllerOptions {\n  messagesLimit: number\n  bytesLimit: number\n  durationLimit: Duration\n  pageExitObservable: Observable<PageExitEvent>\n  sessionExpireObservable: Observable<void>\n}\n\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({\n  messagesLimit,\n  bytesLimit,\n  durationLimit,\n  pageExitObservable,\n  sessionExpireObservable,\n}: FlushControllerOptions) {\n  const pageExitSubscription = pageExitObservable.subscribe((event) => flush(event.reason))\n  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))\n\n  const flushObservable = new Observable<FlushEvent>(() => () => {\n    pageExitSubscription.unsubscribe()\n    sessionExpireSubscription.unsubscribe()\n  })\n\n  let currentBytesCount = 0\n  let currentMessagesCount = 0\n\n  function flush(flushReason: FlushReason) {\n    if (currentMessagesCount === 0) {\n      return\n    }\n\n    const messagesCount = currentMessagesCount\n    const bytesCount = currentBytesCount\n\n    currentMessagesCount = 0\n    currentBytesCount = 0\n    cancelDurationLimitTimeout()\n\n    flushObservable.notify({\n      reason: flushReason,\n      messagesCount,\n      bytesCount,\n    })\n  }\n\n  let durationLimitTimeoutId: TimeoutId | undefined\n  function scheduleDurationLimitTimeout() {\n    if (durationLimitTimeoutId === undefined) {\n      durationLimitTimeoutId = setTimeout(() => {\n        flush('duration_limit')\n      }, durationLimit)\n    }\n  }\n\n  function cancelDurationLimitTimeout() {\n    clearTimeout(durationLimitTimeoutId)\n    durationLimitTimeoutId = undefined\n  }\n\n  return {\n    flushObservable,\n    get messagesCount() {\n      return currentMessagesCount\n    },\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(estimatedMessageBytesCount: number) {\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    /**\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(messageBytesCountDiff = 0) {\n      currentBytesCount += messageBytesCountDiff\n\n      if (currentMessagesCount >= messagesLimit) {\n        flush('messages_limit')\n      } else if (currentBytesCount >= bytesLimit) {\n        flush('bytes_limit')\n      }\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(messageBytesCount: number) {\n      currentBytesCount -= messageBytesCount\n      currentMessagesCount -= 1\n      if (currentMessagesCount === 0) {\n        cancelDurationLimitTimeout()\n      }\n    },\n  }\n}\n","import type { Context, TelemetryEvent, Observable, RawError, PageExitEvent, Encoder } from '@datadog/browser-core'\nimport {\n  DeflateEncoderStreamId,\n  combine,\n  isTelemetryReplicationAllowed,\n  startBatchWithReplica,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport { RumEventType } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\n\nexport function startRumBatch(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  telemetryEventObservable: Observable<TelemetryEvent & Context>,\n  reportError: (error: RawError) => void,\n  pageExitObservable: Observable<PageExitEvent>,\n  sessionExpireObservable: Observable<void>,\n  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder\n) {\n  const replica = configuration.replica\n\n  const batch = startBatchWithReplica(\n    configuration,\n    {\n      endpoint: configuration.rumEndpointBuilder,\n      encoder: createEncoder(DeflateEncoderStreamId.RUM),\n    },\n    replica && {\n      endpoint: replica.rumEndpointBuilder,\n      transformMessage: (message) => combine(message, { application: { id: replica.applicationId } }),\n      encoder: createEncoder(DeflateEncoderStreamId.RUM_REPLICA),\n    },\n    reportError,\n    pageExitObservable,\n    sessionExpireObservable\n  )\n\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (serverRumEvent: RumEvent & Context) => {\n    if (serverRumEvent.type === RumEventType.VIEW) {\n      batch.upsert(serverRumEvent, serverRumEvent.view.id)\n    } else {\n      batch.add(serverRumEvent)\n    }\n  })\n\n  telemetryEventObservable.subscribe((event) => batch.add(event, isTelemetryReplicationAllowed(configuration)))\n\n  return batch\n}\n","import type { Configuration, EndpointBuilder } from '../domain/configuration'\nimport type { Context } from '../tools/serialisation/context'\nimport type { Observable } from '../tools/observable'\nimport type { PageExitEvent } from '../browser/pageExitObservable'\nimport type { RawError } from '../domain/error/error.types'\nimport type { Encoder } from '../tools/encoder'\nimport { createBatch } from './batch'\nimport { createHttpRequest } from './httpRequest'\nimport { createFlushController } from './flushController'\n\nexport interface BatchConfiguration {\n  endpoint: EndpointBuilder\n  encoder: Encoder\n}\n\ninterface ReplicaBatchConfiguration<T> extends BatchConfiguration {\n  transformMessage?: (message: T) => T\n}\n\nexport function startBatchWithReplica<T extends Context>(\n  configuration: Configuration,\n  primary: BatchConfiguration,\n  replica: ReplicaBatchConfiguration<T> | undefined,\n  reportError: (error: RawError) => void,\n  pageExitObservable: Observable<PageExitEvent>,\n  sessionExpireObservable: Observable<void>,\n  batchFactoryImp = createBatch\n) {\n  const primaryBatch = createBatchFromConfig(configuration, primary)\n  const replicaBatch = replica && createBatchFromConfig(configuration, replica)\n\n  function createBatchFromConfig(configuration: Configuration, { endpoint, encoder }: BatchConfiguration) {\n    return batchFactoryImp({\n      encoder,\n      request: createHttpRequest(endpoint, configuration.batchBytesLimit, reportError),\n      flushController: createFlushController({\n        messagesLimit: configuration.batchMessagesLimit,\n        bytesLimit: configuration.batchBytesLimit,\n        durationLimit: configuration.flushTimeout,\n        pageExitObservable,\n        sessionExpireObservable,\n      }),\n      messageBytesLimit: configuration.messageBytesLimit,\n    })\n  }\n\n  return {\n    flushObservable: primaryBatch.flushController.flushObservable,\n\n    add(message: T, replicated = true) {\n      primaryBatch.add(message)\n      if (replicaBatch && replicated) {\n        replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message)\n      }\n    },\n\n    upsert: (message: T, key: string) => {\n      primaryBatch.upsert(message, key)\n      if (replicaBatch) {\n        replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key)\n      }\n    },\n\n    stop: () => {\n      primaryBatch.stop()\n      if (replicaBatch) {\n        replicaBatch.stop()\n      }\n    },\n  }\n}\n","import type { RelativeTime, Observable } from '@datadog/browser-core'\nimport { SESSION_TIME_OUT_DELAY, relativeNow, createValueHistory } from '@datadog/browser-core'\nimport type { LocationChange } from '../../browser/locationChangeObservable'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\n\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\n\nexport const URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\n\nexport interface UrlContext {\n  url: string\n  referrer: string\n}\n\nexport interface UrlContexts {\n  findUrl: (startTime?: RelativeTime) => UrlContext | undefined\n  stop: () => void\n}\n\nexport function startUrlContexts(\n  lifeCycle: LifeCycle,\n  locationChangeObservable: Observable<LocationChange>,\n  location: Location\n) {\n  const urlContextHistory = createValueHistory<UrlContext>({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY })\n\n  let previousViewUrl: string | undefined\n\n  lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, ({ startClocks }) => {\n    const viewUrl = location.href\n    urlContextHistory.add(\n      buildUrlContext({\n        url: viewUrl,\n        referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n      }),\n      startClocks.relative\n    )\n    previousViewUrl = viewUrl\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.AFTER_VIEW_ENDED, ({ endClocks }) => {\n    urlContextHistory.closeActive(endClocks.relative)\n  })\n\n  const locationChangeSubscription = locationChangeObservable.subscribe(({ newLocation }) => {\n    const current = urlContextHistory.find()\n    if (current) {\n      const changeTime = relativeNow()\n      urlContextHistory.closeActive(changeTime)\n      urlContextHistory.add(\n        buildUrlContext({\n          url: newLocation.href,\n          referrer: current.referrer,\n        }),\n        changeTime\n      )\n    }\n  })\n\n  function buildUrlContext({ url, referrer }: { url: string; referrer: string }) {\n    return {\n      url,\n      referrer,\n    }\n  }\n\n  return {\n    findUrl: (startTime?: RelativeTime) => urlContextHistory.find(startTime),\n    stop: () => {\n      locationChangeSubscription.unsubscribe()\n      urlContextHistory.stop()\n    },\n  }\n}\n","import { addEventListener, DOM_EVENT, instrumentMethod, Observable, shallowClone } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../domain/configuration'\n\nexport interface LocationChange {\n  oldLocation: Readonly<Location>\n  newLocation: Readonly<Location>\n}\n\nexport function createLocationChangeObservable(configuration: RumConfiguration, location: Location) {\n  let currentLocation = shallowClone(location)\n\n  return new Observable<LocationChange>((observable) => {\n    const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange)\n    const { stop: stopHashTracking } = trackHash(configuration, onLocationChange)\n\n    function onLocationChange() {\n      if (currentLocation.href === location.href) {\n        return\n      }\n      const newLocation = shallowClone(location)\n      observable.notify({\n        newLocation,\n        oldLocation: currentLocation,\n      })\n      currentLocation = newLocation\n    }\n\n    return () => {\n      stopHistoryTracking()\n      stopHashTracking()\n    }\n  })\n}\n\nfunction trackHistory(configuration: RumConfiguration, onHistoryChange: () => void) {\n  const { stop: stopInstrumentingPushState } = instrumentMethod(\n    getHistoryInstrumentationTarget('pushState'),\n    'pushState',\n    ({ onPostCall }) => {\n      onPostCall(onHistoryChange)\n    }\n  )\n  const { stop: stopInstrumentingReplaceState } = instrumentMethod(\n    getHistoryInstrumentationTarget('replaceState'),\n    'replaceState',\n    ({ onPostCall }) => {\n      onPostCall(onHistoryChange)\n    }\n  )\n  const { stop: removeListener } = addEventListener(configuration, window, DOM_EVENT.POP_STATE, onHistoryChange)\n\n  return {\n    stop: () => {\n      stopInstrumentingPushState()\n      stopInstrumentingReplaceState()\n      removeListener()\n    },\n  }\n}\n\nfunction trackHash(configuration: RumConfiguration, onHashChange: () => void) {\n  return addEventListener(configuration, window, DOM_EVENT.HASH_CHANGE, onHashChange)\n}\n\nfunction getHistoryInstrumentationTarget(methodName: 'pushState' | 'replaceState') {\n  // Ideally we should always instument the method on the prototype, however some frameworks (e.g [Next.js](https://github.com/vercel/next.js/blob/d3f5532065f3e3bb84fb54bd2dfd1a16d0f03a21/packages/next/src/client/components/app-router.tsx#L429))\n  // are wrapping the instance method. In that case we should also wrap the instance method.\n  return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype\n}\n","import type { RelativeTime, ContextValue, Context, CustomerDataTracker } from '@datadog/browser-core'\nimport { SESSION_TIME_OUT_DELAY, createValueHistory } from '@datadog/browser-core'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\n\nexport const FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\nexport const BYTES_COMPUTATION_THROTTLING_DELAY = 200\n\nexport type FeatureFlagContext = Context\n\nexport interface FeatureFlagContexts {\n  findFeatureFlagEvaluations: (startTime?: RelativeTime) => FeatureFlagContext | undefined\n  addFeatureFlagEvaluation: (key: string, value: ContextValue) => void\n  stop: () => void\n}\n\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(\n  lifeCycle: LifeCycle,\n  customerDataTracker: CustomerDataTracker\n): FeatureFlagContexts {\n  const featureFlagContexts = createValueHistory<FeatureFlagContext>({\n    expireDelay: FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY,\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, ({ startClocks }) => {\n    featureFlagContexts.add({}, startClocks.relative)\n    customerDataTracker.resetCustomerData()\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.AFTER_VIEW_ENDED, ({ endClocks }) => {\n    featureFlagContexts.closeActive(endClocks.relative)\n  })\n\n  return {\n    findFeatureFlagEvaluations: (startTime?: RelativeTime) => featureFlagContexts.find(startTime),\n    addFeatureFlagEvaluation: (key: string, value: ContextValue) => {\n      const currentContext = featureFlagContexts.find()\n      if (currentContext) {\n        currentContext[key] = value\n        customerDataTracker.updateCustomerData(currentContext)\n      }\n    },\n    stop: () => customerDataTracker.stop(),\n  }\n}\n","import type { Context, CustomerDataTrackerManager, FlushEvent, Observable, Telemetry } from '@datadog/browser-core'\nimport { performDraw, ONE_SECOND, addTelemetryDebug, setInterval, CustomerDataType } from '@datadog/browser-core'\nimport { RumEventType } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\nimport type { RumConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\n\nexport const MEASURES_PERIOD_DURATION = 10 * ONE_SECOND\n\ntype Measure = {\n  min: number\n  max: number\n  sum: number\n}\n\ntype CurrentPeriodMeasures = {\n  batchCount: number\n  batchBytesCount: Measure\n  batchMessagesCount: Measure\n  globalContextBytes: Measure\n  userContextBytes: Measure\n  featureFlagBytes: Measure\n}\n\ntype CurrentBatchMeasures = {\n  globalContextBytes: Measure\n  userContextBytes: Measure\n  featureFlagBytes: Measure\n}\n\nlet currentPeriodMeasures: CurrentPeriodMeasures\nlet currentBatchMeasures: CurrentBatchMeasures\nlet batchHasRumEvent: boolean\n\nexport function startCustomerDataTelemetry(\n  configuration: RumConfiguration,\n  telemetry: Telemetry,\n  lifeCycle: LifeCycle,\n  customerDataTrackerManager: CustomerDataTrackerManager,\n  batchFlushObservable: Observable<FlushEvent>\n) {\n  const customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate)\n  if (!customerDataTelemetryEnabled) {\n    return\n  }\n\n  initCurrentPeriodMeasures()\n  initCurrentBatchMeasures()\n\n  // We measure the data of every view updates even if there could only be one per batch due to the upsert\n  // It means that contexts bytes count sums can be higher than it really is\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event: RumEvent & Context) => {\n    batchHasRumEvent = true\n    updateMeasure(\n      currentBatchMeasures.globalContextBytes,\n      customerDataTrackerManager.getOrCreateTracker(CustomerDataType.GlobalContext).getBytesCount()\n    )\n\n    updateMeasure(\n      currentBatchMeasures.userContextBytes,\n      customerDataTrackerManager.getOrCreateTracker(CustomerDataType.User).getBytesCount()\n    )\n\n    updateMeasure(\n      currentBatchMeasures.featureFlagBytes,\n      [RumEventType.VIEW, RumEventType.ERROR].includes(event.type as RumEventType)\n        ? customerDataTrackerManager.getOrCreateTracker(CustomerDataType.FeatureFlag).getBytesCount()\n        : 0\n    )\n  })\n\n  batchFlushObservable.subscribe(({ bytesCount, messagesCount }) => {\n    // Don't measure batch that only contains telemetry events to avoid batch sending loop\n    // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n    if (!batchHasRumEvent) {\n      return\n    }\n    currentPeriodMeasures.batchCount += 1\n    updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount)\n    updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount)\n    mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes)\n    mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes)\n    mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes)\n    initCurrentBatchMeasures()\n  })\n\n  setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION)\n}\n\nfunction sendCurrentPeriodMeasures() {\n  if (currentPeriodMeasures.batchCount === 0) {\n    return\n  }\n\n  addTelemetryDebug('Customer data measures', currentPeriodMeasures)\n  initCurrentPeriodMeasures()\n}\n\nfunction createMeasure(): Measure {\n  return { min: Infinity, max: 0, sum: 0 }\n}\n\nfunction updateMeasure(measure: Measure, value: number) {\n  measure.sum += value\n  measure.min = Math.min(measure.min, value)\n  measure.max = Math.max(measure.max, value)\n}\n\nfunction mergeMeasure(target: Measure, source: Measure) {\n  target.sum += source.sum\n  target.min = Math.min(target.min, source.min)\n  target.max = Math.max(target.max, source.max)\n}\n\nfunction initCurrentPeriodMeasures() {\n  currentPeriodMeasures = {\n    batchCount: 0,\n    batchBytesCount: createMeasure(),\n    batchMessagesCount: createMeasure(),\n    globalContextBytes: createMeasure(),\n    userContextBytes: createMeasure(),\n    featureFlagBytes: createMeasure(),\n  }\n}\n\nfunction initCurrentBatchMeasures() {\n  batchHasRumEvent = false\n  currentBatchMeasures = {\n    globalContextBytes: createMeasure(),\n    userContextBytes: createMeasure(),\n    featureFlagBytes: createMeasure(),\n  }\n}\n","import type { Duration, RelativeTime } from '@datadog/browser-core'\nimport {\n  elapsed,\n  createValueHistory,\n  SESSION_TIME_OUT_DELAY,\n  toServerDuration,\n  addEventListeners,\n  relativeNow,\n  DOM_EVENT,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport type { PageStateServerEntry } from '../../rawRumEvent.types'\n\n// Arbitrary value to cap number of element for memory consumption in the browser\nexport const MAX_PAGE_STATE_ENTRIES = 4000\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport const MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500\n\nexport const PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\n\nexport const enum PageState {\n  ACTIVE = 'active',\n  PASSIVE = 'passive',\n  HIDDEN = 'hidden',\n  FROZEN = 'frozen',\n  TERMINATED = 'terminated',\n}\n\nexport type PageStateEntry = { state: PageState; startTime: RelativeTime }\n\nexport interface PageStateHistory {\n  findAll: (startTime: RelativeTime, duration: Duration) => PageStateServerEntry[] | undefined\n  wasInPageStateAt: (state: PageState, startTime: RelativeTime) => boolean\n  wasInPageStateDuringPeriod: (state: PageState, startTime: RelativeTime, duration: Duration) => boolean\n  addPageState(nextPageState: PageState, startTime?: RelativeTime): void\n  stop: () => void\n}\n\nexport function startPageStateHistory(\n  configuration: RumConfiguration,\n  maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE\n): PageStateHistory {\n  const pageStateEntryHistory = createValueHistory<PageStateEntry>({\n    expireDelay: PAGE_STATE_CONTEXT_TIME_OUT_DELAY,\n    maxEntries: MAX_PAGE_STATE_ENTRIES,\n  })\n\n  let currentPageState: PageState\n  addPageState(getPageState(), relativeNow())\n\n  const { stop: stopEventListeners } = addEventListeners(\n    configuration,\n    window,\n    [\n      DOM_EVENT.PAGE_SHOW,\n      DOM_EVENT.FOCUS,\n      DOM_EVENT.BLUR,\n      DOM_EVENT.VISIBILITY_CHANGE,\n      DOM_EVENT.RESUME,\n      DOM_EVENT.FREEZE,\n      DOM_EVENT.PAGE_HIDE,\n    ],\n    (event) => {\n      addPageState(computePageState(event), event.timeStamp as RelativeTime)\n    },\n    { capture: true }\n  )\n\n  function addPageState(nextPageState: PageState, startTime = relativeNow()) {\n    if (nextPageState === currentPageState) {\n      return\n    }\n\n    currentPageState = nextPageState\n    pageStateEntryHistory.closeActive(startTime)\n    pageStateEntryHistory.add({ state: currentPageState, startTime }, startTime)\n  }\n\n  const pageStateHistory = {\n    findAll: (eventStartTime: RelativeTime, duration: Duration): PageStateServerEntry[] | undefined => {\n      const pageStateEntries = pageStateEntryHistory.findAll(eventStartTime, duration)\n\n      if (pageStateEntries.length === 0) {\n        return\n      }\n\n      const pageStateServerEntries = []\n      // limit the number of entries to return\n      const limit = Math.max(0, pageStateEntries.length - maxPageStateEntriesSelectable)\n\n      // loop page state entries backward to return the selected ones in desc order\n      for (let index = pageStateEntries.length - 1; index >= limit; index--) {\n        const pageState = pageStateEntries[index]\n        // compute the start time relative to the event start time (ex: to be relative to the view start time)\n        const relativeStartTime = elapsed(eventStartTime, pageState.startTime)\n\n        pageStateServerEntries.push({\n          state: pageState.state,\n          start: toServerDuration(relativeStartTime),\n        })\n      }\n\n      return pageStateServerEntries\n    },\n    wasInPageStateAt: (state: PageState, startTime: RelativeTime) =>\n      pageStateHistory.wasInPageStateDuringPeriod(state, startTime, 0 as Duration),\n    wasInPageStateDuringPeriod: (state: PageState, startTime: RelativeTime, duration: Duration) =>\n      pageStateEntryHistory.findAll(startTime, duration).some((pageState) => pageState.state === state),\n    addPageState,\n    stop: () => {\n      stopEventListeners()\n      pageStateEntryHistory.stop()\n    },\n  }\n  return pageStateHistory\n}\n\nfunction computePageState(event: Event & { type: DOM_EVENT }) {\n  if (event.type === DOM_EVENT.FREEZE) {\n    return PageState.FROZEN\n  } else if (event.type === DOM_EVENT.PAGE_HIDE) {\n    return (event as PageTransitionEvent).persisted ? PageState.FROZEN : PageState.TERMINATED\n  }\n  return getPageState()\n}\n\nfunction getPageState() {\n  if (document.visibilityState === 'hidden') {\n    return PageState.HIDDEN\n  }\n\n  if (document.hasFocus()) {\n    return PageState.ACTIVE\n  }\n\n  return PageState.PASSIVE\n}\n","import type { Configuration, CookieStore } from '@datadog/browser-core'\nimport {\n  setInterval,\n  clearInterval,\n  Observable,\n  addEventListener,\n  ONE_SECOND,\n  findCommaSeparatedValue,\n  DOM_EVENT,\n} from '@datadog/browser-core'\n\nexport interface CookieStoreWindow extends Window {\n  cookieStore?: CookieStore\n}\n\nexport type CookieObservable = ReturnType<typeof createCookieObservable>\n\nexport function createCookieObservable(configuration: Configuration, cookieName: string) {\n  const detectCookieChangeStrategy = (window as CookieStoreWindow).cookieStore\n    ? listenToCookieStoreChange(configuration)\n    : watchCookieFallback\n\n  return new Observable<string | undefined>((observable) =>\n    detectCookieChangeStrategy(cookieName, (event) => observable.notify(event))\n  )\n}\n\nfunction listenToCookieStoreChange(configuration: Configuration) {\n  return (cookieName: string, callback: (event: string | undefined) => void) => {\n    const listener = addEventListener(\n      configuration,\n      (window as CookieStoreWindow).cookieStore!,\n      DOM_EVENT.CHANGE,\n      (event) => {\n        // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.\n        // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226\n        const changeEvent =\n          event.changed.find((event) => event.name === cookieName) ||\n          event.deleted.find((event) => event.name === cookieName)\n        if (changeEvent) {\n          callback(changeEvent.value)\n        }\n      }\n    )\n    return listener.stop\n  }\n}\n\nexport const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND\n\nfunction watchCookieFallback(cookieName: string, callback: (event: string | undefined) => void) {\n  const previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName)\n  const watchCookieIntervalId = setInterval(() => {\n    const cookieValue = findCommaSeparatedValue(document.cookie, cookieName)\n    if (cookieValue !== previousCookieValue) {\n      callback(cookieValue)\n    }\n  }, WATCH_COOKIE_INTERVAL_DELAY)\n\n  return () => {\n    clearInterval(watchCookieIntervalId)\n  }\n}\n","import { getInitCookie, type Configuration } from '@datadog/browser-core'\n\nimport { createCookieObservable } from '../../browser/cookieObservable'\n\nexport const CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'\n\nexport interface CiTestWindow extends Window {\n  Cypress?: {\n    env: (key: string) => string | undefined\n  }\n}\n\nexport type CiVisibilityContext = ReturnType<typeof startCiVisibilityContext>\n\nexport function startCiVisibilityContext(\n  configuration: Configuration,\n  cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME)\n) {\n  let testExecutionId =\n    getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || (window as CiTestWindow).Cypress?.env('traceId')\n\n  const cookieObservableSubscription = cookieObservable.subscribe((value) => {\n    testExecutionId = value\n  })\n\n  return {\n    get: () => {\n      if (typeof testExecutionId === 'string') {\n        return {\n          test_execution_id: testExecutionId,\n        }\n      }\n    },\n    stop: () => cookieObservableSubscription.unsubscribe(),\n  }\n}\n","import type {\n  Observable,\n  TelemetryEvent,\n  RawError,\n  DeflateEncoderStreamId,\n  Encoder,\n  CustomerDataTrackerManager,\n  TrackingConsentState,\n} from '@datadog/browser-core'\nimport {\n  sendToExtension,\n  createPageExitObservable,\n  TelemetryService,\n  startTelemetry,\n  canUseEventBridge,\n  getEventBridge,\n  addTelemetryDebug,\n  CustomerDataType,\n  drainPreStartTelemetry,\n} from '@datadog/browser-core'\nimport { createDOMMutationObservable } from '../browser/domMutationObservable'\nimport { createWindowOpenObservable } from '../browser/windowOpenObservable'\nimport { startRumAssembly } from '../domain/assembly'\nimport { startInternalContext } from '../domain/contexts/internalContext'\nimport { LifeCycle, LifeCycleEventType } from '../domain/lifeCycle'\nimport { startViewHistory } from '../domain/contexts/viewHistory'\nimport { startRequestCollection } from '../domain/requestCollection'\nimport { startActionCollection } from '../domain/action/actionCollection'\nimport { startErrorCollection } from '../domain/error/errorCollection'\nimport { startResourceCollection } from '../domain/resource/resourceCollection'\nimport { startViewCollection } from '../domain/view/viewCollection'\nimport type { RumSessionManager } from '../domain/rumSessionManager'\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager'\nimport { startRumBatch } from '../transport/startRumBatch'\nimport { startRumEventBridge } from '../transport/startRumEventBridge'\nimport { startUrlContexts } from '../domain/contexts/urlContexts'\nimport type { LocationChange } from '../browser/locationChangeObservable'\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable'\nimport type { RumConfiguration } from '../domain/configuration'\nimport type { ViewOptions } from '../domain/view/trackViews'\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext'\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry'\nimport type { PageStateHistory } from '../domain/contexts/pageStateHistory'\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory'\nimport type { FeatureFlagContexts } from '../domain/contexts/featureFlagContext'\nimport type { CommonContext } from '../domain/contexts/commonContext'\nimport { startDisplayContext } from '../domain/contexts/displayContext'\nimport type { CustomVitalsState } from '../domain/vital/vitalCollection'\nimport { startVitalCollection } from '../domain/vital/vitalCollection'\nimport { startCiVisibilityContext } from '../domain/contexts/ciVisibilityContext'\nimport { startLongAnimationFrameCollection } from '../domain/longAnimationFrame/longAnimationFrameCollection'\nimport { RumPerformanceEntryType } from '../browser/performanceObservable'\nimport { startLongTaskCollection } from '../domain/longTask/longTaskCollection'\nimport type { RecorderApi } from './rumPublicApi'\n\nexport type StartRum = typeof startRum\nexport type StartRumResult = ReturnType<StartRum>\n\nexport function startRum(\n  configuration: RumConfiguration,\n  recorderApi: RecorderApi,\n  customerDataTrackerManager: CustomerDataTrackerManager,\n  getCommonContext: () => CommonContext,\n  initialViewOptions: ViewOptions | undefined,\n  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,\n\n  // `startRum` and its subcomponents assume tracking consent is granted initially and starts\n  // collecting logs unconditionally. As such, `startRum` should be called with a\n  // `trackingConsentState` set to \"granted\".\n  trackingConsentState: TrackingConsentState,\n  customVitalsState: CustomVitalsState\n) {\n  const cleanupTasks: Array<() => void> = []\n  const lifeCycle = new LifeCycle()\n\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event) => sendToExtension('rum', event))\n\n  const telemetry = startRumTelemetry(configuration)\n  telemetry.setContextProvider(() => ({\n    application: {\n      id: configuration.applicationId,\n    },\n    session: {\n      id: session.findTrackedSession()?.id,\n    },\n    view: {\n      id: viewHistory.findView()?.id,\n    },\n    action: {\n      id: actionContexts.findActionId(),\n    },\n  }))\n\n  const reportError = (error: RawError) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error })\n    addTelemetryDebug('Error reported to customer', { 'error.message': error.message })\n  }\n  const featureFlagContexts = startFeatureFlagContexts(\n    lifeCycle,\n    customerDataTrackerManager.getOrCreateTracker(CustomerDataType.FeatureFlag)\n  )\n\n  const pageExitObservable = createPageExitObservable(configuration)\n  const pageExitSubscription = pageExitObservable.subscribe((event) => {\n    lifeCycle.notify(LifeCycleEventType.PAGE_EXITED, event)\n  })\n  cleanupTasks.push(() => pageExitSubscription.unsubscribe())\n\n  const session = !canUseEventBridge()\n    ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)\n    : startRumSessionManagerStub()\n  if (!canUseEventBridge()) {\n    const batch = startRumBatch(\n      configuration,\n      lifeCycle,\n      telemetry.observable,\n      reportError,\n      pageExitObservable,\n      session.expireObservable,\n      createEncoder\n    )\n    cleanupTasks.push(() => batch.stop())\n    startCustomerDataTelemetry(configuration, telemetry, lifeCycle, customerDataTrackerManager, batch.flushObservable)\n  } else {\n    startRumEventBridge(lifeCycle)\n  }\n\n  const domMutationObservable = createDOMMutationObservable()\n  const locationChangeObservable = createLocationChangeObservable(configuration, location)\n  const pageStateHistory = startPageStateHistory(configuration)\n  const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable()\n  cleanupTasks.push(stopWindowOpen)\n\n  const {\n    viewHistory,\n    urlContexts,\n    actionContexts,\n    addAction,\n    stop: stopRumEventCollection,\n  } = startRumEventCollection(\n    lifeCycle,\n    configuration,\n    location,\n    session,\n    pageStateHistory,\n    locationChangeObservable,\n    domMutationObservable,\n    featureFlagContexts,\n    windowOpenObservable,\n    getCommonContext,\n    reportError\n  )\n  cleanupTasks.push(stopRumEventCollection)\n\n  drainPreStartTelemetry()\n\n  const {\n    addTiming,\n    startView,\n    setViewName,\n    setViewContext,\n    setViewContextProperty,\n    getViewContext,\n    stop: stopViewCollection,\n  } = startViewCollection(\n    lifeCycle,\n    configuration,\n    location,\n    domMutationObservable,\n    windowOpenObservable,\n    locationChangeObservable,\n    pageStateHistory,\n    recorderApi,\n    initialViewOptions\n  )\n  cleanupTasks.push(stopViewCollection)\n\n  const { stop: stopResourceCollection } = startResourceCollection(lifeCycle, configuration, pageStateHistory)\n  cleanupTasks.push(stopResourceCollection)\n\n  if (configuration.trackLongTasks) {\n    if (PerformanceObserver.supportedEntryTypes?.includes(RumPerformanceEntryType.LONG_ANIMATION_FRAME)) {\n      const { stop: stopLongAnimationFrameCollection } = startLongAnimationFrameCollection(lifeCycle, configuration)\n      cleanupTasks.push(stopLongAnimationFrameCollection)\n    } else {\n      startLongTaskCollection(lifeCycle, configuration)\n    }\n  }\n\n  const { addError } = startErrorCollection(lifeCycle, configuration, pageStateHistory)\n\n  startRequestCollection(lifeCycle, configuration, session)\n\n  const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState)\n  const internalContext = startInternalContext(\n    configuration.applicationId,\n    session,\n    viewHistory,\n    actionContexts,\n    urlContexts\n  )\n\n  return {\n    addAction,\n    addError,\n    addTiming,\n    addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n    startView,\n    setViewContext,\n    setViewContextProperty,\n    getViewContext,\n    setViewName,\n    lifeCycle,\n    viewHistory,\n    session,\n    stopSession: () => session.expire(),\n    getInternalContext: internalContext.get,\n    startDurationVital: vitalCollection.startDurationVital,\n    stopDurationVital: vitalCollection.stopDurationVital,\n    addDurationVital: vitalCollection.addDurationVital,\n    stop: () => {\n      cleanupTasks.forEach((task) => task())\n    },\n  }\n}\n\nfunction startRumTelemetry(configuration: RumConfiguration) {\n  const telemetry = startTelemetry(TelemetryService.RUM, configuration)\n  if (canUseEventBridge()) {\n    const bridge = getEventBridge<'internal_telemetry', TelemetryEvent>()!\n    telemetry.observable.subscribe((event) => bridge.send('internal_telemetry', event))\n  }\n  return telemetry\n}\n\nexport function startRumEventCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  location: Location,\n  sessionManager: RumSessionManager,\n  pageStateHistory: PageStateHistory,\n  locationChangeObservable: Observable<LocationChange>,\n  domMutationObservable: Observable<void>,\n  featureFlagContexts: FeatureFlagContexts,\n  windowOpenObservable: Observable<void>,\n  getCommonContext: () => CommonContext,\n  reportError: (error: RawError) => void\n) {\n  const viewHistory = startViewHistory(lifeCycle)\n  const urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location)\n\n  const actionCollection = startActionCollection(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    pageStateHistory\n  )\n\n  const displayContext = startDisplayContext(configuration)\n  const ciVisibilityContext = startCiVisibilityContext(configuration)\n\n  startRumAssembly(\n    configuration,\n    lifeCycle,\n    sessionManager,\n    viewHistory,\n    urlContexts,\n    actionCollection.actionContexts,\n    displayContext,\n    ciVisibilityContext,\n    featureFlagContexts,\n    getCommonContext,\n    reportError\n  )\n\n  return {\n    viewHistory,\n    pageStateHistory,\n    urlContexts,\n    addAction: actionCollection.addAction,\n    actionContexts: actionCollection.actionContexts,\n    stop: () => {\n      actionCollection.stop()\n      ciVisibilityContext.stop()\n      displayContext.stop()\n      urlContexts.stop()\n      viewHistory.stop()\n      pageStateHistory.stop()\n    },\n  }\n}\n","import type { Context } from '@datadog/browser-core'\nimport { getEventBridge } from '@datadog/browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { RumEvent } from '../rumEvent.types'\n\nexport function startRumEventBridge(lifeCycle: LifeCycle) {\n  const bridge = getEventBridge<'rum', RumEvent>()!\n\n  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (serverRumEvent: RumEvent & Context) => {\n    bridge.send('rum', serverRumEvent)\n  })\n}\n","import { instrumentMethod, Observable } from '@datadog/browser-core'\n\nexport function createWindowOpenObservable() {\n  const observable = new Observable<void>()\n  const { stop } = instrumentMethod(window, 'open', () => observable.notify())\n  return { observable, stop }\n}\n","import { monitor } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport type { ViewportDimension } from '../../browser/viewportObservable'\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable'\n\nexport type DisplayContext = ReturnType<typeof startDisplayContext>\n\nexport function startDisplayContext(configuration: RumConfiguration) {\n  let viewport: ViewportDimension | undefined\n  // Use requestAnimationFrame to delay the calculation of viewport dimensions until after SDK initialization, preventing long tasks.\n  const animationFrameId = requestAnimationFrame(\n    monitor(() => {\n      viewport = getViewportDimension()\n    })\n  )\n\n  const unsubscribeViewport = initViewportObservable(configuration).subscribe((viewportDimension) => {\n    viewport = viewportDimension\n  }).unsubscribe\n\n  return {\n    get: () => (viewport ? { viewport } : undefined),\n    stop: () => {\n      unsubscribeViewport()\n      if (animationFrameId) {\n        cancelAnimationFrame(animationFrameId)\n      }\n    },\n  }\n}\n","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core'\nimport type { RawRumLongAnimationFrameEvent } from '../../rawRumEvent.types'\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable'\nimport type { RumConfiguration } from '../configuration'\n\nexport function startLongAnimationFrameCollection(lifeCycle: LifeCycle, configuration: RumConfiguration) {\n  const performanceResourceSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.LONG_ANIMATION_FRAME,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      const startClocks = relativeToClocks(entry.startTime)\n\n      const rawRumEvent: RawRumLongAnimationFrameEvent = {\n        date: startClocks.timeStamp,\n        long_task: {\n          id: generateUUID(),\n          entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,\n          duration: toServerDuration(entry.duration),\n          blocking_duration: toServerDuration(entry.blockingDuration),\n          first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),\n          render_start: toServerDuration(entry.renderStart),\n          style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),\n          start_time: toServerDuration(entry.startTime),\n          scripts: entry.scripts.map((script) => ({\n            duration: toServerDuration(script.duration),\n            pause_duration: toServerDuration(script.pauseDuration),\n            forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),\n            start_time: toServerDuration(script.startTime),\n            execution_start: toServerDuration(script.executionStart),\n            source_url: script.sourceURL,\n            source_function_name: script.sourceFunctionName,\n            source_char_position: script.sourceCharPosition,\n            invoker: script.invoker,\n            invoker_type: script.invokerType,\n            window_attribution: script.windowAttribution,\n          })),\n        },\n        type: RumEventType.LONG_TASK,\n        _dd: {\n          discarded: false,\n        },\n      }\n\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        rawRumEvent,\n        startTime: startClocks.relative,\n        domainContext: { performanceEntry: entry },\n      })\n    }\n  })\n\n  return {\n    stop: () => performanceResourceSubscription.unsubscribe(),\n  }\n}\n","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core'\nimport type { RawRumLongTaskEvent } from '../../rawRumEvent.types'\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../browser/performanceObservable'\nimport type { RumConfiguration } from '../configuration'\nexport function startLongTaskCollection(lifeCycle: LifeCycle, configuration: RumConfiguration) {\n  const performanceLongTaskSubscription = createPerformanceObservable(configuration, {\n    type: RumPerformanceEntryType.LONG_TASK,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      if (entry.entryType !== RumPerformanceEntryType.LONG_TASK) {\n        break\n      }\n      if (!configuration.trackLongTasks) {\n        break\n      }\n      const startClocks = relativeToClocks(entry.startTime)\n      const rawRumEvent: RawRumLongTaskEvent = {\n        date: startClocks.timeStamp,\n        long_task: {\n          id: generateUUID(),\n          entry_type: RumLongTaskEntryType.LONG_TASK,\n          duration: toServerDuration(entry.duration),\n        },\n        type: RumEventType.LONG_TASK,\n        _dd: {\n          discarded: false,\n        },\n      }\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        rawRumEvent,\n        startTime: startClocks.relative,\n        domainContext: { performanceEntry: entry },\n      })\n    }\n  })\n\n  return {\n    stop() {\n      performanceLongTaskSubscription.unsubscribe()\n    },\n  }\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport type { ActionContexts } from '../action/actionCollection'\nimport type { RumSessionManager } from '../rumSessionManager'\nimport type { ViewHistory } from './viewHistory'\nimport type { UrlContexts } from './urlContexts'\n\nexport interface InternalContext {\n  application_id: string\n  session_id: string | undefined\n  view?: {\n    id: string\n    url: string\n    referrer: string\n    name?: string\n  }\n  user_action?: {\n    id: string | string[]\n  }\n}\n\n/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(\n  applicationId: string,\n  sessionManager: RumSessionManager,\n  viewHistory: ViewHistory,\n  actionContexts: ActionContexts,\n  urlContexts: UrlContexts\n) {\n  return {\n    get: (startTime?: number): InternalContext | undefined => {\n      const viewContext = viewHistory.findView(startTime as RelativeTime)\n      const urlContext = urlContexts.findUrl(startTime as RelativeTime)\n      const session = sessionManager.findTrackedSession(startTime as RelativeTime)\n      if (session && viewContext && urlContext) {\n        const actionId = actionContexts.findActionId(startTime as RelativeTime)\n        return {\n          application_id: applicationId,\n          session_id: session.id,\n          user_action: actionId ? { id: actionId } : undefined,\n          view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n        }\n      }\n    },\n  }\n}\n","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core'\nimport type { RumConfiguration } from './configuration'\nimport type { ViewHistoryEntry } from './contexts/viewHistory'\nimport type { RumSession } from './rumSessionManager'\n\nexport function getSessionReplayUrl(\n  configuration: RumConfiguration,\n  {\n    session,\n    viewContext,\n    errorType,\n  }: {\n    session?: RumSession\n    viewContext?: ViewHistoryEntry\n    errorType?: string\n  }\n): string {\n  const sessionId = session ? session.id : 'no-session-id'\n  const parameters: string[] = []\n  if (errorType !== undefined) {\n    parameters.push(`error-type=${errorType}`)\n  }\n  if (viewContext) {\n    parameters.push(`seed=${viewContext.id}`)\n    parameters.push(`from=${viewContext.startClocks.timeStamp}`)\n  }\n\n  const origin = getDatadogSiteUrl(configuration)\n  const path = `/rum/replay/sessions/${sessionId}`\n  return `${origin}${path}?${parameters.join('&')}`\n}\n\nexport function getDatadogSiteUrl(rumConfiguration: RumConfiguration) {\n  const site = rumConfiguration.site\n  const subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration)\n  return `https://${subdomain ? `${subdomain}.` : ''}${site}`\n}\n\nfunction getSiteDefaultSubdomain(configuration: RumConfiguration): string | undefined {\n  switch (configuration.site) {\n    case INTAKE_SITE_US1:\n    case INTAKE_SITE_EU1:\n      return 'app'\n    case INTAKE_SITE_STAGING:\n      return 'dd'\n    default:\n      return undefined\n  }\n}\n","import type { ReplayStats } from '@datadog/browser-rum-core'\n\nexport const MAX_STATS_HISTORY = 10\nlet statsPerView: Map<string, ReplayStats> | undefined\n\nexport function getSegmentsCount(viewId: string) {\n  return getOrCreateReplayStats(viewId).segments_count\n}\n\nexport function addSegment(viewId: string) {\n  getOrCreateReplayStats(viewId).segments_count += 1\n}\n\nexport function addRecord(viewId: string) {\n  getOrCreateReplayStats(viewId).records_count += 1\n}\n\nexport function addWroteData(viewId: string, additionalBytesCount: number) {\n  getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount\n}\n\nexport function getReplayStats(viewId: string) {\n  return statsPerView?.get(viewId)\n}\n\nexport function resetReplayStats() {\n  statsPerView = undefined\n}\n\nfunction getOrCreateReplayStats(viewId: string) {\n  if (!statsPerView) {\n    statsPerView = new Map()\n  }\n\n  let replayStats: ReplayStats\n  if (statsPerView.has(viewId)) {\n    replayStats = statsPerView.get(viewId)!\n  } else {\n    replayStats = {\n      records_count: 0,\n      segments_count: 0,\n      segments_total_raw_size: 0,\n    }\n    statsPerView.set(viewId, replayStats)\n    if (statsPerView.size > MAX_STATS_HISTORY) {\n      deleteOldestStats()\n    }\n  }\n\n  return replayStats\n}\n\nfunction deleteOldestStats() {\n  if (!statsPerView) {\n    return\n  }\n  const toDelete = statsPerView.keys().next().value\n  if (toDelete) {\n    statsPerView.delete(toDelete)\n  }\n}\n","import type {\n  DeflateWorkerResponse,\n  DeflateEncoder,\n  DeflateEncoderStreamId,\n  DeflateWorker,\n  EncoderResult,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '@datadog/browser-rum-core'\nimport { addEventListener, addTelemetryDebug, concatBuffers } from '@datadog/browser-core'\n\nexport function createDeflateEncoder(\n  configuration: RumConfiguration,\n  worker: DeflateWorker,\n  streamId: DeflateEncoderStreamId\n): DeflateEncoder {\n  let rawBytesCount = 0\n  let compressedData: Uint8Array[] = []\n  let compressedDataTrailer: Uint8Array\n\n  let nextWriteActionId = 0\n  const pendingWriteActions: Array<{\n    writeCallback?: (additionalEncodedBytesCount: number) => void\n    finishCallback?: () => void\n    id: number\n    data: string\n  }> = []\n\n  const { stop: removeMessageListener } = addEventListener(\n    configuration,\n    worker,\n    'message',\n    ({ data: workerResponse }: MessageEvent<DeflateWorkerResponse>) => {\n      if (workerResponse.type !== 'wrote' || (workerResponse.streamId as DeflateEncoderStreamId) !== streamId) {\n        return\n      }\n\n      rawBytesCount += workerResponse.additionalBytesCount\n      compressedData.push(workerResponse.result)\n      compressedDataTrailer = workerResponse.trailer\n\n      const nextPendingAction = pendingWriteActions.shift()\n      if (nextPendingAction && nextPendingAction.id === workerResponse.id) {\n        if (nextPendingAction.writeCallback) {\n          nextPendingAction.writeCallback(workerResponse.result.byteLength)\n        } else if (nextPendingAction.finishCallback) {\n          nextPendingAction.finishCallback()\n        }\n      } else {\n        removeMessageListener()\n        addTelemetryDebug('Worker responses received out of order.')\n      }\n    }\n  )\n\n  function consumeResult(): EncoderResult<Uint8Array> {\n    const output =\n      compressedData.length === 0 ? new Uint8Array(0) : concatBuffers(compressedData.concat(compressedDataTrailer))\n    const result: EncoderResult<Uint8Array> = {\n      rawBytesCount,\n      output,\n      outputBytesCount: output.byteLength,\n      encoding: 'deflate',\n    }\n    rawBytesCount = 0\n    compressedData = []\n    return result\n  }\n\n  function sendResetIfNeeded() {\n    if (nextWriteActionId > 0) {\n      worker.postMessage({\n        action: 'reset',\n        streamId,\n      })\n      nextWriteActionId = 0\n    }\n  }\n\n  return {\n    isAsync: true,\n\n    get isEmpty() {\n      return nextWriteActionId === 0\n    },\n\n    write(data, callback) {\n      worker.postMessage({\n        action: 'write',\n        id: nextWriteActionId,\n        data,\n        streamId,\n      })\n      pendingWriteActions.push({\n        id: nextWriteActionId,\n        writeCallback: callback,\n        data,\n      })\n      nextWriteActionId += 1\n    },\n\n    finish(callback) {\n      sendResetIfNeeded()\n\n      if (!pendingWriteActions.length) {\n        callback(consumeResult())\n      } else {\n        // Make sure we do not call any write callback\n        pendingWriteActions.forEach((pendingWriteAction) => {\n          delete pendingWriteAction.writeCallback\n        })\n\n        // Wait for the last action to finish before calling the finish callback\n        pendingWriteActions[pendingWriteActions.length - 1].finishCallback = () => callback(consumeResult())\n      }\n    },\n\n    finishSync() {\n      sendResetIfNeeded()\n\n      const pendingData = pendingWriteActions\n        .map((pendingWriteAction) => {\n          // Make sure we do not call any write or finish callback\n          delete pendingWriteAction.writeCallback\n          delete pendingWriteAction.finishCallback\n          return pendingWriteAction.data\n        })\n        .join('')\n\n      return { ...consumeResult(), pendingData }\n    },\n\n    estimateEncodedBytesCount(data) {\n      // This is a rough estimation of the data size once it'll be encoded by deflate. We observed\n      // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but\n      // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce\n      // requests of the expected size.\n      return data.length / 8\n    },\n\n    stop() {\n      removeMessageListener()\n    },\n  }\n}\n","import type { DeflateWorker, DeflateWorkerResponse } from '@datadog/browser-core'\nimport {\n  addTelemetryError,\n  display,\n  addEventListener,\n  setTimeout,\n  ONE_SECOND,\n  DOCS_ORIGIN,\n} from '@datadog/browser-core'\nimport type { RumConfiguration } from '@datadog/browser-rum-core'\n\nexport const INITIALIZATION_TIME_OUT_DELAY = 30 * ONE_SECOND\n\ndeclare const __BUILD_ENV__WORKER_STRING__: string\n\n/**\n * In order to be sure that the worker is correctly working, we need a round trip of\n * initialization messages, making the creation asynchronous.\n * These worker lifecycle states handle this case.\n */\nexport const enum DeflateWorkerStatus {\n  Nil,\n  Loading,\n  Error,\n  Initialized,\n}\n\ntype DeflateWorkerState =\n  | {\n      status: DeflateWorkerStatus.Nil\n    }\n  | {\n      status: DeflateWorkerStatus.Loading\n      worker: DeflateWorker\n      stop: () => void\n      initializationFailureCallbacks: Array<() => void>\n    }\n  | {\n      status: DeflateWorkerStatus.Error\n    }\n  | {\n      status: DeflateWorkerStatus.Initialized\n      worker: DeflateWorker\n      stop: () => void\n      version: string\n    }\n\nexport type CreateDeflateWorker = typeof createDeflateWorker\n\nfunction createDeflateWorker(configuration: RumConfiguration): DeflateWorker {\n  return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([__BUILD_ENV__WORKER_STRING__])))\n}\n\nlet state: DeflateWorkerState = { status: DeflateWorkerStatus.Nil }\n\nexport function startDeflateWorker(\n  configuration: RumConfiguration,\n  source: string,\n  onInitializationFailure: () => void,\n  createDeflateWorkerImpl = createDeflateWorker\n) {\n  if (state.status === DeflateWorkerStatus.Nil) {\n    // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n    doStartDeflateWorker(configuration, source, createDeflateWorkerImpl)\n  }\n\n  switch (state.status) {\n    case DeflateWorkerStatus.Loading:\n      state.initializationFailureCallbacks.push(onInitializationFailure)\n      return state.worker\n    case DeflateWorkerStatus.Initialized:\n      return state.worker\n  }\n}\n\nexport function resetDeflateWorkerState() {\n  if (state.status === DeflateWorkerStatus.Initialized || state.status === DeflateWorkerStatus.Loading) {\n    state.stop()\n  }\n  state = { status: DeflateWorkerStatus.Nil }\n}\n\nexport function getDeflateWorkerStatus() {\n  return state.status\n}\n\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(\n  configuration: RumConfiguration,\n  source: string,\n  createDeflateWorkerImpl = createDeflateWorker\n) {\n  try {\n    const worker = createDeflateWorkerImpl(configuration)\n    const { stop: removeErrorListener } = addEventListener(configuration, worker, 'error', (error) => {\n      onError(configuration, source, error)\n    })\n    const { stop: removeMessageListener } = addEventListener(\n      configuration,\n      worker,\n      'message',\n      ({ data }: MessageEvent<DeflateWorkerResponse>) => {\n        if (data.type === 'errored') {\n          onError(configuration, source, data.error, data.streamId)\n        } else if (data.type === 'initialized') {\n          onInitialized(data.version)\n        }\n      }\n    )\n    worker.postMessage({ action: 'init' })\n    setTimeout(() => onTimeout(source), INITIALIZATION_TIME_OUT_DELAY)\n    const stop = () => {\n      removeErrorListener()\n      removeMessageListener()\n    }\n\n    state = { status: DeflateWorkerStatus.Loading, worker, stop, initializationFailureCallbacks: [] }\n  } catch (error) {\n    onError(configuration, source, error)\n  }\n}\n\nfunction onTimeout(source: string) {\n  if (state.status === DeflateWorkerStatus.Loading) {\n    display.error(`${source} failed to start: a timeout occurred while initializing the Worker`)\n    state.initializationFailureCallbacks.forEach((callback) => callback())\n    state = { status: DeflateWorkerStatus.Error }\n  }\n}\n\nfunction onInitialized(version: string) {\n  if (state.status === DeflateWorkerStatus.Loading) {\n    state = { status: DeflateWorkerStatus.Initialized, worker: state.worker, stop: state.stop, version }\n  }\n}\n\nfunction onError(configuration: RumConfiguration, source: string, error: unknown, streamId?: number) {\n  if (state.status === DeflateWorkerStatus.Loading || state.status === DeflateWorkerStatus.Nil) {\n    display.error(`${source} failed to start: an error occurred while creating the Worker:`, error)\n    if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n      let baseMessage\n      if (configuration.workerUrl) {\n        baseMessage = `Please make sure the Worker URL ${configuration.workerUrl} is correct and CSP is correctly configured.`\n      } else {\n        baseMessage = 'Please make sure CSP is correctly configured.'\n      }\n      display.error(\n        `${baseMessage} See documentation at ${DOCS_ORIGIN}/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay`\n      )\n    } else {\n      addTelemetryError(error)\n    }\n    if (state.status === DeflateWorkerStatus.Loading) {\n      state.initializationFailureCallbacks.forEach((callback) => callback())\n    }\n    state = { status: DeflateWorkerStatus.Error }\n  } else {\n    addTelemetryError(error, {\n      worker_version: state.status === DeflateWorkerStatus.Initialized && state.version,\n      stream_id: streamId,\n    })\n  }\n}\n\nfunction isMessageCspRelated(message: string) {\n  return (\n    message.includes('Content Security Policy') ||\n    // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n    message.includes(\"requires 'TrustedScriptURL'\")\n  )\n}\n","/**\n * Test for Browser features used while recording\n */\nexport function isBrowserSupported() {\n  return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' &&\n    typeof CSSSupportsRule === 'function' &&\n    typeof URL.createObjectURL === 'function' &&\n    'forEach' in NodeList.prototype\n  )\n}\n","import type {\n  LifeCycle,\n  RumConfiguration,\n  RumSessionManager,\n  StartRecordingOptions,\n  ViewHistory,\n  RumSession,\n} from '@datadog/browser-rum-core'\nimport { LifeCycleEventType, SessionReplayState } from '@datadog/browser-rum-core'\nimport { asyncRunOnReadyState, monitorError, PageExitReason, type DeflateEncoder } from '@datadog/browser-core'\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink'\nimport type { startRecording } from './startRecording'\n\nexport type StartRecording = typeof startRecording\n\nexport const enum RecorderStatus {\n  // The recorder is stopped.\n  Stopped,\n  // The user started the recording while it wasn't possible yet. The recorder should start as soon\n  // as possible.\n  IntentToStart,\n  // The recorder is starting. It does not record anything yet.\n  Starting,\n  // The recorder is started, it records the session.\n  Started,\n}\n\nexport interface Strategy {\n  start: (options?: StartRecordingOptions) => void\n  stop: () => void\n  isRecording: () => boolean\n  getSessionReplayLink: () => string | undefined\n}\n\nexport function createPostStartStrategy(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  sessionManager: RumSessionManager,\n  viewHistory: ViewHistory,\n  loadRecorder: () => Promise<StartRecording | undefined>,\n  getOrCreateDeflateEncoder: () => DeflateEncoder | undefined\n): Strategy {\n  let status = RecorderStatus.Stopped\n  let stopRecording: () => void\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {\n    if (status === RecorderStatus.Starting || status === RecorderStatus.Started) {\n      stop()\n      status = RecorderStatus.IntentToStart\n    }\n  })\n\n  // Stop the recorder on page unload to avoid sending records after the page is ended.\n  lifeCycle.subscribe(LifeCycleEventType.PAGE_EXITED, (pageExitEvent) => {\n    if (pageExitEvent.reason === PageExitReason.UNLOADING) {\n      stop()\n    }\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    if (status === RecorderStatus.IntentToStart) {\n      start()\n    }\n  })\n\n  const doStart = async () => {\n    const [startRecordingImpl] = await Promise.all([loadRecorder(), asyncRunOnReadyState(configuration, 'interactive')])\n\n    if (status !== RecorderStatus.Starting) {\n      return\n    }\n\n    const deflateEncoder = getOrCreateDeflateEncoder()\n    if (!deflateEncoder || !startRecordingImpl) {\n      status = RecorderStatus.Stopped\n      return\n    }\n\n    ;({ stop: stopRecording } = startRecordingImpl(\n      lifeCycle,\n      configuration,\n      sessionManager,\n      viewHistory,\n      deflateEncoder\n    ))\n\n    status = RecorderStatus.Started\n  }\n\n  function start(options?: StartRecordingOptions) {\n    const session = sessionManager.findTrackedSession()\n    if (canStartRecording(session, options)) {\n      status = RecorderStatus.IntentToStart\n      return\n    }\n\n    if (isRecordingInProgress(status)) {\n      return\n    }\n\n    status = RecorderStatus.Starting\n\n    // Intentionally not awaiting doStart() to keep it asynchronous\n    doStart().catch(monitorError)\n\n    if (shouldForceReplay(session!, options)) {\n      sessionManager.setForcedReplay()\n    }\n  }\n\n  function stop() {\n    if (status === RecorderStatus.Started) {\n      stopRecording?.()\n    }\n\n    status = RecorderStatus.Stopped\n  }\n\n  return {\n    start,\n    stop,\n    getSessionReplayLink() {\n      return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== RecorderStatus.Stopped)\n    },\n    isRecording: () => status === RecorderStatus.Started,\n  }\n}\n\nfunction canStartRecording(session: RumSession | undefined, options?: StartRecordingOptions) {\n  return !session || (session.sessionReplay === SessionReplayState.OFF && (!options || !options.force))\n}\n\nfunction isRecordingInProgress(status: RecorderStatus) {\n  return status === RecorderStatus.Starting || status === RecorderStatus.Started\n}\n\nfunction shouldForceReplay(session: RumSession, options?: StartRecordingOptions) {\n  return options && options.force && session.sessionReplay === SessionReplayState.OFF\n}\n","import type { RumConfiguration, RumSessionManager, ViewHistory, RumSession } from '@datadog/browser-rum-core'\nimport { getSessionReplayUrl, SessionReplayState } from '@datadog/browser-rum-core'\nimport { isBrowserSupported } from '../boot/isBrowserSupported'\n\nexport function getSessionReplayLink(\n  configuration: RumConfiguration,\n  sessionManager: RumSessionManager,\n  viewHistory: ViewHistory,\n  isRecordingStarted: boolean\n): string | undefined {\n  const session = sessionManager.findTrackedSession()\n  const errorType = getErrorType(session, isRecordingStarted)\n  const viewContext = viewHistory.findView()\n\n  return getSessionReplayUrl(configuration, {\n    viewContext,\n    errorType,\n    session,\n  })\n}\n\nfunction getErrorType(session: RumSession | undefined, isRecordingStarted: boolean) {\n  if (!isBrowserSupported()) {\n    return 'browser-not-supported'\n  }\n  if (!session) {\n    // possibilities:\n    // - rum sampled out\n    // - session expired (edge case)\n    return 'rum-not-tracked'\n  }\n  if (session.sessionReplay === SessionReplayState.OFF) {\n    // possibilities\n    // - replay sampled out\n    return 'incorrect-session-plan'\n  }\n  if (!isRecordingStarted) {\n    return 'replay-not-started'\n  }\n}\n","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core'\nimport type { RumPublicApi } from '@datadog/browser-rum-core'\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core'\nimport { makeRecorderApi } from '../boot/recorderApi'\nimport { createDeflateEncoder, startDeflateWorker } from '../domain/deflate'\nimport { lazyLoadRecorder } from '../boot/lazyLoadRecorder'\nexport {\n  CommonProperties,\n  RumPublicApi as RumGlobal,\n  RumInitConfiguration,\n  // Events\n  RumEvent,\n  RumActionEvent,\n  RumErrorEvent,\n  RumLongTaskEvent,\n  RumResourceEvent,\n  RumViewEvent,\n  RumVitalEvent,\n  // Events context\n  RumEventDomainContext,\n  RumViewEventDomainContext,\n  RumErrorEventDomainContext,\n  RumActionEventDomainContext,\n  RumFetchResourceEventDomainContext,\n  RumXhrResourceEventDomainContext,\n  RumOtherResourceEventDomainContext,\n  RumLongTaskEventDomainContext,\n} from '@datadog/browser-rum-core'\nexport { DefaultPrivacyLevel } from '@datadog/browser-core'\n\nconst recorderApi = makeRecorderApi(lazyLoadRecorder)\n\nexport const datadogRum = makeRumPublicApi(startRum, recorderApi, { startDeflateWorker, createDeflateEncoder })\n\ninterface BrowserWindow extends Window {\n  DD_RUM?: RumPublicApi\n}\ndefineGlobal(getGlobalObject<BrowserWindow>(), 'DD_RUM', datadogRum)\n","import type { DeflateEncoder, DeflateWorker } from '@datadog/browser-core'\nimport {\n  canUseEventBridge,\n  noop,\n  BridgeCapability,\n  bridgeSupports,\n  DeflateEncoderStreamId,\n} from '@datadog/browser-core'\nimport type {\n  LifeCycle,\n  ViewHistory,\n  RumSessionManager,\n  RecorderApi,\n  RumConfiguration,\n  StartRecordingOptions,\n} from '@datadog/browser-rum-core'\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats'\nimport type { CreateDeflateWorker } from '../domain/deflate'\nimport {\n  createDeflateEncoder,\n  DeflateWorkerStatus,\n  getDeflateWorkerStatus,\n  startDeflateWorker,\n} from '../domain/deflate'\nimport { isBrowserSupported } from './isBrowserSupported'\nimport type { StartRecording } from './postStartStrategy'\nimport { createPostStartStrategy } from './postStartStrategy'\nimport { createPreStartStrategy } from './preStartStrategy'\n\nexport function makeRecorderApi(\n  loadRecorder: () => Promise<StartRecording | undefined>,\n  createDeflateWorkerImpl?: CreateDeflateWorker\n): RecorderApi {\n  if ((canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) || !isBrowserSupported()) {\n    return {\n      start: noop,\n      stop: noop,\n      getReplayStats: () => undefined,\n      onRumStart: noop,\n      isRecording: () => false,\n      getSessionReplayLink: () => undefined,\n    }\n  }\n\n  // eslint-disable-next-line prefer-const\n  let { strategy, shouldStartImmediately } = createPreStartStrategy()\n\n  return {\n    start: (options?: StartRecordingOptions) => strategy.start(options),\n    stop: () => strategy.stop(),\n    getSessionReplayLink: () => strategy.getSessionReplayLink(),\n    onRumStart,\n    isRecording: () =>\n      // The worker is started optimistically, meaning we could have started to record but its\n      // initialization fails a bit later. This could happen when:\n      // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n      // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n      // * the browser fails to load the worker in case the workerUrl is used\n      // * an unexpected error occurs in the Worker before initialization, ex:\n      //   * a runtime exception collected by monitor()\n      //   * a syntax error notified by the browser via an error event\n      // * the worker is unresponsive for some reason and timeouts\n      //\n      // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n      // an important part of the Datadog App:\n      // * If we have a false positive (we set has_replay: true even if no replay data is present),\n      // we might display broken links to the Session Replay player.\n      // * If we have a false negative (we don't set has_replay: true even if replay data is\n      // available), it is less noticeable because no link will be displayed.\n      //\n      // Thus, it is better to have false negative, so let's make sure the worker is correctly\n      // initialized before advertizing that we are recording.\n      //\n      // In the future, when the compression worker will also be used for RUM data, this will be\n      // less important since no RUM event will be sent when the worker fails to initialize.\n      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized && strategy.isRecording(),\n\n    getReplayStats: (viewId) =>\n      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized ? getReplayStatsImpl(viewId) : undefined,\n  }\n\n  function onRumStart(\n    lifeCycle: LifeCycle,\n    configuration: RumConfiguration,\n    sessionManager: RumSessionManager,\n    viewHistory: ViewHistory,\n    worker: DeflateWorker | undefined\n  ) {\n    let cachedDeflateEncoder: DeflateEncoder | undefined\n\n    function getOrCreateDeflateEncoder() {\n      if (!cachedDeflateEncoder) {\n        worker ??= startDeflateWorker(\n          configuration,\n          'Datadog Session Replay',\n          () => {\n            strategy.stop()\n          },\n          createDeflateWorkerImpl\n        )\n\n        if (worker) {\n          cachedDeflateEncoder = createDeflateEncoder(configuration, worker, DeflateEncoderStreamId.REPLAY)\n        }\n      }\n      return cachedDeflateEncoder\n    }\n\n    strategy = createPostStartStrategy(\n      configuration,\n      lifeCycle,\n      sessionManager,\n      viewHistory,\n      loadRecorder,\n      getOrCreateDeflateEncoder\n    )\n\n    if (shouldStartImmediately(configuration)) {\n      strategy.start()\n    }\n  }\n}\n","import { noop } from '@datadog/browser-core'\nimport type { RumConfiguration } from '@datadog/browser-rum-core'\nimport type { Strategy } from './postStartStrategy'\n\nconst enum PreStartRecorderStatus {\n  None,\n  HadManualStart,\n  HadManualStop,\n}\n\nexport function createPreStartStrategy(): {\n  strategy: Strategy\n  shouldStartImmediately: (configuration: RumConfiguration) => boolean\n} {\n  let status = PreStartRecorderStatus.None\n  return {\n    strategy: {\n      start() {\n        status = PreStartRecorderStatus.HadManualStart\n      },\n      stop() {\n        status = PreStartRecorderStatus.HadManualStop\n      },\n      isRecording: () => false,\n      getSessionReplayLink: noop as () => string | undefined,\n    },\n    shouldStartImmediately(configuration) {\n      return (\n        status === PreStartRecorderStatus.HadManualStart ||\n        (status === PreStartRecorderStatus.None && !configuration.startSessionReplayRecordingManually)\n      )\n    },\n  }\n}\n","export async function lazyLoadRecorder() {\n  try {\n    const module = await import(/* webpackChunkName: \"recorder\" */ './startRecording')\n    return module.startRecording\n  } catch {\n    /* Prevent collecting the webpack ChunkLoadError as it is already collected as a RUM resource. */\n  }\n}\n"],"names":["makePublicApi","stub","publicApi","version","onReady","callback","Object","defineProperty","get","enumerable","defineGlobal","global","name","api","existingGlobalVariable","q","warn","forEach","fn","addEventListener","configuration","eventTarget","eventName","listener","options","addEventListeners","eventNames","once","capture","passive","listenerWithMonitor","event","isTrusted","__ddIsTrusted","allowUntrustedEvents","stop","listenerTarget","window","EventTarget","prototype","add","remove","call","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","createPageExitObservable","observable","stopListeners","type","document","visibilityState","notify","reason","stopBeforeUnloadListener","isPageExitReason","includes","runOnReadyState","expectedReadyState","readyState","asyncRunOnReadyState","Promise","resolve","INTAKE_SITE_STAGING","INTAKE_SITE_FED_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_US1_FED","PCI_INTAKE_HOST_US1","INTAKE_URL_PARAMETERS","getConnectivity","navigator","status","onLine","interfaces","connection","undefined","effective_type","effectiveType","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","handlingStack","componentStack","startClocks","nonErrorPrefix","source","handling","isErrorInstance","isError","message","computeMessage","stack","length","url","hasUsableStack","causes","flattenErrorCauses","fingerprint","tryToGetFingerprint","String","dd_fingerprint","error","Error","toString","parentSource","currentError","cause","push","ErrorSource","AGENT","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","TelemetryType","log","usage","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","preStartTelemetryBuffer","onRawTelemetryEventCollected","startTelemetry","telemetryService","contextProvider","alreadySentEvents","Set","telemetryEnabled","site","telemetrySampleRate","telemetryEnabledPerType","telemetryConfigurationSampleRate","telemetryUsageSampleRate","runtimeEnvInfo","is_local_file","location","protocol","is_worker","self","rawEvent","stringifiedEvent","jsonStringify","size","maxTelemetryEventsPerPage","has","date","service","_dd","format_version","telemetry","runtime_env","connectivity","sdk_setup","experimental_features","Array","from","toTelemetryEvent","sendToExtension","addTelemetryError","setContextProvider","provider","enabled","drainPreStartTelemetry","drain","isTelemetryReplicationAllowed","addTelemetryDebug","context","debug","e","formatError","addTelemetryConfiguration","addTelemetryUsage","computeStackTrace","kind","scrubCustomerFrames","filter","frame","some","allowedFrameUrl","startsWith","BUFFER_LIMIT","createBoundedBuffer","buffer","splice","arg","catchUserErrors","errorMsg","args","err","ConsoleApiName","info","globalConsole","console","originalConsoleMethods","keys","PREFIX","display","bind","DOCS_ORIGIN","DOCS_TROUBLESHOOTING","MORE_DETAILS","ExperimentalFeature","enabledExperimentalFeatures","initFeatureFlags","enableExperimentalFeatures","isArray","flag","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","getGlobalObject","globalThis","this","configurable","globalObject","_dd_temp_","getZoneJsOriginalValue","target","browserWindow","original","Zone","__symbol__","instrumentMethod","targetPrototype","method","onPreCall","computeHandlingStack","stopped","instrumentation","apply","arguments","parameters","postCallCallback","onPostCall","result","instrumentSetter","property","after","originalDescriptor","getOwnPropertyDescriptor","set","stoppedInstrumentation","value","instrumentationWrapper","mergeInto","destination","circularReferenceChecker","WeakSet","hasAlreadyBeenSeen","array","indexOf","createCircularReferenceChecker","Date","getTime","RegExp","flags","ignoreCase","multiline","sticky","unicode","join","merged","i","key","hasOwnProperty","deepClone","combine","sources","onMonitorErrorCollected","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","monitor","callMonitored","monitorError","displayIfDebugEnabled","Observable","constructor","onFirstSubscribe","observers","subscribe","f","onLastUnsubscribe","unsubscribe","other","data","observer","mergeObservables","observables","globalObservable","subscriptions","map","subscription","requestIdleCallback","opts","cancelIdleCallback","id","start","timeoutId","didTimeout","timeRemaining","Math","max","MAX_TASK_TIME","requestIdleCallbackShim","payload","__ddBrowserSdkExtensionCallback","replacer","space","JSON","stringify","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","WeakMap","sanitizedData","sanitizeProcessor","serializedSanitizedData","accumulatedCharacterCount","containerToProcess","shift","separatorLength","targetData","path","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","description","sanitizedSource","sanitizeObjects","sourceAsObject","currentPath","Event","currentTarget","match","changeType","UNKNOWN_FUNCTION","ex","stackProperty","tryToGetString","exString","slice","split","line","stackFrame","parts","CHROME_LINE_RE","exec","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","fileUrl","filePosition","candidate","computeStackTraceFromOnErrorMessage","messageObj","ERROR_TYPES_RE","tryToParseMessage","createHandlingStack","formattedStack","toStackTraceString","formatErrorMessage","setTimeout","delay","clearTimeout","setInterval","clearInterval","removeItem","item","index","isChromium","detectBrowserCached","isSafari","browserCache","userAgent","chrome","test","vendor","detectBrowser","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","TextEncoder","encode","Blob","concatBuffers","buffers","reduce","total","Uint8Array","offset","throttle","wait","needLeadingExecution","leading","needTrailingExecution","trailing","pendingExecutionWithParameters","pendingTimeoutId","inWaitPeriod","throttled","cancel","noop","performDraw","threshold","random","round","num","decimals","toFixed","isPercentage","isNumber","shallowClone","objectHasValue","isEmptyObject","mapValues","newObject","findLast","predicate","objectValues","values","objectEntries","entries","isServerError","tryToClone","response","clone","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","timeStampToClocks","getRelativeTime","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","addDuration","getTimeStamp","currentDrift","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","end","a","b","timestamp","looksLikeRelativeTime","time","navigationStart","timing","getType","normalizeUrl","buildUrl","href","isValidUrl","getPathName","pathname","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","anchorElement","createElement","implementation","createHTMLDocument","baseElement","head","appendChild","body","URL","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getCapabilities","parse","getPrivacyLevel","getAllowedWebViewHosts","send","eventType","viewId","view","bridgeSupports","capability","bridge","canUseEventBridge","currentHost","hostname","allowedHost","endsWith","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","state","sendStrategy","trackType","reportError","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","first","dequeue","currentBackoffTime","min","shouldRetryRequest","ongoingRequestCount","retry","count","lastFailureStatus","isFull","queueFullReported","previousQueue","newPayloadQueue","bytesCount","createHttpRequest","endpointBuilder","bytesLimit","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","Request","isKeepAliveSupported","fetchUrl","build","fetch","keepalive","mode","then","sendXHR","fetchKeepAliveStrategy","sendOnExit","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","request","XMLHttpRequest","open","setRequestHeader","CUSTOMER_DATA_BYTES_LIMIT","CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT","BYTES_COMPUTATION_THROTTLING_DELAY","createCustomerDataTracker","checkCustomerDataLimit","bytesCountCache","computeBytesCountThrottled","cancelComputeBytesCount","resetBytesCount","updateCustomerData","resetCustomerData","getBytesCount","createContextManager","customerDataTracker","changeObservable","contextManager","getContext","setContext","newContext","clearContext","setContextProperty","removeContextProperty","TrackingConsent","GRANTED","NOT_GRANTED","CONTEXT_STORE_KEY_PREFIX","storageListeners","storeContextManager","productKey","customerDataType","storageKey","buildStorageKey","getFromStorage","rawContext","localStorage","getItem","setItem","createIdentityEncoder","output","outputBytesCount","isAsync","isEmpty","write","additionalEncodedBytesCount","finish","finishSync","rawBytesCount","pendingData","estimateEncodedBytesCount","sanitizeUser","newUser","user","displayAlreadyInitializedError","sdkName","initConfiguration","silentMultipleInit","generateUUID","placeholder","parseInt","replace","COMMA_SEPARATED_KEY_VALUE","findCommaSeparatedValue","rawString","lastIndex","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","startDurationVital","vitalsByName","vitalsByReference","vital","reference","__dd_vital_reference","stopDurationVital","stopCallback","nameOrRef","vitalStart","stopOptions","stopClocks","buildDurationVital","delete","callPluginsMethod","plugins","methodName","parameter","plugin","fetchObservable","initFetchObservable","input","init","methodFromParams","toUpperCase","responsePromise","startContext","reportFetch","partialContext","assign","responseType","isAborted","signal","aborted","DOMException","code","ABORT_ERR","afterSend","beforeSend","setCookie","expireDelay","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","partitioned","cookie","getCookie","initCookieParsed","getCurrentSiteCache","getInitCookie","Map","findCommaSeparatedValues","deleteCookie","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","SESSION_STORE_KEY","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_COOKIE_EXPIRATION_DELAY","SessionPersistence","COOKIE","LOCAL_STORAGE","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","EXPIRED","getExpiredSessionState","previousSessionState","expiredSessionState","isExpired","trackAnonymousUser","anonymousId","floor","pow","padStart","isSessionInNotStartedState","session","isSessionStarted","isSessionInExpiredState","sessionState","created","Number","expire","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","useSecureSessionCookie","usePartitionedCrossSiteSessionCookie","trackSessionAcrossSubdomains","testCookieName","testCookieValue","domainLevels","candidateDomain","pop","getCurrentSite","buildCookieOptions","isCookieCorrectlySet","areCookiesAuthorized","retrieveSessionCookie","LOCAL_STORAGE_TEST_KEY","selectLocalStorageStrategy","testKey","retrievedId","persistInLocalStorage","retrieveSessionFromLocalStorage","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","bufferedOperations","ongoingOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","isLockEnabled","persistSession","expireSession","persistWithLock","lock","currentLock","retrieveStore","retrieveSession","next","currentStore","retryLater","processedSession","process","sessionStore","currentNumberOfRetries","nextOperations","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","sessionPersistence","sessionStoreStrategyType","allowFallbackToLocalStorage","startSessionStore","computeSessionState","renewObservable","expireObservable","sessionStateUpdateObservable","cookieStore","expireSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","initCookieStrategy","expireSessionFromLocalStorage","initLocalStorageStrategy","watchSessionTimeoutId","synchronizeSession","sessionCache","startSession","throttledExpandOrRenewSession","cancelExpandOrRenewSession","synchronizedSession","trackingType","isTracked","expandOrRenewSessionState","hasSessionInCache","renewSessionInCache","isSessionInCacheOutdated","previousState","newState","expandOrRenewSession","expandSession","getSession","restartSession","updateSessionState","partialSessionState","createEndpointBuilder","configurationTags","buildUrlWithParameters","proxy","normalizedProxyUrl","encodeURIComponent","host","internalAnalyticsSubdomain","usePciIntake","domainParts","extension","buildEndpointHost","createEndpointUrlWithParametersBuilder","clientToken","encoding","tags","reverse","buildEndpointParameters","urlPrefix","TAG_SIZE_LIMIT","buildTag","rawValue","valueSizeLimit","supportUnicodePropertyEscapes","hasForbiddenCharacters","computeTransportConfiguration","env","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","TraceContextInjection","ALL","SAMPLED","isString","tag","tagName","isSampleRate","sampleRate","isMatchOption","itemType","matchList","list","useStartsWith","getCrypto","crypto","msCrypto","createSpanIdentifier","createIdentifier","createIdentifierImplementationCache","bits","CONSISTENT_TRACE_SAMPLING","getRandomValues","BigUint64Array","areBigIntIdentifiersSupported","createIdentifierUsingBigInt","createIdentifierUsingUint32Array","BigInt","Uint32Array","radix","high","low","str","mod","toPaddedHexadecimalString","traceId","clearTracingIfNeeded","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","findTrackedSession","tracingOption","allowedTracingUrls","find","identifier","knuthFactor","twoPow64","isTraceSampled","traceSampleRate","traceContextInjection","propagatorTypes","tracingHeaders","propagatorType","traceparent","tracestate","b3","makeTracingHeaders","DEFAULT_PROPAGATOR_TYPES","validateAndBuildRumConfiguration","trackFeatureFlagsForEvents","sessionReplaySampleRate","excludedActivityUrls","tracingOptions","option","expectedItem","isTracingOption","validateAndBuildTracingOptions","baseConfiguration","sessionSampleRate","trackingConsent","storeContextsAcrossPages","batchBytesLimit","eventRateLimiterThreshold","flushTimeout","batchMessagesLimit","messageBytesLimit","validateAndBuildConfiguration","actionNameAttribute","startSessionReplayRecordingManually","rulePsr","workerUrl","compressIntakeRequests","trackUserInteractions","trackViewsManually","trackResources","trackLongTasks","subdomain","defaultPrivacyLevel","enablePrivacyForActionName","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","REMOTE_CONFIGURATION_URL","displayRemoteConfigurationFetchingError","createPreStartStrategy","ignoreInitIfSyntheticsWillInjectRum","startDeflateWorker","getCommonContext","trackingConsentState","customVitalsState","doStartRum","bufferApiCalls","firstStartViewCall","deflateWorker","cachedInitConfiguration","cachedConfiguration","trackingConsentStateSubscription","tryStartRum","emptyContext","isGranted","initialViewOptions","startRumResult","doInit","eventBridgeAvailable","overrideInitConfigurationForBridge","baseSerializedConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","telemetry_usage_sample_rate","use_before_send","use_partitioned_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_anonymous_user","session_persistence","allow_fallback_to_local_storage","store_contexts_across_pages","allow_untrusted_events","tracking_consent","session_replay_sample_rate","start_session_replay_recording_manually","trace_sample_rate","trace_context_injection","action_name_attribute","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","enable_privacy_for_action_name","use_excluded_activity_urls","use_worker_url","compress_intake_requests","track_views_manually","track_user_interactions","track_resources","track_long_task","getConfigurationTelemetry","track_feature_flags_for_events","serializeRumConfiguration","tryToInit","addDurationVital","remoteConfigurationId","REMOTE_CONFIGURATION","xhr","responseText","fetchRemoteConfiguration","remoteInitConfiguration","applyRemoteConfiguration","fetchAndApplyRemoteConfiguration","getInternalContext","stopSession","addTiming","startView","setViewName","setViewContext","setViewContextProperty","getViewContext","addAction","action","commonContext","addError","providedError","addFeatureFlagEvaluation","RUM_STORAGE_KEY","makeRumPublicApi","startRumImpl","recorderApi","customerDataTrackerManager","compressionStatus","customerDataTrackers","alreadyWarned","initialBytesCount","bytesCountLimit","tracker","displayCustomerDataLimitReachedWarning","createDetachedTracker","getOrCreateTracker","setCompressionStatus","newCompressionStatus","getCompressionStatus","clear","createCustomerDataTrackerManager","globalContextManager","userContextManager","currentConsent","update","createTrackingConsentState","hasReplay","isRecording","buildCommonContext","strategy","createDeflateEncoder","streamId","onRumStart","lifeCycle","viewHistory","preStartStrategy","createPostStartStrategy","sanitizedOptions","feature","rumPublicApi","m","setTrackingConsent","setGlobalContext","getGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","startTime","getInitConfiguration","setUser","isValid","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","clearUser","getSessionReplayLink","startSessionReplayRecording","force","stopSessionReplayRecording","getMutationObserverConstructor","MutationObserver","patchedInstance","originalInstance","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","current","fields","field","isValidObject","isValidObjectContaining","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","ROOT_MODIFIABLE_FIELD_PATHS","modifiableFieldPathsByEvent","startRumAssembly","urlContexts","actionContexts","displayContext","ciVisibilityContext","featureFlagContexts","WRITABLE_RESOURCE_GRAPHQL","eventRateLimiters","syntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsTestId","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","getSyntheticsContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewHistoryEntry","findView","urlContext","findUrl","actionId","findActionId","rumContext","drift","browser_sdk_version","application","referrer","feature_flags","findFeatureFlagsContext","synthetics","ci_test","serverRumEvent","has_replay","sampled_for_replay","sessionReplay","anonymous_id","usr","modifiableFieldPaths","modifier","fieldPath","fieldType","newValue","newType","limitModification","shouldSend","eventStartTime","isTrackingEnforced","isListedInConfig","featureFlagContext","findFeatureFlagEvaluations","LifeCycle","callbacks","eventCallbacks","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","createValueHistory","maxEntries","clearOldValuesInterval","oldTimeThreshold","endTime","clearOldValues","close","unshift","returnInactive","closeActive","latestEntry","findAll","reset","VIEW_CONTEXT_TIME_OUT_DELAY","xhrObservable","xhrContexts","openXhr","abortXhr","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","areInOrder","numbers","isResourceEntryRequestType","computeResourceEntryDuration","responseEnd","computeResourceEntryDetails","hasValidResourceEntryTimings","fetchStart","workerStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","first_byte","worker","connect","ssl","dns","redirect","hasValidResourceEntryDuration","areCommonTimingsInOrder","areRedirectionTimingsInOrder","hasRedirection","origin","computeResourceEntryProtocol","nextHopProtocol","computeResourceEntryDeliveryType","deliveryType","computeResourceEntrySize","encodedBodySize","decodedBodySize","transferSize","encoded_body_size","decoded_body_size","transfer_size","isAllowedRequestUrl","every","param","isIntakeUrl","DATA_URL_REGEX","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","isLongDataUrl","substring","sanitizeDataUrl","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","Headers","header","concat","traceXhr","startTracer","stopInstrumentingStart","stopInstrumentingSend","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","sendXhr","stopInstrumentingAbort","createXhrObservable","initXhrObservable","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer","chunk","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","discardNegativeDuration","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","RumPerformanceEntryType","createPerformanceObservable","PerformanceObserver","handlePerformanceEntries","rumPerformanceEntries","entryType","RESOURCE","isForbiddenResource","filterRumPerformanceEntries","isObserverInitializing","getEntries","observe","NAVIGATION","LONG_TASK","PAINT","buffered","getEntriesByType","entryTypes","stopFirstInputTiming","resourceTimingBufferFullListener","clearResourceTimings","manageResourceTimingBufferFull","supportPerformanceTimingEvent","FIRST_INPUT","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","processingEnd","sendTiming","sendTimingIfPointerIsNotCancelled","retrieveFirstInputTiming","disconnect","supportedEntryTypes","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","windowOpenObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","hasChildNodes","childNodes","forEachChildNodes","child","firstChild","nextSibling","getParentNode","parentNode","NodePrivacyLevel","IGNORE","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_PREFIX","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","cache","parentNodePrivacyLevel","nodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","inputElement","autocomplete","getAttribute","getPrivacySelector","element","nodeName","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","hasAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","censorText","text","getTextContent","textNode","ignoreWhiteSpace","parentTagName","parentElement","textContent","trim","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","ACTION_NAME_PLACEHOLDER","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","closest","truncate","normalizeWhitespace","priorityStrategies","userProgrammaticAttribute","labels","getActionNameFromTextualContent","nameSource","privacyEnabledActionName","getActionNameFromStandardAttribute","labelledByAttribute","refElement","ownerDocument","getElementById","label","getTextualContent","fallbackStrategies","MAX_PARENTS_TO_CONSIDER","getActionNameFromElementForStrategies","strategies","recursionCounter","actionName","trimmedName","attribute","isContentEditable","innerText","removeTextFromElements","query","querySelectorAll","textToReplace","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","CSS","escape","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","classList","className","getSelectorFromElement","isConnected","documentElement","contains","targetElementSelector","currentElement","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","childSelector","selectorGetter","elementSelector","currentElementSelector","isSiblingMatching","scopedSelector","supportScopeSelectorCache","querySelector","supportScopeSelector","parent","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","DEAD_CLICK_EXCLUDE_SELECTOR","isDead","click","hasPageActivity","getUserActivity","scroll","CLICK_ACTION_MAX_DURATION","interactionSelectorCache","updateInteractionSelector","relativeTimestamp","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","history","stopObservable","currentClickChain","stopClickChain","stopActionEventsListener","onPointerDown","onPointerUp","selectionEmptyAtPointerDown","clickContext","userActivity","listeners","localUserActivity","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","defaultActionName","getActionNameFromElement","width","height","position","x","clientX","left","y","clientY","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","viewEndedSubscription","endClocks","stopSubscription","startClickAction","tryAppend","rageClick","firstClick","onFinalize","bufferedClicks","maxDurationBetweenClicksTimeoutId","appendClick","tryFinalize","dontAcceptMoreClick","isStopped","second","sqrt","createClickChain","clicks","isRage","addFrustration","hasError","hasSelectionChanged","computeFrustration","validate","finalizeClicks","historyEntry","eventCountsSubscription","activityEndTime","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","events","processAction","pageStateHistory","autoActionProperties","isAutoAction","loading_time","long_task","resource","name_source","ACTION_NAME_MASKING","actionEvent","in_foreground","wasInPageStateAt","consoleObservablesByApi","RawReportType","intervention","deprecation","cspViolation","buildRawReportError","partial","buildStack","sourceFile","lineNumber","columnNumber","startErrorCollection","errorObservable","apis","consoleObservables","originalConsoleApi","params","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","initConsoleObservable","consoleLog","trackConsoleError","handleRuntimeError","rawError","stopInstrumentingOnError","errorObj","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","trackRuntimeError","blockedURI","effectiveDirective","csp","disposition","originalPolicy","buildRawReportErrorFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportErrorFromReport","types","createReportObservable","initReportObservable","trackReportError","processError","doStartErrorCollection","handling_stack","component_stack","source_type","IDLE_CALLBACK_TIMEOUT","MAX_EXECUTION_TIME_ON_TIMEOUT","alreadyMatchedEntries","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","traceIdMeta","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","getNavigationEntry","navigationEntry","timings","numberKey","timingElement","computeTimingsFromDeprecatedPerformanceTiming","retrieveInitialDocumentResourceTiming","startResourceCollection","taskQueue","pendingTasks","run","deadline","executionTimeRemaining","scheduleNextRun","timeout","task","createTaskQueue","retrieveInitialDocumentResourceTimingImpl","handleResource","matchingTiming","sameNameEntries","getEntriesByName","candidates","isBetween","matchRequestResourceEntry","tracingInfo","span_id","trace_id","rule_psr","computeRequestTracingInfo","correspondingTimingOverrides","computeResourceEntryMetrics","wasInPageStateDuringPeriod","computeRequestDuration","resourceEvent","status_code","delivery_type","performanceEntry","requestInput","requestInit","processRequest","performanceResourceSubscription","processResourceEntry","computeRawEvent","computeResourceEntryTracingInfo","isType","computeResourceEntryType","entryMetrics","statusCode","responseStatus","renderBlockingStatus","render_blocking_status","FCP_MAXIMUM_DELAY","LCP_MAXIMUM_DELAY","trackFirstHidden","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","getNavigationEntryImpl","stopOnReadyState","waitAfterLoadEvent","loadEventEnd","isIncompleteNavigation","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","processNavigationEntry","trackNavigationTimings","navigationTimings","firstHidden","stopFCPTracking","fcpEntry","firstContentfulPaint","trackFirstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","biggestLcpSize","performanceLcpSubscription","LARGEST_CONTENTFUL_PAINT","lcpEntry","lcpTargetSelector","largestContentfulPaint","targetSelector","trackLargestContentfulPaint","stopFIDTracking","performanceFirstInputSubscription","firstInputEntry","firstInputDelay","firstInputTargetSelector","firstInput","trackFirstInput","asRumRect","MAX_WINDOW_DURATION","MAX_UPDATE_GAP","isLayoutShiftSupported","LAYOUT_SHIFT","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","getInteractionCount","interactionCount","MAX_INTERACTION_ENTRIES","MAX_INP_VALUE","getScrollX","scrollX","visual","visualViewport","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","viewportObservable","initViewportObservable","updateDimension","getViewportDimension","createViewportObservable","scale","innerWidth","innerHeight","THROTTLE_SCROLL_DURATION","trackCommonViewMetrics","loadingType","viewStart","commonViewMetrics","stopLoadingTimeTracking","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","loadingTime","newLoadingTime","trackLoadingTime","stopScrollMetricsTracking","scrollValues","throttleDuration","ResizeObserver","throttledNotify","scrollTop","scrollHeight","scrollingElement","scrollDepth","computeScrollValues","observerTarget","resizeObserver","eventListener","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","maxDepth","maxDepthScrollTop","trackScrollMetrics","newScrollMetrics","stopCLSTracking","biggestShift","maxClsValue","cumulatedValue","maxValue","isMaxValue","slidingSessionWindow","performanceSubscription","hadRecentInput","attribution","WeakRef","previousRect","currentRect","deref","trackCumulativeLayoutShift","cumulativeLayoutShift","stopINPTracking","getInteractionToNextPaint","setViewEnd","viewLoadingType","EVENT","PerformanceEventTiming","getViewInteractionCount","stopViewInteractionCount","interactionId","durationThreshold","previousInteractionCount","computeViewInteractionCount","trackViewInteractionCount","viewEnd","longestInteractions","sortAndTrimLongestInteractions","sort","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaintTargetSelector","interactionToNextPaintStartTime","interactionToNextPaint","handleEntries","newInteraction","getInteractionSelector","firstInputSubscription","eventSubscription","viewEndTime","trackInteractionToNextPaint","getCommonViewMetrics","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","getPathFromHash","hash","startViewCollection","pageOpenObserable","locationChangeObservable","replayStats","getReplayStats","pageStates","viewEvent","document_version","documentVersion","replay_stats","page_states","cumulative_layout_shift","cumulative_layout_shift_time","cumulative_layout_shift_target_selector","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","first_input_target_selector","interaction_to_next_paint","interaction_to_next_paint_time","interaction_to_next_paint_target_selector","is_active","isActive","largest_contentful_paint","largest_contentful_paint_target_selector","load_event","loading_type","computeViewPerformanceData","time_spent","max_depth","max_depth_scroll_top","max_scroll_height","max_scroll_height_time","sessionIsActive","privacy","replay_level","customTimings","custom_timings","processViewUpdate","areViewsTrackedAutomatically","activeViews","locationChangeSubscription","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","viewCreatedEvent","cancelScheduleViewUpdate","triggerViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","stopEventCountsTracking","trackViewEventCounts","keepAliveIntervalId","currentEnd","sanitized","sanitizeTiming","updatedName","newView","pageExitEvent","oldLocation","newLocation","currentLocation","otherLocation","correspondingId","isHashAnAnchor","renewViewOnLocationChange","trackViews","cls","score","target_selector","previous_rect","current_rect","fcp","fid","inp","lcp","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","isReplayForced","forcedReplay","trackActivity","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","trackResume","findSession","isTypeTracked","rumSessionType","createBatch","encoder","flushController","upsertBuffer","flushSubscription","flushObservable","upsertMessages","isPageExit","encoderResult","formatPayloadFromEncoder","pendingMessages","flush","addOrUpdate","serializedMessage","estimatedMessageBytesCount","hasMessageFor","removedMessage","messageBytesCount","notifyAfterRemoveMessage","notifyBeforeAddMessage","notifyAfterAddMessage","realMessageBytesCount","upsert","createFlushController","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","pageExitSubscription","sessionExpireSubscription","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","flushReason","messagesCount","cancelDurationLimitTimeout","messageBytesCountDiff","startRumBatch","telemetryEventObservable","createEncoder","batch","primary","batchFactoryImp","primaryBatch","createBatchFromConfig","replicaBatch","endpoint","replicated","transformMessage","startBatchWithReplica","URL_CONTEXT_TIME_OUT_DELAY","getHistoryInstrumentationTarget","History","FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY","MEASURES_PERIOD_DURATION","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","MAX_PAGE_STATE_ENTRIES","MAX_PAGE_STATE_ENTRIES_SELECTABLE","PAGE_STATE_CONTEXT_TIME_OUT_DELAY","getPageState","hasFocus","WATCH_COOKIE_INTERVAL_DELAY","watchCookieFallback","cookieName","previousCookieValue","watchCookieIntervalId","cookieValue","CI_VISIBILITY_TEST_ID_COOKIE_NAME","startRum","cleanupTasks","startRumTelemetry","currentContext","startFeatureFlagContexts","setForcedReplay","startRumSessionManagerStub","rawTrackingType","hasValidRumSession","sessionEntity","startRumSessionManager","startRumEventBridge","batchFlushObservable","startCustomerDataTelemetry","attributes","characterData","childList","subtree","createDOMMutationObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","trackHistory","onLocationChange","stopHashTracking","onHashChange","trackHash","createLocationChangeObservable","maxPageStateEntriesSelectable","pageStateEntryHistory","currentPageState","addPageState","stopEventListeners","persisted","computePageState","nextPageState","pageStateEntries","pageStateServerEntries","pageState","relativeStartTime","startPageStateHistory","stopWindowOpen","createWindowOpenObservable","stopRumEventCollection","viewValueHistory","buildViewHistoryEntry","viewUpdate","startViewHistory","urlContextHistory","previousViewUrl","viewUrl","buildUrlContext","changeTime","startUrlContexts","actionCollection","startActionCollection","viewport","animationFrameId","requestAnimationFrame","unsubscribeViewport","viewportDimension","cancelAnimationFrame","startDisplayContext","cookieObservable","detectCookieChangeStrategy","changeEvent","changed","deleted","listenToCookieStoreChange","createCookieObservable","testExecutionId","Cypress","cookieObservableSubscription","test_execution_id","startCiVisibilityContext","startRumEventCollection","stopViewCollection","stopResourceCollection","LONG_ANIMATION_FRAME","stopLongAnimationFrameCollection","entry_type","blocking_duration","blockingDuration","first_ui_event_timestamp","firstUIEventTimestamp","render_start","renderStart","style_and_layout_start","styleAndLayoutStart","start_time","scripts","script","pause_duration","pauseDuration","forced_style_and_layout_duration","forcedStyleAndLayoutDuration","execution_start","executionStart","source_url","sourceURL","source_function_name","sourceFunctionName","source_char_position","sourceCharPosition","invoker","invoker_type","invokerType","window_attribution","windowAttribution","startLongAnimationFrameCollection","startLongTaskCollection","vitalCollection","computed_value","processVital","startVitalCollection","internalContext","viewContext","application_id","session_id","user_action","startInternalContext","getSessionReplayUrl","errorType","sessionId","rumConfiguration","getSiteDefaultSubdomain","getDatadogSiteUrl","MAX_STATS_HISTORY","statsPerView","getSegmentsCount","getOrCreateReplayStats","segments_count","addSegment","addRecord","records_count","addWroteData","additionalBytesCount","segments_total_raw_size","toDelete","deleteOldestStats","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","workerResponse","trailer","nextPendingAction","writeCallback","byteLength","finishCallback","consumeResult","sendResetIfNeeded","postMessage","pendingWriteAction","INITIALIZATION_TIME_OUT_DELAY","createDeflateWorker","Worker","createObjectURL","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener","onError","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","baseMessage","worker_version","stream_id","isBrowserSupported","CSSSupportsRule","NodeList","loadRecorder","getOrCreateDeflateEncoder","stopRecording","doStart","async","startRecordingImpl","all","deflateEncoder","canStartRecording","isRecordingInProgress","shouldForceReplay","isRecordingStarted","getErrorType","shouldStartImmediately","cachedDeflateEncoder","makeRecorderApi","startRecording","datadogRum"],"sourceRoot":""}