{"version":3,"file":"static/js/npm.datadog.6ffe2bd2.js","mappings":"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","sources":["webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/display.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/catchUserErrors.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/monitor.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/utils.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/boundedBuffer.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/timeUtils.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/browser/cookie.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/synthetics/syntheticsWorkerValues.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/transport/eventBridge.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/tracekit/computeStackTrace.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/error.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/experimentalFeatures.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/urlPolyfill.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/intakeSites.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/endpointBuilder.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/tags.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/configuration.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/configuration/transportConfiguration.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/observable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/telemetry/telemetry.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/browser/domMutationObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/resource/resourceUtils.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/getDocumentTraceId.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/browser/viewportObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/displayContext.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/browser/performanceCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/createEventRateLimiter.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/limitModification.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/assembly.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/syntheticsContext.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/ciTestContext.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/foregroundContexts.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/lifeCycle.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/browser/xhrObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/session/sessionConstants.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/contextHistory.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/viewContexts.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/instrumentMethod.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/browser/fetchObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/tracing/tracer.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/requestCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/trackEventCounts.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/waitPageActivityEnd.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/clickChain.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/getActionNameFromElement.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/browserDetection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/getSelectorFromElement.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/listenActionEvents.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/computeFrustration.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/trackClickActions.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/action/actionCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/tracekit/tracekit.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/console/consoleObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/report/reportObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/view/trackFirstHidden.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/error/errorCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/error/trackConsoleError.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/error/trackRuntimeError.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/error/trackReportError.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/resource/matchRequestTiming.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/resource/resourceCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/view/trackInitialViewTimings.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/view/trackViewMetrics.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/view/trackViews.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/view/viewCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/session/sessionCookieStore.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/session/oldCookiesMigration.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/session/sessionManager.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/domain/session/sessionStore.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumSessionManager.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/transport/batch.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/transport/httpRequest.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/urlContexts.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/types/sessionReplayConstants.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/constants.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/privacy.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/serializationUtils.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/utils.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/serialize.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/mutationBatch.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/mutationObserver.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/viewports.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/observer.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/replayStats.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/segmentCollection/segment.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/segmentCollection/deflateWorker.js","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/segmentCollection/segmentCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/segmentCollection/startDeflateWorker.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/transport/send.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/entries/main.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/boot/init.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/boot/recorderApi.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/boot/startRecording.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum/src/domain/record/record.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/boot/rumPublicApi.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-core/src/tools/contextManager.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/boot/startRum.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/transport/startRumEventBridge.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/transport/startRumBatch.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/browser/locationChangeObservable.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/rumEventsCollection/longTask/longTaskCollection.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/contexts/internalContext.ts","webpack://drbinaryweb/./node_modules/@datadog/browser-rum-core/src/domain/configuration.ts"],"sourcesContent":["/* eslint-disable no-console, 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  (api: ConsoleApiName, ...args: any[]): void\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\nexport const display: Display = (api, ...args) => {\n  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {\n    api = ConsoleApiName.log\n  }\n  display[api](...args)\n}\n\ndisplay.debug = console.debug.bind(console)\ndisplay.log = console.log.bind(console)\ndisplay.info = console.info.bind(console)\ndisplay.warn = console.warn.bind(console)\ndisplay.error = console.error.bind(console)\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","import { ConsoleApiName, 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    displayIfDebugEnabled(ConsoleApiName.error, e)\n    if (onMonitorErrorCollected) {\n      try {\n        onMonitorErrorCollected(e)\n      } catch (e) {\n        displayIfDebugEnabled(ConsoleApiName.error, e)\n      }\n    }\n  }\n}\n\nexport function displayIfDebugEnabled(api: ConsoleApiName, ...args: any[]) {\n  if (debugMode) {\n    display(api, '[MONITOR]', ...args)\n  }\n}\n","import { monitor } from './monitor'\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\nexport const ONE_KILO_BYTE = 1024\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  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}\n\nexport const enum ResourceType {\n  DOCUMENT = 'document',\n  XHR = 'xhr',\n  BEACON = 'beacon',\n  FETCH = 'fetch',\n  CSS = 'css',\n  JS = 'js',\n  IMAGE = 'image',\n  FONT = 'font',\n  MEDIA = 'media',\n  OTHER = 'other',\n}\n\nexport const enum RequestType {\n  FETCH = ResourceType.FETCH,\n  XHR = ResourceType.XHR,\n}\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\ninterface Assignable {\n  [key: string]: any\n}\n\nexport function assign<T, U>(target: T, source: U): T & U\nexport function assign<T, U, V>(target: T, source1: U, source2: V): T & U & V\nexport function assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W\nexport function assign(target: Assignable, ...toAssign: Assignable[]) {\n  toAssign.forEach((source: Assignable) => {\n    for (const key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key]\n      }\n    }\n  })\n  return target\n}\n\nexport function shallowClone<T>(object: T): T & Record<string, never> {\n  return assign({}, object)\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\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\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() {}\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\ninterface ObjectWithToJsonMethod {\n  toJSON: unknown\n}\nfunction 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\nexport function includes(candidate: string, search: string): boolean\nexport function includes<T>(candidate: T[], search: T): boolean\nexport function includes(candidate: string | unknown[], search: any) {\n  return candidate.indexOf(search) !== -1\n}\n\nexport function arrayFrom<T>(arrayLike: ArrayLike<T> | Set<T>): T[] {\n  if (Array.from) {\n    return Array.from(arrayLike)\n  }\n\n  const array = []\n\n  if (arrayLike instanceof Set) {\n    arrayLike.forEach((item) => array.push(item))\n  } else {\n    for (let i = 0; i < arrayLike.length; i++) {\n      array.push(arrayLike[i])\n    }\n  }\n\n  return array\n}\n\nexport function find<T, S extends T>(\n  array: ArrayLike<T>,\n  predicate: (item: T, index: number) => item is S\n): S | undefined\nexport function find<T>(array: ArrayLike<T>, predicate: (item: T, index: number) => boolean): T | undefined\nexport function find(\n  array: ArrayLike<unknown>,\n  predicate: (item: unknown, index: number) => boolean\n): unknown | undefined {\n  for (let i = 0; i < array.length; i += 1) {\n    const item = array[i]\n    if (predicate(item, i)) {\n      return item\n    }\n  }\n  return undefined\n}\n\nexport 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\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\nexport function objectValues<T = unknown>(object: { [key: string]: T }) {\n  return Object.keys(object).map((key) => object[key])\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 objectEntries(object: { [key: string]: unknown }): Array<[string, unknown]> {\n  return Object.keys(object).map((key) => [key, object[key]])\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\nexport function startsWith(candidate: string, search: string) {\n  return candidate.slice(0, search.length) === search\n}\n\nexport function endsWith(candidate: string, search: string) {\n  return candidate.slice(-search.length) === search\n}\n\n/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject<T>(): 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\nexport function getLocationOrigin() {\n  return getLinkElementOrigin(window.location)\n}\n\n/**\n * IE fallback\n * https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n */\nexport function getLinkElementOrigin(element: Location | HTMLAnchorElement | URL) {\n  if (element.origin) {\n    return element.origin\n  }\n  const sanitizedHost = element.host.replace(/(:80|:443)$/, '')\n  return `${element.protocol}//${sanitizedHost}`\n}\n\nexport function findCommaSeparatedValue(rawString: string, name: string) {\n  const regex = new RegExp(`(?:^|;)\\\\s*${name}\\\\s*=\\\\s*([^;]+)`)\n  const matches = regex.exec(rawString)\n  return matches ? matches[1] : undefined\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) return candidate\n\n  return `${candidate.slice(0, correctedLength)}${suffix}`\n}\n\nexport interface EventEmitter {\n  addEventListener(\n    event: DOM_EVENT,\n    listener: (event: Event) => void,\n    options?: boolean | { capture?: boolean; passive?: boolean }\n  ): void\n  removeEventListener(\n    event: DOM_EVENT,\n    listener: (event: Event) => void,\n    options?: boolean | { capture?: boolean; passive?: boolean }\n  ): void\n}\n\ninterface AddEventListenerOptions {\n  once?: boolean\n  capture?: boolean\n  passive?: boolean\n}\n\n/**\n * Add an event listener to an event emitter 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<E extends Event>(\n  emitter: EventEmitter,\n  event: DOM_EVENT,\n  listener: (event: E) => void,\n  options?: AddEventListenerOptions\n) {\n  return addEventListeners(emitter, [event], listener, options)\n}\n\n/**\n * Add event listeners to an event emitter 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<E extends Event>(\n  emitter: EventEmitter,\n  events: DOM_EVENT[],\n  listener: (event: E) => void,\n  { once, capture, passive }: { once?: boolean; capture?: boolean; passive?: boolean } = {}\n) {\n  const wrappedListener = monitor(\n    once\n      ? (event: Event) => {\n          stop()\n          listener(event as E)\n        }\n      : (listener as (event: Event) => void)\n  )\n\n  const options = passive ? { capture, passive } : capture\n  events.forEach((event) => emitter.addEventListener(event, wrappedListener, options))\n  const stop = () => events.forEach((event) => emitter.removeEventListener(event, wrappedListener, options))\n\n  return {\n    stop,\n  }\n}\n\nexport function elementMatches(element: Element & { msMatchesSelector?(selector: string): boolean }, selector: string) {\n  if (element.matches) {\n    return element.matches(selector)\n  }\n  // IE11 support\n  if (element.msMatchesSelector) {\n    return element.msMatchesSelector(selector)\n  }\n  return false\n}\n\nexport function runOnReadyState(expectedReadyState: 'complete' | 'interactive', callback: () => void) {\n  if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n    callback()\n  } else {\n    const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED\n    addEventListener(window, eventName, callback, { once: true })\n  }\n}\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\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\ninterface CircularReferenceChecker {\n  hasAlreadyBeenSeen(value: any): boolean\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\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: Record<any, any> = getType(destination) === 'object' ? destination : {}\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 dereferenced (\"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\nexport type TimeoutId = ReturnType<typeof setTimeout>\n\nexport function requestIdleCallback(callback: () => void, opts?: { timeout?: number }) {\n  // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the\n  // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the\n  // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any\n  // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes\n  // efficiently.\n  if (window.requestIdleCallback) {\n    const id = window.requestIdleCallback(monitor(callback), opts)\n    return () => window.cancelIdleCallback(id)\n  }\n  const id = window.requestAnimationFrame(monitor(callback))\n  return () => window.cancelAnimationFrame(id)\n}\n\nexport function removeDuplicates<T>(array: T[]) {\n  const set = new Set<T>()\n  array.forEach((item) => set.add(item))\n  return arrayFrom(set)\n}\n\nexport function matchList(list: Array<string | RegExp>, value: string) {\n  return list.some((item) => item === value || (item instanceof RegExp && item.test(value)))\n}\n\n// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str: string) {\n  if (window.CSS && window.CSS.escape) {\n    return window.CSS.escape(str)\n  }\n\n  // eslint-disable-next-line no-control-regex\n  return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n    if (asCodePoint) {\n      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n      if (ch === '\\0') {\n        return '\\uFFFD'\n      }\n      // Control characters and (dependent upon position) numbers get escaped as code points\n      return `${ch.slice(0, -1)}\\\\${ch.charCodeAt(ch.length - 1).toString(16)} `\n    }\n    // Other potentially-special ASCII characters get backslash-escaped\n    return `\\\\${ch}`\n  })\n}\n","const BUFFER_LIMIT = 500\n\nexport class BoundedBuffer {\n  private buffer: Array<() => void> = []\n\n  add(callback: () => void) {\n    const length = this.buffer.push(callback)\n    if (length > BUFFER_LIMIT) {\n      this.buffer.splice(0, 1)\n    }\n  }\n\n  drain() {\n    this.buffer.forEach((callback) => callback())\n    this.buffer.length = 0\n  }\n}\n","import { isNumber, ONE_YEAR, round } from './utils'\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\nfunction getCorrectedTimeStamp(relativeTime: RelativeTime) {\n  const correctedOrigin = dateNow() - performance.now()\n  // apply correction only for positive drift\n  if (correctedOrigin > getNavigationStart()) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return Math.round(correctedOrigin + relativeTime) as TimeStamp\n  }\n  return getTimeStamp(relativeTime)\n}\n\nexport function currentDrift() {\n  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n  return Math.round(dateNow() - (getNavigationStart() + performance.now()))\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\n/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\nexport function getRelativeTime(timestamp: TimeStamp) {\n  return (timestamp - getNavigationStart()) as RelativeTime\n}\n\nexport function getTimeStamp(relativeTime: RelativeTime) {\n  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n  return Math.round(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\nfunction getNavigationStart() {\n  if (navigationStart === undefined) {\n    navigationStart = performance.timing.navigationStart as TimeStamp\n  }\n  return navigationStart\n}\n\nexport function resetNavigationStart() {\n  navigationStart = undefined\n}\n","import { display } from '../tools/display'\nimport { findCommaSeparatedValue, generateUUID, ONE_SECOND } from '../tools/utils'\n\nexport const COOKIE_ACCESS_DELAY = ONE_SECOND\n\nexport interface CookieOptions {\n  secure?: boolean\n  crossSite?: boolean\n  domain?: string\n}\n\nexport function setCookie(name: string, value: string, expireDelay: number, 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  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}`\n}\n\nexport function getCookie(name: string) {\n  return findCommaSeparatedValue(document.cookie, name)\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_SECOND, 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 { getCookie } 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 || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)\n  )\n}\n\nexport function getSyntheticsTestId(): string | undefined {\n  const value = (window as BrowserWindow)._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)\n  return typeof value === 'string' ? value : undefined\n}\n\nexport function getSyntheticsResultId(): string | undefined {\n  const value = (window as BrowserWindow)._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)\n  return typeof value === 'string' ? value : undefined\n}\n","import { endsWith, getGlobalObject } from '../tools/utils'\n\nexport interface BrowserWindowWithEventBridge extends Window {\n  DatadogEventBridge?: DatadogEventBridge\n}\n\nexport interface DatadogEventBridge {\n  getAllowedWebViewHosts(): string\n  send(msg: string): void\n}\n\nexport function getEventBridge<T, E>() {\n  const eventBridgeGlobal = getEventBridgeGlobal()\n\n  if (!eventBridgeGlobal) {\n    return\n  }\n\n  return {\n    getAllowedWebViewHosts() {\n      return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts()) as string[]\n    },\n    send(eventType: T, event: E) {\n      eventBridgeGlobal.send(JSON.stringify({ eventType, event }))\n    },\n  }\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 || endsWith(currentHost, `.${allowedHost}`))\n  )\n}\n\nfunction getEventBridgeGlobal() {\n  return getGlobalObject<BrowserWindowWithEventBridge>().DatadogEventBridge\n}\n","import type { StackTrace, StackFrame } from './types'\n\nconst UNKNOWN_FUNCTION = '?'\n\n/**\n * Computes a stack trace for an exception.\n */\nexport function computeStackTrace(ex: unknown): StackTrace {\n  const stack: StackFrame[] = []\n\n  const stackProperty = tryToGetString(ex, 'stack')\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 = '((?:file|https?|blob|chrome-extension|native|eval|webpack|<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  // eslint-disable-next-line max-len\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","import type { StackTrace } from '../domain/tracekit'\nimport { computeStackTrace } from '../domain/tracekit'\nimport { callMonitored } from './monitor'\nimport type { ClocksState } from './timeUtils'\nimport { jsonStringify, noop } from './utils'\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}\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 ErrorHandling {\n  HANDLED = 'handled',\n  UNHANDLED = 'unhandled',\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport type ErrorSource = typeof ErrorSource[keyof typeof ErrorSource]\n\nexport function formatUnknownError(\n  stackTrace: StackTrace | undefined,\n  errorObject: any,\n  nonErrorPrefix: string,\n  handlingStack?: string\n) {\n  if (!stackTrace || (stackTrace.message === undefined && !(errorObject instanceof Error))) {\n    return {\n      message: `${nonErrorPrefix} ${jsonStringify(errorObject)!}`,\n      stack: 'No stack, consider using an instance of Error',\n      handlingStack,\n      type: stackTrace && stackTrace.name,\n    }\n  }\n\n  return {\n    message: stackTrace.message || 'Empty message',\n    stack: toStackTraceString(stackTrace),\n    handlingStack,\n    type: stackTrace.name,\n  }\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 getFileFromStackTraceString(stack: string) {\n  return /@ (.+)/.exec(stack)?.[1]\n}\n\nexport function formatErrorMessage(stack: StackTrace) {\n  return `${stack.name || 'Error'}: ${stack.message!}`\n}\n\n/**\n Creates a stacktrace without SDK internal frames.\n \n Constraints:\n - Has to be called at the utmost position of the call stack.\n - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack(): 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  // IE needs to throw the error to fill in the stack trace\n  if (!error.stack) {\n    try {\n      throw error\n    } catch (e) {\n      noop()\n    }\n  }\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","/**\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\nlet enabledExperimentalFeatures: Set<string> | undefined\n\nexport function updateExperimentalFeatures(enabledFeatures: string[] | undefined): void {\n  // Safely handle external data\n  if (!Array.isArray(enabledFeatures)) {\n    return\n  }\n\n  if (!enabledExperimentalFeatures) {\n    enabledExperimentalFeatures = new Set(enabledFeatures)\n  }\n\n  enabledFeatures\n    .filter((flag) => typeof flag === 'string')\n    .forEach((flag: string) => {\n      enabledExperimentalFeatures!.add(flag)\n    })\n}\n\nexport function isExperimentalFeatureEnabled(featureName: string): boolean {\n  return !!enabledExperimentalFeatures && enabledExperimentalFeatures.has(featureName)\n}\n\nexport function resetExperimentalFeatures(): void {\n  enabledExperimentalFeatures = new Set()\n}\n\nexport function getExperimentalFeatures(): Set<string> {\n  return enabledExperimentalFeatures || new Set()\n}\n","import { getLinkElementOrigin, getLocationOrigin } from './utils'\n\nexport function normalizeUrl(url: string) {\n  return buildUrl(url, getLocationOrigin()).href\n}\n\nexport function isValidUrl(url: string) {\n  try {\n    return !!buildUrl(url)\n  } catch {\n    return false\n  }\n}\n\nexport function haveSameOrigin(url1: string, url2: string) {\n  return getOrigin(url1) === getOrigin(url2)\n}\n\nexport function getOrigin(url: string) {\n  return getLinkElementOrigin(buildUrl(url))\n}\n\nexport function getPathName(url: string) {\n  const pathname = buildUrl(url).pathname\n  return pathname[0] === '/' ? pathname : `/${pathname}`\n}\n\nexport function getSearch(url: string) {\n  return buildUrl(url).search\n}\n\nexport function getHash(url: string) {\n  return buildUrl(url).hash\n}\n\nexport function buildUrl(url: string, base?: string) {\n  if (checkURLSupported()) {\n    return base !== undefined ? new URL(url, base) : new URL(url)\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\nlet isURLSupported: boolean | undefined\nfunction checkURLSupported() {\n  if (isURLSupported !== undefined) {\n    return isURLSupported\n  }\n  try {\n    const url = new URL('http://test/path')\n    isURLSupported = url.href === 'http://test/path'\n    return isURLSupported\n  } catch {\n    isURLSupported = false\n  }\n  return isURLSupported\n}\n","export const INTAKE_SITE_STAGING = 'datad0g.com'\nexport const INTAKE_SITE_US1 = 'datadoghq.com'\nexport const INTAKE_SITE_US1_FED = 'ddog-gov.com'\n","import { timeStampNow } from '../../tools/timeUtils'\nimport { normalizeUrl } from '../../tools/urlPolyfill'\nimport { generateUUID } from '../../tools/utils'\nimport type { InitConfiguration } from './configuration'\nimport { INTAKE_SITE_US1 } from './intakeSites'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nexport const ENDPOINTS = {\n  logs: 'logs',\n  rum: 'rum',\n  sessionReplay: 'session-replay',\n} as const\n\nconst INTAKE_TRACKS = {\n  logs: 'logs',\n  rum: 'rum',\n  sessionReplay: 'replay',\n}\n\ntype EndpointType = keyof typeof ENDPOINTS\n\nexport type EndpointBuilder = ReturnType<typeof createEndpointBuilder>\n\nexport function createEndpointBuilder(\n  initConfiguration: InitConfiguration,\n  endpointType: EndpointType,\n  tags: string[]\n) {\n  const { site = INTAKE_SITE_US1, clientToken } = initConfiguration\n\n  const domainParts = site.split('.')\n  const extension = domainParts.pop()\n  const host = `${ENDPOINTS[endpointType]}.browser-intake-${domainParts.join('-')}.${extension!}`\n  const baseUrl = `https://${host}/api/v2/${INTAKE_TRACKS[endpointType]}`\n  const proxyUrl = initConfiguration.proxyUrl && normalizeUrl(initConfiguration.proxyUrl)\n\n  return {\n    build() {\n      let parameters =\n        'ddsource=browser' +\n        `&ddtags=${encodeURIComponent([`sdk_version:${__BUILD_ENV__SDK_VERSION__}`].concat(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      if (endpointType === 'rum') {\n        parameters += `&batch_time=${timeStampNow()}`\n      }\n      const endpointUrl = `${baseUrl}?${parameters}`\n\n      return proxyUrl ? `${proxyUrl}?ddforward=${encodeURIComponent(endpointUrl)}` : endpointUrl\n    },\n    buildIntakeUrl() {\n      return proxyUrl ? `${proxyUrl}?ddforward` : baseUrl\n    },\n    endpointType,\n  }\n}\n","import { 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\nconst FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/\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 || FORBIDDEN_CHARACTERS.test(rawValue)) {\n    display.warn(`${key} value doesn't meet tag requirements and will be sanitized`)\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","import type { CookieOptions } from '../../browser/cookie'\nimport { getCurrentSite } from '../../browser/cookie'\nimport { catchUserErrors } from '../../tools/catchUserErrors'\nimport { display } from '../../tools/display'\nimport { assign, isPercentage, ONE_KILO_BYTE, ONE_SECOND } from '../../tools/utils'\nimport { updateExperimentalFeatures } from './experimentalFeatures'\nimport type { TransportConfiguration } from './transportConfiguration'\nimport { computeTransportConfiguration } from './transportConfiguration'\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 interface InitConfiguration {\n  // global options\n  clientToken: string\n  beforeSend?: GenericBeforeSendCallback | undefined\n  sampleRate?: number | undefined\n  telemetrySampleRate?: number | undefined\n  silentMultipleInit?: boolean | undefined\n\n  // transport options\n  proxyUrl?: string | undefined\n  site?: string | undefined\n\n  // tag and context options\n  service?: string | undefined\n  env?: string | undefined\n  version?: string | undefined\n\n  // cookie options\n  useCrossSiteSessionCookie?: boolean | undefined\n  useSecureSessionCookie?: boolean | undefined\n  trackSessionAcrossSubdomains?: boolean | undefined\n\n  // internal options\n  enableExperimentalFeatures?: string[] | undefined\n  replica?: ReplicaUserConfiguration | undefined\n  datacenter?: string\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\ninterface ReplicaUserConfiguration {\n  applicationId?: string\n  clientToken: string\n}\n\nexport interface Configuration extends TransportConfiguration {\n  // Built from init configuration\n  beforeSend: GenericBeforeSendCallback | undefined\n  cookieOptions: CookieOptions\n  sampleRate: number\n  telemetrySampleRate: number\n  service: string | undefined\n  silentMultipleInit: 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: number\n  batchMessagesLimit: number\n  messageBytesLimit: number\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 (initConfiguration.sampleRate !== undefined && !isPercentage(initConfiguration.sampleRate)) {\n    display.error('Sample Rate should be a number between 0 and 100')\n    return\n  }\n\n  if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n    display.error('Telemetry Sample Rate should be a number between 0 and 100')\n    return\n  }\n\n  // Set the experimental feature flags as early as possible, so we can use them in most places\n  updateExperimentalFeatures(initConfiguration.enableExperimentalFeatures)\n\n  return assign(\n    {\n      beforeSend:\n        initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n      cookieOptions: buildCookieOptions(initConfiguration),\n      sampleRate: initConfiguration.sampleRate ?? 100,\n      telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,\n      service: initConfiguration.service,\n      silentMultipleInit: !!initConfiguration.silentMultipleInit,\n\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_KILO_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,\n\n      /**\n       * Logs intake limit\n       */\n      batchMessagesLimit: 50,\n      messageBytesLimit: 256 * ONE_KILO_BYTE,\n    },\n    computeTransportConfiguration(initConfiguration)\n  )\n}\n\nexport function buildCookieOptions(initConfiguration: InitConfiguration) {\n  const cookieOptions: CookieOptions = {}\n\n  cookieOptions.secure = mustUseSecureCookie(initConfiguration)\n  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie\n\n  if (initConfiguration.trackSessionAcrossSubdomains) {\n    cookieOptions.domain = getCurrentSite()\n  }\n\n  return cookieOptions\n}\n\nfunction mustUseSecureCookie(initConfiguration: InitConfiguration) {\n  return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie\n}\n","import { assign, objectValues } from '../../tools/utils'\nimport type { InitConfiguration } from './configuration'\nimport type { EndpointBuilder } from './endpointBuilder'\nimport { createEndpointBuilder } from './endpointBuilder'\nimport { buildTags } from './tags'\nimport { INTAKE_SITE_US1 } from './intakeSites'\n\nexport interface TransportConfiguration {\n  logsEndpointBuilder: EndpointBuilder\n  rumEndpointBuilder: EndpointBuilder\n  sessionReplayEndpointBuilder: EndpointBuilder\n  isIntakeUrl: (url: string) => boolean\n  replica?: ReplicaConfiguration\n  site: string\n}\n\nexport interface ReplicaConfiguration {\n  applicationId?: string\n  logsEndpointBuilder: EndpointBuilder\n  rumEndpointBuilder: EndpointBuilder\n}\n\nexport function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {\n  const tags = buildTags(initConfiguration)\n\n  const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)\n  const intakeEndpoints = objectValues(endpointBuilders).map((builder) => builder.buildIntakeUrl())\n\n  const replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags)\n\n  return assign(\n    {\n      isIntakeUrl: (url: string) => intakeEndpoints.some((intakeEndpoint) => url.indexOf(intakeEndpoint) === 0),\n      replica: replicaConfiguration,\n      site: initConfiguration.site || INTAKE_SITE_US1,\n    },\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, 'sessionReplay', tags),\n  }\n}\n\nfunction computeReplicaConfiguration(\n  initConfiguration: InitConfiguration,\n  intakeEndpoints: string[],\n  tags: string[]\n): ReplicaConfiguration | undefined {\n  if (!initConfiguration.replica) {\n    return\n  }\n\n  const replicaConfiguration: InitConfiguration = assign({}, 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  intakeEndpoints.push(...objectValues(replicaEndpointBuilders).map((builder) => builder.buildIntakeUrl()))\n\n  return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders)\n}\n","export interface Subscription {\n  unsubscribe: () => void\n}\n\nexport class Observable<T> {\n  private observers: Array<(data: T) => void> = []\n  private onLastUnsubscribe?: () => void\n\n  constructor(private onFirstSubscribe?: () => (() => void) | void) {}\n\n  subscribe(f: (data: T) => void): Subscription {\n    if (!this.observers.length && this.onFirstSubscribe) {\n      this.onLastUnsubscribe = this.onFirstSubscribe() || undefined\n    }\n    this.observers.push(f)\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  const globalObservable = new Observable<T>(() => {\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  return globalObservable\n}\n","import type { Context } from '../../tools/context'\nimport { ConsoleApiName } from '../../tools/display'\nimport { toStackTraceString } from '../../tools/error'\nimport { assign, combine, jsonStringify, performDraw, includes, startsWith, arrayFrom } from '../../tools/utils'\nimport type { Configuration } from '../configuration'\nimport { getExperimentalFeatures, INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration'\nimport type { StackTrace } from '../tracekit'\nimport { computeStackTrace } from '../tracekit'\nimport { Observable } from '../../tools/observable'\nimport { timeStampNow } from '../../tools/timeUtils'\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'\nimport type { TelemetryEvent } from './telemetryEvent.types'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nconst enum StatusType {\n  debug = 'debug',\n  error = 'error',\n}\n\nconst ALLOWED_FRAME_URLS = [\n  'https://www.datadoghq-browser-agent.com',\n  'https://www.datad0g-browser-agent.com',\n  'http://localhost',\n  '<anonymous>',\n]\n\nexport interface Telemetry {\n  setContextProvider: (provider: () => Context) => void\n  observable: Observable<TelemetryEvent & Context>\n}\n\nexport interface RawTelemetryEvent extends Context {\n  message: string\n  status: StatusType\n  error?: {\n    kind?: string\n    stack: string\n  }\n}\n\nconst TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED]\n\nconst telemetryConfiguration: {\n  maxEventsPerPage: number\n  sentEventCount: number\n  telemetryEnabled: boolean\n} = { maxEventsPerPage: 0, sentEventCount: 0, telemetryEnabled: false }\n\nlet onRawTelemetryEventCollected: ((event: RawTelemetryEvent) => void) | undefined\n\nexport function startTelemetry(configuration: Configuration): Telemetry {\n  let contextProvider: () => Context\n  const observable = new Observable<TelemetryEvent & Context>()\n\n  telemetryConfiguration.telemetryEnabled = performDraw(configuration.telemetrySampleRate)\n\n  onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {\n    if (!includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && telemetryConfiguration.telemetryEnabled) {\n      observable.notify(toTelemetryEvent(event))\n    }\n  }\n  startMonitorErrorCollection(addTelemetryError)\n\n  assign(telemetryConfiguration, {\n    maxEventsPerPage: configuration.maxTelemetryEventsPerPage,\n    sentEventCount: 0,\n  })\n\n  function toTelemetryEvent(event: RawTelemetryEvent): TelemetryEvent & Context {\n    return combine(\n      {\n        type: 'telemetry' as const,\n        date: timeStampNow(),\n        service: 'browser-sdk',\n        version: __BUILD_ENV__SDK_VERSION__,\n        source: 'browser' as const,\n        _dd: {\n          format_version: 2 as const,\n        },\n        telemetry: event as any, // https://github.com/microsoft/TypeScript/issues/48457\n        experimental_features: arrayFrom(getExperimentalFeatures()),\n      },\n      contextProvider !== undefined ? contextProvider() : {}\n    )\n  }\n\n  return {\n    setContextProvider: (provider: () => Context) => {\n      contextProvider = provider\n    },\n    observable,\n  }\n}\n\nexport function startFakeTelemetry() {\n  const events: RawTelemetryEvent[] = []\n  assign(telemetryConfiguration, {\n    maxEventsPerPage: Infinity,\n    sentEventCount: 0,\n  })\n\n  onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {\n    events.push(event)\n  }\n\n  return events\n}\n\nexport function resetTelemetry() {\n  onRawTelemetryEventCollected = undefined\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  addTelemetry(\n    assign(\n      {\n        message,\n        status: StatusType.debug,\n      },\n      context\n    )\n  )\n}\n\nexport function addTelemetryError(e: unknown) {\n  addTelemetry(\n    assign(\n      {\n        status: StatusType.error,\n      },\n      formatError(e)\n    )\n  )\n}\n\nfunction addTelemetry(event: RawTelemetryEvent) {\n  if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {\n    telemetryConfiguration.sentEventCount += 1\n    onRawTelemetryEventCollected(event)\n  }\n}\n\nexport function formatError(e: unknown) {\n  if (e instanceof Error) {\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: 'Not an instance of error',\n    },\n    message: `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) => startsWith(frame.url!, allowedFrameUrl))\n  )\n  return stackTrace\n}\n","import { monitor, noop, Observable } from '@datadog/browser-core'\n\nexport function createDOMMutationObservable() {\n  const MutationObserver = getMutationObserverConstructor()\n\n  const observable: Observable<void> = new Observable<void>(() => {\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  return observable\n}\n\ntype MutationObserverConstructor = new (callback: MutationCallback) => MutationObserver\nexport interface BrowserWindow extends Window {\n  MutationObserver?: MutationObserverConstructor\n  Zone?: {\n    __symbol__: (name: string) => string\n  }\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    const zoneSymbol = browserWindow.Zone.__symbol__\n\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 = browserWindow[zoneSymbol('MutationObserver') as any] as unknown as\n      | MutationObserverConstructor\n      | undefined\n\n    if (!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 any\n      const originalInstance = patchedInstance[zoneSymbol('originalInstance')] as\n        | { constructor: MutationObserverConstructor }\n        | undefined\n\n      constructor = originalInstance && originalInstance.constructor\n    }\n  }\n\n  if (!constructor) {\n    constructor = browserWindow.MutationObserver\n  }\n\n  return constructor\n}\n","import type { RelativeTime, ServerDuration } from '@datadog/browser-core'\nimport {\n  assign,\n  addTelemetryDebug,\n  elapsed,\n  getPathName,\n  includes,\n  isValidUrl,\n  ResourceType,\n  toServerDuration,\n} from '@datadog/browser-core'\n\nimport type { RumPerformanceResourceTiming } from '../../../browser/performanceCollection'\n\nimport type { PerformanceResourceDetailsElement } from '../../../rawRumEvent.types'\nimport type { RumConfiguration } from '../../configuration'\n\nexport interface PerformanceResourceDetails {\n  redirect?: PerformanceResourceDetailsElement\n  dns?: PerformanceResourceDetailsElement\n  connect?: PerformanceResourceDetailsElement\n  ssl?: PerformanceResourceDetailsElement\n  // eslint-disable-next-line camelcase\n  first_byte: PerformanceResourceDetailsElement\n  download: PerformanceResourceDetailsElement\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      includes(['image', 'img', 'icon'], 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      includes(['audio', 'video'], initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null,\n  ],\n]\n\nexport function computeResourceKind(timing: RumPerformanceResourceTiming) {\n  const url = timing.name\n  if (!isValidUrl(url)) {\n    addTelemetryDebug(`Failed to construct URL for \"${timing.name}\"`)\n    return ResourceType.OTHER\n  }\n  const path = getPathName(url)\n  for (const [type, isType] of RESOURCE_TYPES) {\n    if (isType(timing.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 isRequestKind(timing: RumPerformanceResourceTiming) {\n  return timing.initiatorType === 'xmlhttprequest' || timing.initiatorType === 'fetch'\n}\n\nexport function computePerformanceResourceDuration(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 computePerformanceResourceDetails(\n  entry: RumPerformanceResourceTiming\n): PerformanceResourceDetails | undefined {\n  const validEntry = toValidEntry(entry)\n\n  if (!validEntry) {\n    return undefined\n  }\n  const {\n    startTime,\n    fetchStart,\n    redirectStart,\n    redirectEnd,\n    domainLookupStart,\n    domainLookupEnd,\n    connectStart,\n    secureConnectionStart,\n    connectEnd,\n    requestStart,\n    responseStart,\n    responseEnd,\n  } = validEntry\n\n  const details: PerformanceResourceDetails = {\n    download: formatTiming(startTime, responseStart, responseEnd),\n    first_byte: formatTiming(startTime, requestStart, responseStart),\n  }\n\n  // Make sure a connection occurred\n  if (connectEnd !== fetchStart) {\n    details.connect = formatTiming(startTime, connectStart, connectEnd)\n\n    // Make sure a secure connection occurred\n    if (areInOrder(connectStart, secureConnectionStart, connectEnd)) {\n      details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd)\n    }\n  }\n\n  // Make sure a domain lookup occurred\n  if (domainLookupEnd !== fetchStart) {\n    details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd)\n  }\n\n  if (hasRedirection(entry)) {\n    details.redirect = formatTiming(startTime, redirectStart, redirectEnd)\n  }\n\n  return details\n}\n\nexport function toValidEntry(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  if (\n    !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    return undefined\n  }\n\n  if (!hasRedirection(entry)) {\n    return entry\n  }\n\n  let { redirectStart, redirectEnd } = entry\n  // Firefox doesn't provide redirect timings on cross origin requests.\n  // Provide a default for those.\n  if (redirectStart < entry.startTime) {\n    redirectStart = entry.startTime\n  }\n  if (redirectEnd < entry.startTime) {\n    redirectEnd = entry.fetchStart\n  }\n\n  // Make sure redirect timings are in order\n  if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {\n    return undefined\n  }\n\n  return assign({}, entry, {\n    redirectEnd,\n    redirectStart,\n  })\n}\n\nfunction hasRedirection(entry: RumPerformanceResourceTiming) {\n  // The only time fetchStart is different than startTime is if a redirection occurred.\n  return entry.fetchStart !== entry.startTime\n}\n\nfunction formatTiming(origin: RelativeTime, start: RelativeTime, end: RelativeTime) {\n  return {\n    duration: toServerDuration(elapsed(start, end)),\n    start: toServerDuration(elapsed(origin, start)),\n  }\n}\n\nexport function computeSize(entry: RumPerformanceResourceTiming) {\n  // Make sure a request actually occurred\n  if (entry.startTime < entry.responseStart) {\n    return entry.decodedBodySize\n  }\n  return undefined\n}\n\nexport function isAllowedRequestUrl(configuration: RumConfiguration, url: string) {\n  return url && !configuration.isIntakeUrl(url)\n}\n","import type { TimeStamp } from '@datadog/browser-core'\nimport { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core'\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  // eslint-disable-next-line @typescript-eslint/prefer-for-of\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\nfunction isCommentNode(node: Node): node is Comment {\n  return node.nodeName === '#comment'\n}\n\nfunction isTextNode(node: Node): node is Text {\n  return node.nodeName === '#text'\n}\n","import { monitor, Observable, throttle, addEventListener, DOM_EVENT } from '@datadog/browser-core'\n\nexport interface ViewportDimension {\n  height: number\n  width: number\n}\n\nlet viewportObservable: Observable<ViewportDimension> | undefined\n\nexport function initViewportObservable() {\n  if (!viewportObservable) {\n    viewportObservable = createViewportObservable()\n  }\n  return viewportObservable\n}\n\nexport function createViewportObservable() {\n  const observable = new Observable<ViewportDimension>(() => {\n    const { throttled: updateDimension } = throttle(\n      monitor(() => {\n        observable.notify(getViewportDimension())\n      }),\n      200\n    )\n\n    return addEventListener(window, DOM_EVENT.RESIZE, updateDimension, { capture: true, passive: true }).stop\n  })\n\n  return observable\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 { isExperimentalFeatureEnabled } from '@datadog/browser-core'\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable'\n\nlet viewport: { width: number; height: number } | undefined\nlet stopListeners: (() => void) | undefined\n\nexport function getDisplayContext() {\n  if (!isExperimentalFeatureEnabled('clickmap')) return\n\n  if (!viewport) {\n    viewport = getViewportDimension()\n    stopListeners = initViewportObservable().subscribe((viewportDimension) => {\n      viewport = viewportDimension\n    }).unsubscribe\n  }\n\n  return {\n    viewport,\n  }\n}\n\nexport function resetDisplayContext() {\n  if (stopListeners) stopListeners()\n  viewport = undefined\n}\n","import type { Duration, RelativeTime, TimeStamp } from '@datadog/browser-core'\nimport {\n  dateNow,\n  assign,\n  addEventListeners,\n  DOM_EVENT,\n  getRelativeTime,\n  isNumber,\n  monitor,\n  relativeNow,\n  runOnReadyState,\n} from '@datadog/browser-core'\n\nimport type { RumConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/rumEventsCollection/resource/resourceUtils'\n\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId'\nimport type { PerformanceEntryRepresentation } from '../domainContext.types'\n\nexport interface RumPerformanceResourceTiming {\n  entryType: 'resource'\n  initiatorType: string\n  name: string\n  startTime: RelativeTime\n  duration: Duration\n  fetchStart: 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  traceId?: string\n}\n\nexport interface RumPerformanceLongTaskTiming {\n  entryType: 'longtask'\n  startTime: RelativeTime\n  duration: Duration\n  toJSON(): PerformanceEntryRepresentation\n}\n\nexport interface RumPerformancePaintTiming {\n  entryType: 'paint'\n  name: 'first-paint' | 'first-contentful-paint'\n  startTime: RelativeTime\n}\n\nexport interface RumPerformanceNavigationTiming {\n  entryType: 'navigation'\n  domComplete: RelativeTime\n  domContentLoadedEventEnd: RelativeTime\n  domInteractive: RelativeTime\n  loadEventEnd: RelativeTime\n}\n\nexport interface RumLargestContentfulPaintTiming {\n  entryType: 'largest-contentful-paint'\n  startTime: RelativeTime\n  size: number\n}\n\nexport interface RumFirstInputTiming {\n  entryType: 'first-input'\n  startTime: RelativeTime\n  processingStart: RelativeTime\n}\n\nexport interface RumLayoutShiftTiming {\n  entryType: 'layout-shift'\n  startTime: RelativeTime\n  value: number\n  hadRecentInput: boolean\n}\n\nexport type RumPerformanceEntry =\n  | RumPerformanceResourceTiming\n  | RumPerformanceLongTaskTiming\n  | RumPerformancePaintTiming\n  | RumPerformanceNavigationTiming\n  | RumLargestContentfulPaintTiming\n  | RumFirstInputTiming\n  | RumLayoutShiftTiming\n\nfunction supportPerformanceObject() {\n  return window.performance !== undefined && 'getEntries' in performance\n}\n\nexport function supportPerformanceTimingEvent(entryType: string) {\n  return (\n    window.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes !== undefined &&\n    PerformanceObserver.supportedEntryTypes.includes(entryType)\n  )\n}\n\nexport function supportPerformanceEntry() {\n  // Safari 10 doesn't support PerformanceEntry\n  return typeof PerformanceEntry === 'function'\n}\n\nexport function startPerformanceCollection(lifeCycle: LifeCycle, configuration: RumConfiguration) {\n  retrieveInitialDocumentResourceTiming((timing) => {\n    handleRumPerformanceEntries(lifeCycle, configuration, [timing])\n  })\n\n  if (supportPerformanceObject()) {\n    const performanceEntries = performance.getEntries()\n    // Because the performance entry list can be quite large\n    // delay the computation to prevent the SDK from blocking the main thread on init\n    setTimeout(monitor(() => handleRumPerformanceEntries(lifeCycle, configuration, performanceEntries)))\n  }\n\n  if (window.PerformanceObserver) {\n    const handlePerformanceEntryList = monitor((entries: PerformanceObserverEntryList) =>\n      handleRumPerformanceEntries(lifeCycle, configuration, entries.getEntries())\n    )\n    const mainEntries = ['resource', 'navigation', 'longtask', 'paint']\n    const experimentalEntries = ['largest-contentful-paint', 'first-input', 'layout-shift']\n\n    try {\n      // Experimental entries are not retrieved by performance.getEntries()\n      // use a single PerformanceObserver with buffered flag by type\n      // to get values that could happen before SDK init\n      experimentalEntries.forEach((type) => {\n        const observer = new PerformanceObserver(handlePerformanceEntryList)\n        observer.observe({ type, buffered: true })\n      })\n    } catch (e) {\n      // Some old browser versions (ex: chrome 67) don't support the PerformanceObserver type and buffered options\n      // In these cases, fallback to PerformanceObserver with entryTypes\n      mainEntries.push(...experimentalEntries)\n    }\n\n    const mainObserver = new PerformanceObserver(handlePerformanceEntryList)\n    mainObserver.observe({ entryTypes: mainEntries })\n\n    if (supportPerformanceObject() && 'addEventListener' in performance) {\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n      performance.addEventListener('resourcetimingbufferfull', () => {\n        performance.clearResourceTimings()\n      })\n    }\n  }\n  if (!supportPerformanceTimingEvent('navigation')) {\n    retrieveNavigationTiming((timing) => {\n      handleRumPerformanceEntries(lifeCycle, configuration, [timing])\n    })\n  }\n  if (!supportPerformanceTimingEvent('first-input')) {\n    retrieveFirstInputTiming((timing) => {\n      handleRumPerformanceEntries(lifeCycle, configuration, [timing])\n    })\n  }\n}\n\nexport function retrieveInitialDocumentResourceTiming(callback: (timing: RumPerformanceResourceTiming) => void) {\n  runOnReadyState('interactive', () => {\n    let timing: RumPerformanceResourceTiming\n\n    const forcedAttributes = {\n      entryType: 'resource' as const,\n      initiatorType: FAKE_INITIAL_DOCUMENT,\n      traceId: getDocumentTraceId(document),\n    }\n    if (supportPerformanceTimingEvent('navigation') && performance.getEntriesByType('navigation').length > 0) {\n      const navigationEntry = performance.getEntriesByType('navigation')[0]\n      timing = assign(navigationEntry.toJSON(), forcedAttributes)\n    } else {\n      const relativePerformanceTiming = computeRelativePerformanceTiming()\n      timing = assign(\n        relativePerformanceTiming,\n        {\n          decodedBodySize: 0,\n          duration: relativePerformanceTiming.responseEnd,\n          name: window.location.href,\n          startTime: 0 as RelativeTime,\n        },\n        forcedAttributes\n      )\n    }\n    callback(timing)\n  })\n}\n\nfunction retrieveNavigationTiming(callback: (timing: RumPerformanceNavigationTiming) => void) {\n  function sendFakeTiming() {\n    callback(\n      assign(computeRelativePerformanceTiming(), {\n        entryType: 'navigation' as const,\n      })\n    )\n  }\n\n  runOnReadyState('complete', () => {\n    // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n    setTimeout(monitor(sendFakeTiming))\n  })\n}\n\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nfunction retrieveFirstInputTiming(callback: (timing: RumFirstInputTiming) => void) {\n  const startTimeStamp = dateNow()\n  let timingSent = false\n\n  const { stop: removeEventListeners } = addEventListeners(\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: RumFirstInputTiming = {\n        entryType: 'first-input',\n        processingStart: relativeNow(),\n        startTime: evt.timeStamp as RelativeTime,\n      }\n\n      if (evt.type === DOM_EVENT.POINTER_DOWN) {\n        sendTimingIfPointerIsNotCancelled(timing)\n      } else {\n        sendTiming(timing)\n      }\n    },\n    { passive: true, capture: true }\n  )\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(timing: RumFirstInputTiming) {\n    addEventListeners(\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: RumFirstInputTiming) {\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\nexport type RelativePerformanceTiming = {\n  -readonly [key in keyof Omit<PerformanceTiming, 'toJSON'>]: RelativeTime\n}\n\nfunction computeRelativePerformanceTiming() {\n  const result: Partial<RelativePerformanceTiming> = {}\n  const timing = performance.timing\n  for (const key in timing) {\n    if (isNumber(timing[key as keyof PerformanceTiming])) {\n      const numberKey = key as keyof RelativePerformanceTiming\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n      const timingElement = timing[numberKey] as TimeStamp\n      result[numberKey] = timingElement === 0 ? (0 as RelativeTime) : getRelativeTime(timingElement)\n    }\n  }\n  return result as RelativePerformanceTiming\n}\n\nfunction handleRumPerformanceEntries(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  entries: Array<PerformanceEntry | RumPerformanceEntry>\n) {\n  const rumPerformanceEntries = entries.filter(\n    (entry) =>\n      entry.entryType === 'resource' ||\n      entry.entryType === 'navigation' ||\n      entry.entryType === 'paint' ||\n      entry.entryType === 'longtask' ||\n      entry.entryType === 'largest-contentful-paint' ||\n      entry.entryType === 'first-input' ||\n      entry.entryType === 'layout-shift'\n  ) as RumPerformanceEntry[]\n\n  const rumAllowedPerformanceEntries = rumPerformanceEntries.filter(\n    (entry) => !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry)\n  )\n\n  if (rumAllowedPerformanceEntries.length) {\n    lifeCycle.notify(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, rumAllowedPerformanceEntries)\n  }\n}\n\nfunction isIncompleteNavigation(entry: RumPerformanceEntry) {\n  return entry.entryType === 'navigation' && entry.loadEventEnd <= 0\n}\n\nfunction isForbiddenResource(configuration: RumConfiguration, entry: RumPerformanceEntry) {\n  return entry.entryType === 'resource' && !isAllowedRequestUrl(configuration, entry.name)\n}\n","import type { RawError } from './error'\nimport { ErrorSource } from './error'\nimport { clocksNow } from './timeUtils'\nimport { ONE_MINUTE } from './utils'\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 type { Context } from './context'\nimport { deepClone, getType } from './utils'\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: string[],\n  modifier: (object: T) => Result\n): Result | undefined {\n  const clone = deepClone(object)\n  const result = modifier(clone)\n  modifiableFieldPaths.forEach((path) => {\n    const originalValue = get(object, path)\n    const newValue = get(clone, path)\n    const originalType = getType(originalValue)\n    const newType = getType(newValue)\n    if (newType === originalType) {\n      set(object, path, newValue)\n    } else if (originalType === 'object' && (newType === 'undefined' || newType === 'null')) {\n      set(object, path, {})\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 (!isValidObjectContaining(current, field)) {\n      return\n    }\n    if (i !== fields.length - 1) {\n      current = current[field]\n    } else {\n      current[field] = value\n    }\n  }\n}\n\nfunction isValidObjectContaining(object: unknown, field: string): object is { [key: string]: unknown } {\n  return typeof object === 'object' && object !== null && Object.prototype.hasOwnProperty.call(object, field)\n}\n","import type { Context, RawError, EventRateLimiter } from '@datadog/browser-core'\nimport {\n  combine,\n  isEmptyObject,\n  limitModification,\n  timeStampNow,\n  currentDrift,\n  display,\n  createEventRateLimiter,\n  canUseEventBridge,\n} from '@datadog/browser-core'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type {\n  CommonContext,\n  RawRumErrorEvent,\n  RawRumEvent,\n  RawRumLongTaskEvent,\n  RawRumResourceEvent,\n  RumContext,\n  User,\n} from '../rawRumEvent.types'\nimport { RumEventType } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\nimport { getSyntheticsContext } from './contexts/syntheticsContext'\nimport { getCiTestContext } from './contexts/ciTestContext'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\nimport type { ViewContexts } from './contexts/viewContexts'\nimport type { RumSessionManager } from './rumSessionManager'\nimport { RumSessionPlan } from './rumSessionManager'\nimport type { UrlContexts } from './contexts/urlContexts'\nimport type { RumConfiguration } from './configuration'\nimport type { ActionContexts } from './rumEventsCollection/action/actionCollection'\nimport { getDisplayContext } from './contexts/displayContext'\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_EVENTS_MODIFIABLE_FIELD_PATHS = [\n  // Fields with sensitive data\n  'view.url',\n  'view.referrer',\n  'action.target.name',\n  'error.message',\n  'error.stack',\n  'error.resource.url',\n  'resource.url',\n]\n\nconst OTHER_EVENTS_MODIFIABLE_FIELD_PATHS = VIEW_EVENTS_MODIFIABLE_FIELD_PATHS.concat([\n  // User-customizable field\n  'context',\n])\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  viewContexts: ViewContexts,\n  urlContexts: UrlContexts,\n  actionContexts: ActionContexts,\n  getCommonContext: () => CommonContext\n) {\n  const reportError = (error: RawError) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error })\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  }\n\n  const syntheticsContext = getSyntheticsContext()\n  const ciTestContext = getCiTestContext()\n\n  lifeCycle.subscribe(\n    LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n    ({ startTime, rawRumEvent, domainContext, savedCommonContext, customerContext }) => {\n      const viewContext = viewContexts.findView(startTime)\n      const urlContext = urlContexts.findUrl(startTime)\n      // allow to send events if the session was tracked when they start\n      // except for views which are continuously updated\n      // TODO: stop sending view updates when session is expired\n      const session = sessionManager.findTrackedSession(rawRumEvent.type !== RumEventType.VIEW ? startTime : undefined)\n      if (session && viewContext && 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            session: {\n              plan: session.hasPremiumPlan ? RumSessionPlan.PREMIUM : RumSessionPlan.LITE,\n            },\n            browser_sdk_version: canUseEventBridge() ? __BUILD_ENV__SDK_VERSION__ : undefined,\n          },\n          application: {\n            id: configuration.applicationId,\n          },\n          date: timeStampNow(),\n          service: viewContext.service || configuration.service,\n          version: viewContext.version || configuration.version,\n          source: 'browser',\n          session: {\n            id: session.id,\n            type: syntheticsContext ? SessionType.SYNTHETICS : ciTestContext ? SessionType.CI_TEST : SessionType.USER,\n          },\n          view: {\n            id: viewContext.id,\n            name: viewContext.name,\n            url: urlContext.url,\n            referrer: urlContext.referrer,\n          },\n          action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n          synthetics: syntheticsContext,\n          ci_test: ciTestContext,\n          display: getDisplayContext(),\n        }\n\n        const serverRumEvent = combine(rumContext as RumContext & Context, rawRumEvent) as RumEvent & Context\n        serverRumEvent.context = combine(commonContext.context, customerContext)\n\n        if (!('has_replay' in serverRumEvent.session)) {\n          ;(serverRumEvent.session as Mutable<RumEvent['session']>).has_replay = commonContext.hasReplay\n        }\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(\n      event,\n      event.type === RumEventType.VIEW ? VIEW_EVENTS_MODIFIABLE_FIELD_PATHS : OTHER_EVENTS_MODIFIABLE_FIELD_PATHS,\n      (event) => 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  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","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","export interface CiTestWindow extends Window {\n  Cypress?: {\n    env: (key: string) => string | undefined\n  }\n}\n\nexport function getCiTestContext() {\n  const testExecutionId = (window as CiTestWindow).Cypress?.env('traceId')\n\n  if (typeof testExecutionId === 'string') {\n    return {\n      test_execution_id: testExecutionId,\n    }\n  }\n}\n","import type { RelativeTime, Duration } from '@datadog/browser-core'\nimport { addEventListener, DOM_EVENT, elapsed, relativeNow, toServerDuration } from '@datadog/browser-core'\nimport type { InForegroundPeriod } from '../../rawRumEvent.types'\n\n// Arbitrary value to cap number of element mostly for backend & to save bandwidth\nexport const MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS = 500\n// Arbitrary value to cap number of element mostly for memory consumption in the browser\nexport const MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS = 2500\n\nexport interface ForegroundContexts {\n  isInForegroundAt: (startTime: RelativeTime) => boolean | undefined\n  selectInForegroundPeriodsFor: (startTime: RelativeTime, duration: Duration) => InForegroundPeriod[] | undefined\n  stop: () => void\n}\n\nexport interface ForegroundPeriod {\n  start: RelativeTime\n  end?: RelativeTime\n}\n\nlet foregroundPeriods: ForegroundPeriod[] = []\n\nexport function startForegroundContexts(): ForegroundContexts {\n  if (document.hasFocus()) {\n    addNewForegroundPeriod()\n  }\n\n  const { stop: stopForegroundTracking } = trackFocus(addNewForegroundPeriod)\n  const { stop: stopBlurTracking } = trackBlur(closeForegroundPeriod)\n  return {\n    isInForegroundAt,\n    selectInForegroundPeriodsFor,\n    stop: () => {\n      foregroundPeriods = []\n      stopForegroundTracking()\n      stopBlurTracking()\n    },\n  }\n}\n\nexport function addNewForegroundPeriod() {\n  if (foregroundPeriods.length > MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS) {\n    return\n  }\n  const currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1]\n  const now = relativeNow()\n  if (currentForegroundPeriod !== undefined && currentForegroundPeriod.end === undefined) {\n    return\n  }\n  foregroundPeriods.push({\n    start: now,\n  })\n}\n\nexport function closeForegroundPeriod() {\n  if (foregroundPeriods.length === 0) {\n    return\n  }\n  const currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1]\n  const now = relativeNow()\n  if (currentForegroundPeriod.end !== undefined) {\n    return\n  }\n  currentForegroundPeriod.end = now\n}\n\nfunction trackFocus(onFocusChange: () => void) {\n  return addEventListener(window, DOM_EVENT.FOCUS, (event) => {\n    if (!event.isTrusted) {\n      return\n    }\n    onFocusChange()\n  })\n}\n\nfunction trackBlur(onBlurChange: () => void) {\n  return addEventListener(window, DOM_EVENT.BLUR, (event) => {\n    if (!event.isTrusted) {\n      return\n    }\n    onBlurChange()\n  })\n}\n\nfunction isInForegroundAt(startTime: RelativeTime): boolean {\n  for (let i = foregroundPeriods.length - 1; i >= 0; i--) {\n    const foregroundPeriod = foregroundPeriods[i]\n    if (foregroundPeriod.end !== undefined && startTime > foregroundPeriod.end) {\n      break\n    }\n    if (\n      startTime > foregroundPeriod.start &&\n      (foregroundPeriod.end === undefined || startTime < foregroundPeriod.end)\n    ) {\n      return true\n    }\n  }\n  return false\n}\n\nfunction selectInForegroundPeriodsFor(eventStartTime: RelativeTime, duration: Duration): InForegroundPeriod[] {\n  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n  const eventEndTime = (eventStartTime + duration) as RelativeTime\n  const filteredForegroundPeriods: InForegroundPeriod[] = []\n\n  const earliestIndex = Math.max(0, foregroundPeriods.length - MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS)\n  for (let i = foregroundPeriods.length - 1; i >= earliestIndex; i--) {\n    const foregroundPeriod = foregroundPeriods[i]\n    if (foregroundPeriod.end !== undefined && eventStartTime > foregroundPeriod.end) {\n      // event starts after the end of the current focus period\n      // since the array is sorted, we can stop looking for foreground periods\n      break\n    }\n    if (eventEndTime < foregroundPeriod.start) {\n      // event ends before the start of the current focus period\n      // continue to previous one\n      continue\n    }\n    const startTime = eventStartTime > foregroundPeriod.start ? eventStartTime : foregroundPeriod.start\n    const startDuration = elapsed(eventStartTime, startTime)\n    const endTime =\n      foregroundPeriod.end === undefined || eventEndTime < foregroundPeriod.end ? eventEndTime : foregroundPeriod.end\n    const endDuration = elapsed(startTime, endTime)\n    filteredForegroundPeriods.unshift({\n      start: toServerDuration(startDuration),\n      duration: toServerDuration(endDuration),\n    })\n  }\n  return filteredForegroundPeriods\n}\n","import type { Context, RawError, RelativeTime, Subscription } from '@datadog/browser-core'\nimport type { RumPerformanceEntry } from '../browser/performanceCollection'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type { CommonContext, RawRumEvent } from '../rawRumEvent.types'\nimport type { RumEvent } from '../rumEvent.types'\nimport type { RequestCompleteEvent, RequestStartEvent } from './requestCollection'\nimport type { AutoAction } from './rumEventsCollection/action/actionCollection'\nimport type { ViewEvent, ViewCreatedEvent, ViewEndedEvent } from './rumEventsCollection/view/trackViews'\n\nexport const enum LifeCycleEventType {\n  PERFORMANCE_ENTRIES_COLLECTED,\n  AUTO_ACTION_COMPLETED,\n  VIEW_CREATED,\n  VIEW_UPDATED,\n  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\n  SESSION_RENEWED,\n  BEFORE_UNLOAD,\n  RAW_RUM_EVENT_COLLECTED,\n  RUM_EVENT_COLLECTED,\n  RAW_ERROR_COLLECTED,\n}\n\nexport class LifeCycle {\n  private callbacks: { [key in LifeCycleEventType]?: Array<(data: any) => void> } = {}\n\n  notify(eventType: LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, data: RumPerformanceEntry[]): void\n  notify(eventType: LifeCycleEventType.REQUEST_STARTED, data: RequestStartEvent): void\n  notify(eventType: LifeCycleEventType.REQUEST_COMPLETED, data: RequestCompleteEvent): void\n  notify(eventType: LifeCycleEventType.AUTO_ACTION_COMPLETED, data: AutoAction): void\n  notify(eventType: LifeCycleEventType.VIEW_CREATED, data: ViewCreatedEvent): void\n  notify(eventType: LifeCycleEventType.VIEW_UPDATED, data: ViewEvent): void\n  notify(eventType: LifeCycleEventType.VIEW_ENDED, data: ViewEndedEvent): void\n  notify(\n    eventType: LifeCycleEventType.RAW_ERROR_COLLECTED,\n    data: { error: RawError; savedCommonContext?: CommonContext; customerContext?: Context }\n  ): void\n  notify(\n    eventType:\n      | LifeCycleEventType.SESSION_EXPIRED\n      | LifeCycleEventType.SESSION_RENEWED\n      | LifeCycleEventType.BEFORE_UNLOAD\n  ): void\n  notify(eventType: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, data: RawRumEventCollectedData): void\n  notify(eventType: LifeCycleEventType.RUM_EVENT_COLLECTED, data: RumEvent & Context): void\n  notify(eventType: LifeCycleEventType, data?: any) {\n    const eventCallbacks = this.callbacks[eventType]\n    if (eventCallbacks) {\n      eventCallbacks.forEach((callback) => callback(data))\n    }\n  }\n\n  subscribe(\n    eventType: LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED,\n    callback: (data: RumPerformanceEntry[]) => void\n  ): Subscription\n  subscribe(eventType: LifeCycleEventType.REQUEST_STARTED, callback: (data: RequestStartEvent) => void): Subscription\n  subscribe(\n    eventType: LifeCycleEventType.REQUEST_COMPLETED,\n    callback: (data: RequestCompleteEvent) => void\n  ): Subscription\n  subscribe(eventType: LifeCycleEventType.AUTO_ACTION_COMPLETED, callback: (data: AutoAction) => void): Subscription\n  subscribe(eventType: LifeCycleEventType.VIEW_CREATED, callback: (data: ViewCreatedEvent) => void): Subscription\n  subscribe(eventType: LifeCycleEventType.VIEW_UPDATED, callback: (data: ViewEvent) => void): Subscription\n  subscribe(eventType: LifeCycleEventType.VIEW_ENDED, callback: (data: ViewEndedEvent) => void): Subscription\n  subscribe(\n    eventType: LifeCycleEventType.RAW_ERROR_COLLECTED,\n    callback: (data: { error: RawError; savedCommonContext?: CommonContext; customerContext?: Context }) => void\n  ): Subscription\n  subscribe(\n    eventType:\n      | LifeCycleEventType.SESSION_EXPIRED\n      | LifeCycleEventType.SESSION_RENEWED\n      | LifeCycleEventType.BEFORE_UNLOAD,\n    callback: () => void\n  ): Subscription\n  subscribe(\n    eventType: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n    callback: (data: RawRumEventCollectedData) => void\n  ): Subscription\n  subscribe(\n    eventType: LifeCycleEventType.RUM_EVENT_COLLECTED,\n    callback: (data: RumEvent & Context) => void\n  ): Subscription\n  subscribe(eventType: LifeCycleEventType, callback: (data?: any) => void) {\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\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","import { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod'\nimport { monitor } from '../tools/monitor'\nimport { Observable } from '../tools/observable'\nimport type { Duration, RelativeTime, ClocksState } from '../tools/timeUtils'\nimport { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/timeUtils'\nimport { normalizeUrl } from '../tools/urlPolyfill'\nimport { shallowClone } from '../tools/utils'\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  startTime: RelativeTime // deprecated\n  startClocks: ClocksState\n  isAborted: boolean\n  xhr: XMLHttpRequest\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() {\n  if (!xhrObservable) {\n    xhrObservable = createXhrObservable()\n  }\n  return xhrObservable\n}\n\nfunction createXhrObservable() {\n  const observable = new Observable<XhrContext>(() => {\n    const { stop: stopInstrumentingStart } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {\n      before: openXhr,\n    })\n\n    const { stop: stopInstrumentingSend } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {\n      before() {\n        sendXhr.call(this, observable)\n      },\n    })\n\n    const { stop: stopInstrumentingAbort } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {\n      before: abortXhr,\n    })\n\n    return () => {\n      stopInstrumentingStart()\n      stopInstrumentingSend()\n      stopInstrumentingAbort()\n    }\n  })\n  return observable\n}\n\nfunction openXhr(this: XMLHttpRequest, method: string, url: string | URL) {\n  xhrContexts.set(this, {\n    state: 'open',\n    method,\n    url: normalizeUrl(url.toString()),\n  })\n}\n\nfunction sendXhr(this: XMLHttpRequest, observable: Observable<XhrContext>) {\n  const context = xhrContexts.get(this)\n  if (!context) {\n    return\n  }\n\n  const startContext = context as XhrStartContext\n  startContext.state = 'start'\n  startContext.startTime = relativeNow()\n  startContext.startClocks = clocksNow()\n  startContext.isAborted = false\n  startContext.xhr = this\n\n  let hasBeenReported = false\n\n  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {\n    before() {\n      if (this.readyState === XMLHttpRequest.DONE) {\n        // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n        // application during a future event. For example, Angular is calling .abort() on\n        // completed requests during a onreadystatechange event, so the status becomes '0'\n        // before the request is collected.\n        onEnd()\n      }\n    },\n  })\n\n  const onEnd = monitor(() => {\n    this.removeEventListener('loadend', onEnd)\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 = this.status\n    observable.notify(shallowClone(completeContext))\n  })\n  this.addEventListener('loadend', onEnd)\n  observable.notify(startContext)\n}\n\nfunction abortXhr(this: XMLHttpRequest) {\n  const context = xhrContexts.get(this) as XhrStartContext | undefined\n  if (context) {\n    context.isAborted = true\n  }\n}\n","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils'\n\nexport const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR\nexport const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE\n","import type { RelativeTime } from './timeUtils'\nimport { relativeNow } from './timeUtils'\nimport type { TimeoutId } from './utils'\nimport { ONE_MINUTE } from './utils'\n\nconst END_OF_TIMES = Infinity as RelativeTime\n\nexport interface ContextHistoryEntry<T> {\n  startTime: RelativeTime\n  endTime: RelativeTime\n  context: T\n  remove(): void\n  close(endTime: RelativeTime): void\n}\n\nexport const CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE\n\n/**\n * Store and keep track of contexts spans. This whole class assumes that contexts are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nexport class ContextHistory<Context> {\n  private entries: Array<ContextHistoryEntry<Context>> = []\n  private clearOldContextsInterval: TimeoutId\n\n  constructor(private expireDelay: number) {\n    this.clearOldContextsInterval = setInterval(() => this.clearOldContexts(), CLEAR_OLD_CONTEXTS_INTERVAL)\n  }\n\n  /**\n   * Add a context 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  add(context: Context, startTime: RelativeTime): ContextHistoryEntry<Context> {\n    const entry: ContextHistoryEntry<Context> = {\n      context,\n      startTime,\n      endTime: END_OF_TIMES,\n      remove: () => {\n        const index = this.entries.indexOf(entry)\n        if (index >= 0) {\n          this.entries.splice(index, 1)\n        }\n      },\n      close: (endTime: RelativeTime) => {\n        entry.endTime = endTime\n      },\n    }\n    this.entries.unshift(entry)\n    return entry\n  }\n\n  /**\n   * Return the latest context that was active during `startTime`, or the currently active context\n   * if no `startTime` is provided. This method assumes that entries are not overlapping.\n   */\n  find(startTime: RelativeTime = END_OF_TIMES): Context | undefined {\n    for (const entry of this.entries) {\n      if (entry.startTime <= startTime) {\n        if (startTime <= entry.endTime) {\n          return entry.context\n        }\n        break\n      }\n    }\n  }\n\n  /**\n   * Helper function to close the currently active context, if any. This method assumes that entries\n   * are not overlapping.\n   */\n  closeActive(endTime: RelativeTime) {\n    const latestEntry = this.entries[0]\n    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n      latestEntry.close(endTime)\n    }\n  }\n\n  /**\n   * Return all contexts that were active during `startTime`, or all currently active contexts if no\n   * `startTime` is provided.\n   */\n  findAll(startTime: RelativeTime = END_OF_TIMES): Context[] {\n    return this.entries\n      .filter((entry) => entry.startTime <= startTime && startTime <= entry.endTime)\n      .map((entry) => entry.context)\n  }\n\n  /**\n   * Remove all entries from this collection.\n   */\n  reset() {\n    this.entries = []\n  }\n\n  /**\n   * Stop internal garbage collection of past entries.\n   */\n  stop() {\n    clearInterval(this.clearOldContextsInterval)\n  }\n\n  private clearOldContexts() {\n    const oldTimeThreshold = relativeNow() - this.expireDelay\n    while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n      this.entries.pop()\n    }\n  }\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport { SESSION_TIME_OUT_DELAY, ContextHistory } from '@datadog/browser-core'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { ViewCreatedEvent } from '../rumEventsCollection/view/trackViews'\n\nexport const VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\n\nexport interface ViewContext {\n  service?: string\n  version?: string\n  id: string\n  name?: string\n}\n\nexport interface ViewContexts {\n  findView: (startTime?: RelativeTime) => ViewContext | undefined\n  stop: () => void\n}\n\nexport function startViewContexts(lifeCycle: LifeCycle): ViewContexts {\n  const viewContextHistory = new ContextHistory<ViewContext>(VIEW_CONTEXT_TIME_OUT_DELAY)\n\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_CREATED, (view) => {\n    viewContextHistory.add(buildViewContext(view), view.startClocks.relative)\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, ({ endClocks }) => {\n    viewContextHistory.closeActive(endClocks.relative)\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    viewContextHistory.reset()\n  })\n\n  function buildViewContext(view: ViewCreatedEvent) {\n    return {\n      service: view.service,\n      version: view.version,\n      id: view.id,\n      name: view.name,\n    }\n  }\n\n  return {\n    findView: (startTime) => viewContextHistory.find(startTime),\n    stop: () => {\n      viewContextHistory.stop()\n    },\n  }\n}\n","import { callMonitored, monitor } from './monitor'\nimport { noop } from './utils'\n\nexport function instrumentMethod<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(\n  object: OBJECT,\n  method: METHOD,\n  instrumentationFactory: (\n    original: OBJECT[METHOD]\n  ) => (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => ReturnType<OBJECT[METHOD]>\n) {\n  const original = object[method]\n\n  let instrumentation = instrumentationFactory(original)\n\n  const instrumentationWrapper = function (this: OBJECT): ReturnType<OBJECT[METHOD]> {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return instrumentation.apply(this, arguments as unknown as Parameters<OBJECT[METHOD]>)\n  }\n  object[method] = instrumentationWrapper as OBJECT[METHOD]\n\n  return {\n    stop: () => {\n      if (object[method] === instrumentationWrapper) {\n        object[method] = original\n      } else {\n        instrumentation = original\n      }\n    },\n  }\n}\n\nexport function instrumentMethodAndCallOriginal<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(\n  object: OBJECT,\n  method: METHOD,\n  {\n    before,\n    after,\n  }: {\n    before?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void\n    after?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void\n  }\n) {\n  return instrumentMethod(\n    object,\n    method,\n    (original) =>\n      function () {\n        const args = arguments as unknown as Parameters<OBJECT[METHOD]>\n        let result\n\n        if (before) {\n          callMonitored(before, this as ThisParameterType<OBJECT[METHOD]>, args)\n        }\n\n        if (typeof original === 'function') {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n          result = original.apply(this, args)\n        }\n\n        if (after) {\n          callMonitored(after, this as ThisParameterType<OBJECT[METHOD]>, args)\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return result\n      }\n  )\n}\n\nexport function instrumentSetter<OBJECT extends { [key: string]: any }, PROPERTY extends keyof OBJECT>(\n  object: OBJECT,\n  property: PROPERTY,\n  after: (thisObject: OBJECT, value: OBJECT[PROPERTY]) => void\n) {\n  const originalDescriptor = Object.getOwnPropertyDescriptor(object, property)\n  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n    return { stop: noop }\n  }\n\n  let instrumentation = (thisObject: OBJECT, value: OBJECT[PROPERTY]) => {\n    // put hooked setter into event loop to avoid of set latency\n    setTimeout(\n      monitor(() => {\n        after(thisObject, value)\n      }),\n      0\n    )\n  }\n\n  const instrumentationWrapper = function (this: OBJECT, value: OBJECT[PROPERTY]) {\n    originalDescriptor.set!.call(this, value)\n    instrumentation(this, value)\n  }\n\n  Object.defineProperty(object, property, {\n    set: instrumentationWrapper,\n  })\n\n  return {\n    stop: () => {\n      if (Object.getOwnPropertyDescriptor(object, property)?.set === instrumentationWrapper) {\n        Object.defineProperty(object, property, originalDescriptor)\n      } else {\n        instrumentation = noop\n      }\n    },\n  }\n}\n","import { instrumentMethod } from '../tools/instrumentMethod'\nimport { callMonitored, monitor } from '../tools/monitor'\nimport { Observable } from '../tools/observable'\nimport type { Duration, ClocksState } from '../tools/timeUtils'\nimport { elapsed, clocksNow, timeStampNow } from '../tools/timeUtils'\nimport { normalizeUrl } from '../tools/urlPolyfill'\n\ninterface FetchContextBase {\n  method: string\n  startClocks: ClocksState\n  input: RequestInfo\n  init?: RequestInit\n  url: string\n}\n\nexport interface FetchStartContext extends FetchContextBase {\n  state: 'start'\n}\n\nexport interface FetchCompleteContext extends FetchContextBase {\n  state: 'complete'\n  duration: Duration\n  status: number\n  response?: Response\n  responseType?: string\n  isAborted: boolean\n  error?: Error\n}\n\nexport type FetchContext = FetchStartContext | FetchCompleteContext\n\nlet fetchObservable: Observable<FetchContext> | undefined\n\nexport function initFetchObservable() {\n  if (!fetchObservable) {\n    fetchObservable = createFetchObservable()\n  }\n  return fetchObservable\n}\n\nfunction createFetchObservable() {\n  const observable = new Observable<FetchContext>(() => {\n    if (!window.fetch) {\n      return\n    }\n\n    const { stop } = instrumentMethod(\n      window,\n      'fetch',\n      (originalFetch) =>\n        function (input, init) {\n          let responsePromise: Promise<Response>\n\n          const context = callMonitored(beforeSend, null, [observable, input, init])\n          if (context) {\n            responsePromise = originalFetch.call(this, context.input, context.init)\n            callMonitored(afterSend, null, [observable, responsePromise, context])\n          } else {\n            responsePromise = originalFetch.call(this, input, init)\n          }\n\n          return responsePromise\n        }\n    )\n\n    return stop\n  })\n\n  return observable\n}\n\nfunction beforeSend(observable: Observable<FetchContext>, input: RequestInfo, init?: RequestInit) {\n  const method = (init && init.method) || (typeof input === 'object' && input.method) || 'GET'\n  const url = normalizeUrl((typeof input === 'object' && input.url) || (input as string))\n  const startClocks = clocksNow()\n\n  const context: FetchStartContext = {\n    state: 'start',\n    init,\n    input,\n    method,\n    startClocks,\n    url,\n  }\n\n  observable.notify(context)\n\n  return context\n}\n\nfunction afterSend(\n  observable: Observable<FetchContext>,\n  responsePromise: Promise<Response>,\n  startContext: FetchStartContext\n) {\n  const reportFetch = (response: Response | Error) => {\n    const context = startContext as unknown as FetchCompleteContext\n    context.state = 'complete'\n    context.duration = elapsed(context.startClocks.timeStamp, timeStampNow())\n\n    if ('stack' in response || response instanceof Error) {\n      context.status = 0\n      context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR\n      context.error = response\n\n      observable.notify(context)\n    } else if ('status' in response) {\n      context.response = response\n      context.responseType = response.type\n      context.status = response.status\n      context.isAborted = false\n\n      observable.notify(context)\n    }\n  }\n  responsePromise.then(monitor(reportFetch), monitor(reportFetch))\n}\n","import { getOrigin, matchList, objectEntries, shallowClone, performDraw } from '@datadog/browser-core'\nimport type { RumConfiguration } from '../configuration'\nimport type {\n  RumFetchCompleteContext,\n  RumFetchStartContext,\n  RumXhrCompleteContext,\n  RumXhrStartContext,\n} from '../requestCollection'\nimport type { RumSessionManager } from '../rumSessionManager'\n\nexport interface Tracer {\n  traceFetch: (context: Partial<RumFetchStartContext>) => void\n  traceXhr: (context: Partial<RumXhrStartContext>, xhr: XMLHttpRequest) => void\n  clearTracingIfNeeded: (context: RumFetchCompleteContext | RumXhrCompleteContext) => void\n}\n\ninterface TracingHeaders {\n  [key: string]: string\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: RumFetchCompleteContext | 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: 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) as string[][])\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() || !isAllowedUrl(configuration, context.url!) || !sessionManager.findTrackedSession()) {\n    return\n  }\n\n  context.traceId = new TraceIdentifier()\n  context.spanId = new TraceIdentifier()\n  context.traceSampled = performDraw(configuration.tracingSampleRate)\n  inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled))\n}\n\nfunction isAllowedUrl(configuration: RumConfiguration, requestUrl: string) {\n  return matchList(configuration.allowedTracingOrigins, getOrigin(requestUrl))\n}\n\nexport function isTracingSupported() {\n  return getCrypto() !== undefined\n}\n\nfunction getCrypto() {\n  return window.crypto || (window as any).msCrypto\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(traceId: TraceIdentifier, spanId: TraceIdentifier, traceSampled: boolean): TracingHeaders {\n  return {\n    'x-datadog-origin': 'rum',\n    'x-datadog-parent-id': spanId.toDecimalString(),\n    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n    'x-datadog-trace-id': traceId.toDecimalString(),\n  }\n}\n\n/* eslint-disable no-bitwise */\nexport class TraceIdentifier {\n  private buffer: Uint8Array = new Uint8Array(8)\n\n  constructor() {\n    getCrypto().getRandomValues(this.buffer)\n    this.buffer[0] = this.buffer[0] & 0x7f // force 63-bit\n  }\n\n  toString(radix: number) {\n    let high = this.readInt32(0)\n    let low = this.readInt32(4)\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   * Format used everywhere except the trace intake\n   */\n  toDecimalString() {\n    return this.toString(10)\n  }\n\n  private readInt32(offset: number) {\n    return (\n      this.buffer[offset] * 16777216 +\n      (this.buffer[offset + 1] << 16) +\n      (this.buffer[offset + 2] << 8) +\n      this.buffer[offset + 3]\n    )\n  }\n}\n/* eslint-enable no-bitwise */\n","import type {\n  Duration,\n  XhrCompleteContext,\n  XhrStartContext,\n  ClocksState,\n  FetchStartContext,\n  FetchCompleteContext,\n} from '@datadog/browser-core'\nimport { RequestType, initFetchObservable, initXhrObservable } 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 './rumEventsCollection/resource/resourceUtils'\nimport type { TraceIdentifier, Tracer } from './tracing/tracer'\nimport { startTracer } from './tracing/tracer'\n\nexport interface CustomContext {\n  requestIndex: number\n  spanId?: TraceIdentifier\n  traceId?: TraceIdentifier\n  traceSampled?: boolean\n}\nexport interface RumFetchStartContext extends FetchStartContext, CustomContext {}\nexport interface RumFetchCompleteContext extends FetchCompleteContext, CustomContext {}\nexport interface RumXhrStartContext extends XhrStartContext, CustomContext {}\nexport interface RumXhrCompleteContext extends XhrCompleteContext, CustomContext {}\n\nexport interface RequestStartEvent {\n  requestIndex: number\n  url: string\n}\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?: TraceIdentifier\n  traceId?: TraceIdentifier\n  traceSampled?: boolean\n  xhr?: XMLHttpRequest\n  response?: Response\n  input?: RequestInfo\n  init?: RequestInit\n  error?: Error\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, configuration, tracer)\n}\n\nexport function trackXhr(lifeCycle: LifeCycle, configuration: RumConfiguration, tracer: Tracer) {\n  const subscription = initXhrObservable().subscribe((rawContext) => {\n    const context = rawContext as RumXhrStartContext | RumXhrCompleteContext\n    if (!isAllowedRequestUrl(configuration, 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        })\n        break\n    }\n  })\n\n  return { stop: () => subscription.unsubscribe() }\n}\n\nexport function trackFetch(lifeCycle: LifeCycle, configuration: RumConfiguration, tracer: Tracer) {\n  const subscription = initFetchObservable().subscribe((rawContext) => {\n    const context = rawContext as RumFetchCompleteContext | RumFetchStartContext\n    if (!isAllowedRequestUrl(configuration, 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 'complete':\n        tracer.clearTracingIfNeeded(context)\n\n        lifeCycle.notify(LifeCycleEventType.REQUEST_COMPLETED, {\n          duration: context.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        })\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","import { noop } from '@datadog/browser-core'\nimport { RumEventType } from '../rawRumEvent.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(lifeCycle: LifeCycle, callback: (eventCounts: EventCounts) => void = noop) {\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    switch (event.type) {\n      case RumEventType.ERROR:\n        eventCounts.errorCount += 1\n        callback(eventCounts)\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(eventCounts)\n        break\n      case RumEventType.LONG_TASK:\n        eventCounts.longTaskCount += 1\n        callback(eventCounts)\n        break\n      case RumEventType.RESOURCE:\n        eventCounts.resourceCount += 1\n        callback(eventCounts)\n        break\n    }\n  })\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n    eventCounts,\n  }\n}\n","import type { Subscription, TimeoutId, TimeStamp } from '@datadog/browser-core'\nimport { instrumentMethodAndCallOriginal, matchList, monitor, Observable, timeStampNow } from '@datadog/browser-core'\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  configuration: RumConfiguration,\n  pageActivityEndCallback: (event: PageActivityEndEvent) => void,\n  maxDuration?: number\n) {\n  const pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, configuration)\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 &&\n    setTimeout(\n      monitor(() => complete({ hadActivity: true, end: timeStampNow() })),\n      maxDuration\n    )\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  configuration: RumConfiguration\n): Observable<PageActivityEvent> {\n  const observable = new Observable<PageActivityEvent>(() => {\n    const subscriptions: Subscription[] = []\n    let firstRequestIndex: undefined | number\n    let pendingRequestsCount = 0\n\n    subscriptions.push(\n      domMutationObservable.subscribe(notifyPageActivity),\n      lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n        if (entries.some((entry) => entry.entryType === 'resource' && !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    const { stop: stopTrackingWindowOpen } = trackWindowOpen(notifyPageActivity)\n\n    return () => {\n      stopTrackingWindowOpen()\n      subscriptions.forEach((s) => s.unsubscribe())\n    }\n\n    function notifyPageActivity() {\n      observable.notify({ isBusy: pendingRequestsCount > 0 })\n    }\n  })\n\n  return observable\n}\n\nfunction isExcludedUrl(configuration: RumConfiguration, requestUrl: string): boolean {\n  return matchList(configuration.excludedActivityUrls, requestUrl)\n}\n\nfunction trackWindowOpen(callback: () => void) {\n  return instrumentMethodAndCallOriginal(window, 'open', { before: callback })\n}\n","import { monitor, ONE_SECOND } 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 maxDurationBetweenClicksTimeout: number | undefined\n  appendClick(firstClick)\n\n  function appendClick(click: Click) {\n    click.stopObservable.subscribe(tryFinalize)\n    bufferedClicks.push(click)\n    clearTimeout(maxDurationBetweenClicksTimeout)\n    maxDurationBetweenClicksTimeout = setTimeout(monitor(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(maxDurationBetweenClicksTimeout)\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 { safeTruncate, isIE, find } from '@datadog/browser-core'\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 */\nconst DEFAULT_PROGRAMMATIC_ATTRIBUTE = 'data-dd-action-name'\n\nexport function getActionNameFromElement(element: Element, userProgrammaticAttribute?: string): string {\n  // Proceed to get the action name in two steps:\n  // * first, get the name programmatically, explicitly defined by the user.\n  // * then, use strategies that are known to return good results. Those strategies will be used on\n  //   the element and a few parents, but it's likely that they won't succeed at all.\n  // * if no name is found this way, use strategies returning less accurate names as a fallback.\n  //   Those are much likely to succeed.\n  return (\n    getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ATTRIBUTE) ||\n    (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute)) ||\n    getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies) ||\n    getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies) ||\n    ''\n  )\n}\n\nfunction getActionNameFromElementProgrammatically(targetElement: Element, programmaticAttribute: string) {\n  let elementWithAttribute\n  // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n  // without limit. It is up to the user to declare a relevant naming strategy.\n  // If available, use element.closest() to match get the attribute from the element or any of its\n  // parent.  Else fallback to a more traditional implementation.\n  if (supportsElementClosest()) {\n    elementWithAttribute = targetElement.closest(`[${programmaticAttribute}]`)\n  } else {\n    let element: Element | null = targetElement\n    while (element) {\n      if (element.hasAttribute(programmaticAttribute)) {\n        elementWithAttribute = element\n        break\n      }\n      element = element.parentElement\n    }\n  }\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) => string | undefined | null\n\nconst priorityStrategies: NameStrategy[] = [\n  // associated LABEL text\n  (element, userProgrammaticAttribute) => {\n    // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n    // instead\n    if (supportsLabelProperty()) {\n      if ('labels' in element && element.labels && element.labels.length > 0) {\n        return getTextualContent(element.labels[0], userProgrammaticAttribute)\n      }\n    } else if (element.id) {\n      const label =\n        element.ownerDocument &&\n        find(element.ownerDocument.querySelectorAll('label'), (label) => label.htmlFor === element.id)\n      return label && getTextualContent(label, 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 input.value\n      }\n    }\n  },\n  // BUTTON, LABEL or button-like element text\n  (element, userProgrammaticAttribute) => {\n    if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n      return getTextualContent(element, userProgrammaticAttribute)\n    }\n  },\n  (element) => element.getAttribute('aria-label'),\n  // associated element text designated by the aria-labelledby attribute\n  (element, userProgrammaticAttribute) => {\n    const labelledByAttribute = element.getAttribute('aria-labelledby')\n    if (labelledByAttribute) {\n      return labelledByAttribute\n        .split(/\\s+/)\n        .map((id) => getElementById(element, id))\n        .filter((label): label is HTMLElement => Boolean(label))\n        .map((element) => getTextualContent(element, userProgrammaticAttribute))\n        .join(' ')\n    }\n  },\n  (element) => element.getAttribute('alt'),\n  (element) => element.getAttribute('name'),\n  (element) => element.getAttribute('title'),\n  (element) => element.getAttribute('placeholder'),\n  // SELECT first OPTION text\n  (element, userProgrammaticAttribute) => {\n    if ('options' in element && element.options.length > 0) {\n      return getTextualContent(element.options[0], userProgrammaticAttribute)\n    }\n  },\n]\n\nconst fallbackStrategies: NameStrategy[] = [\n  (element, userProgrammaticAttribute) => getTextualContent(element, userProgrammaticAttribute),\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) {\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 name = strategy(element, userProgrammaticAttribute)\n      if (typeof name === 'string') {\n        const trimmedName = name.trim()\n        if (trimmedName) {\n          return truncate(normalizeWhitespace(trimmedName))\n        }\n      }\n    }\n    // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n    // be reconsidered in the future.\n    if (element.nodeName === 'FORM') {\n      break\n    }\n    element = element.parentElement\n    recursionCounter += 1\n  }\n}\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 getTextualContent(element: Element | HTMLElement, userProgrammaticAttribute: string | undefined) {\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    if (!supportsInnerTextScriptAndStyleRemoval()) {\n      // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n      // be relatively fast and work in most cases.\n      removeTextFromElements('script, style')\n    }\n\n    // remove the text of elements with programmatic attribute value\n    removeTextFromElements(`[${DEFAULT_PROGRAMMATIC_ATTRIBUTE}]`)\n\n    if (userProgrammaticAttribute) {\n      removeTextFromElements(`[${userProgrammaticAttribute}]`)\n    }\n\n    return text\n  }\n\n  return element.textContent\n}\n\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n  return !isIE()\n}\n\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nlet supportsLabelPropertyResult: boolean | undefined\nfunction supportsLabelProperty() {\n  if (supportsLabelPropertyResult === undefined) {\n    supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype\n  }\n  return supportsLabelPropertyResult\n}\n\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nlet supportsElementClosestResult: boolean | undefined\nfunction supportsElementClosest() {\n  if (supportsElementClosestResult === undefined) {\n    supportsElementClosestResult = 'closest' in HTMLElement.prototype\n  }\n  return supportsElementClosestResult\n}\n","export function isIE() {\n  return Boolean((document as any).documentMode)\n}\n\nexport function isChromium() {\n  return !!(window as any).chrome || /HeadlessChrome/.test(window.navigator.userAgent)\n}\n","import { arrayFrom, cssEscape } from '@datadog/browser-core'\n\nexport function getSelectorFromElement(targetElement: Element): string {\n  const targetElementSelector = []\n  let element: Element | null = targetElement\n\n  while (element && element.nodeName !== 'HTML') {\n    const idSelector = getIDSelector(element)\n    if (idSelector) {\n      targetElementSelector.unshift(idSelector)\n      break\n    }\n\n    targetElementSelector.unshift(getClassSelector(element) || getPositionSelector(element))\n\n    element = element.parentElement\n  }\n\n  return targetElementSelector.join('>')\n}\n\nfunction getIDSelector(element: Element): string | undefined {\n  if (!element.id) return\n\n  const escapedId = cssEscape(element.id)\n  const isUnique = element.ownerDocument.body.querySelectorAll(`#${escapedId}`).length === 1\n\n  if (isUnique) return `#${escapedId}`\n}\n\nfunction getClassSelector(element: Element): string | undefined {\n  const orderedClassList = arrayFrom(element.classList).sort()\n  let classUniqueAmongSiblings = true\n  for (let i = 0; i < element.parentElement!.children.length; i++) {\n    const sibling = element.parentElement!.children[i]\n    if (sibling === element) continue\n\n    if (sibling.tagName === element.tagName && sameClasses(orderedClassList, sibling.classList)) {\n      classUniqueAmongSiblings = false\n      break\n    }\n  }\n\n  if (classUniqueAmongSiblings)\n    return `${element.tagName}${orderedClassList.map((className) => `.${cssEscape(className)}`).join('')}`\n}\n\nfunction sameClasses(a: string[], b: DOMTokenList): boolean {\n  return a.length <= b.length && a.every((className) => b.contains(className))\n}\n\nfunction getPositionSelector(element: Element): string | undefined {\n  const isUniqueChild = !element.previousElementSibling && !element.nextElementSibling\n  if (isUniqueChild) return `${element.tagName}`\n\n  let index = 1\n  let prevSibling = element.previousElementSibling\n  while (prevSibling) {\n    if (element.tagName === prevSibling.tagName) index++\n\n    prevSibling = prevSibling.previousElementSibling\n  }\n\n  return `${element.tagName}:nth-of-type(${index})`\n}\n","import { addEventListener, DOM_EVENT, monitor } from '@datadog/browser-core'\n\nexport interface OnClickContext {\n  event: MouseEvent & { target: Element }\n  getUserActivity(): { selection: boolean; input: boolean }\n}\n\nexport function listenActionEvents({ onClick }: { onClick(context: OnClickContext): void }) {\n  let hasSelectionChanged = false\n  let selectionEmptyAtMouseDown: boolean\n  let hasInputChanged = false\n\n  const listeners = [\n    addEventListener(\n      window,\n      DOM_EVENT.MOUSE_DOWN,\n      () => {\n        hasSelectionChanged = false\n        selectionEmptyAtMouseDown = isSelectionEmpty()\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      window,\n      DOM_EVENT.SELECTION_CHANGE,\n      () => {\n        if (!selectionEmptyAtMouseDown || !isSelectionEmpty()) {\n          hasSelectionChanged = true\n        }\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      window,\n      DOM_EVENT.CLICK,\n      (clickEvent: MouseEvent) => {\n        if (clickEvent.target instanceof Element) {\n          // Use a scoped variable to make sure the value is not changed by other clicks\n          const userActivity = {\n            selection: hasSelectionChanged,\n            input: hasInputChanged,\n          }\n          if (!hasInputChanged) {\n            setTimeout(\n              monitor(() => {\n                userActivity.input = hasInputChanged\n              })\n            )\n          }\n\n          onClick({\n            event: clickEvent as MouseEvent & { target: Element },\n            getUserActivity: () => userActivity,\n          })\n        }\n      },\n      { capture: true }\n    ),\n\n    addEventListener(\n      window,\n      DOM_EVENT.INPUT,\n      () => {\n        hasInputChanged = 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","import { elementMatches, 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)) {\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  // eslint-disable-next-line max-len\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  // 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) {\n    return false\n  }\n  return !elementMatches(click.event.target, DEAD_CLICK_EXCLUDE_SELECTOR)\n}\n","import type { Duration, ClocksState, RelativeTime, TimeStamp } from '@datadog/browser-core'\nimport {\n  timeStampNow,\n  isExperimentalFeatureEnabled,\n  Observable,\n  assign,\n  getRelativeTime,\n  ONE_MINUTE,\n  ContextHistory,\n  generateUUID,\n  clocksNow,\n  ONE_SECOND,\n  elapsed,\n} from '@datadog/browser-core'\nimport type { FrustrationType } from '../../../rawRumEvent.types'\nimport { ActionType } from '../../../rawRumEvent.types'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport { trackEventCounts } from '../../trackEventCounts'\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd'\nimport type { ClickChain } from './clickChain'\nimport { createClickChain } from './clickChain'\nimport { getActionNameFromElement } from './getActionNameFromElement'\nimport { getSelectorFromElement } from './getSelectorFromElement'\nimport type { OnClickContext } from './listenActionEvents'\nimport { listenActionEvents } from './listenActionEvents'\nimport { computeFrustration } from './computeFrustration'\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  target?: {\n    selector: string\n    width: number\n    height: number\n  }\n  position?: { x: number; y: number }\n  startClocks: ClocksState\n  duration?: Duration\n  counts: ActionCounts\n  event: MouseEvent & { target: Element }\n  frustrationTypes: FrustrationType[]\n  events: Event[]\n}\n\nexport interface ActionContexts {\n  findActionId: (startTime?: RelativeTime) => string | string[] | undefined\n}\n\ntype ClickActionIdHistory = ContextHistory<ClickAction['id']>\n\n// Maximum duration for click actions\nexport const CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND\nexport const ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE // arbitrary\n\nexport function trackClickActions(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  configuration: RumConfiguration\n) {\n  const history: ClickActionIdHistory = new ContextHistory(ACTION_CONTEXT_TIME_OUT_DELAY)\n  const stopObservable = new Observable<void>()\n  const { trackFrustrations } = configuration\n  let currentClickChain: ClickChain | undefined\n\n  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n    history.reset()\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.BEFORE_UNLOAD, stopClickChain)\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, stopClickChain)\n\n  const { stop: stopActionEventsListener } = listenActionEvents({ onClick: processClick })\n\n  const actionContexts: ActionContexts = {\n    findActionId: (startTime?: RelativeTime) =>\n      trackFrustrations ? history.findAll(startTime) : history.find(startTime),\n  }\n\n  return {\n    stop: () => {\n      stopClickChain()\n      stopObservable.notify()\n      stopActionEventsListener()\n    },\n    actionContexts,\n  }\n\n  function stopClickChain() {\n    if (currentClickChain) {\n      currentClickChain.stop()\n    }\n  }\n\n  function processClick({ event, getUserActivity }: OnClickContext) {\n    if (!trackFrustrations && history.find()) {\n      // TODO: remove this in a future major version. To keep retrocompatibility, ignore any new\n      // action if another one is already occurring.\n      return\n    }\n\n    const name = getActionNameFromElement(event.target, configuration.actionNameAttribute)\n    if (!trackFrustrations && !name) {\n      // TODO: remove this in a future major version. To keep retrocompatibility, ignore any action\n      // with a blank name\n      return\n    }\n\n    const startClocks = clocksNow()\n\n    const click = newClick(lifeCycle, history, getUserActivity, {\n      name,\n      event,\n      startClocks,\n    })\n\n    if (trackFrustrations && (!currentClickChain || !currentClickChain.tryAppend(click))) {\n      const rageClick = click.clone()\n      currentClickChain = createClickChain(click, (clicks) => {\n        finalizeClicks(clicks, rageClick)\n      })\n    }\n\n    const { stop: stopWaitPageActivityEnd } = waitPageActivityEnd(\n      lifeCycle,\n      domMutationObservable,\n      configuration,\n      (pageActivityEndEvent) => {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < startClocks.timeStamp) {\n          // If the clock is looking weird, just discard the click\n          click.discard()\n        } else {\n          click.stop(pageActivityEndEvent.hadActivity ? pageActivityEndEvent.end : undefined)\n\n          // Validate or discard the click only if we don't track frustrations. It'll be done when\n          // the click chain is finalized.\n          if (!trackFrustrations) {\n            if (!pageActivityEndEvent.hadActivity) {\n              // If we are not tracking frustrations, we should discard the click to keep backward\n              // compatibility.\n              click.discard()\n            } else {\n              click.validate()\n            }\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}\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: OnClickContext['getUserActivity'],\n  base: Pick<ClickAction, 'startClocks' | 'event' | 'name'>\n) {\n  const id = generateUUID()\n  let target: ClickAction['target']\n  let position: ClickAction['position']\n\n  if (isExperimentalFeatureEnabled('clickmap')) {\n    const rect = base.event.target.getBoundingClientRect()\n    target = {\n      selector: getSelectorFromElement(base.event.target),\n      width: Math.round(rect.width),\n      height: Math.round(rect.height),\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(base.event.clientX - rect.left),\n      y: Math.round(base.event.clientY - rect.top),\n    }\n  }\n  const historyEntry = history.add(id, base.startClocks.relative)\n  const eventCountsSubscription = trackEventCounts(lifeCycle)\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: base.event,\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\n    isStopped: () => status === ClickStatus.STOPPED || status === ClickStatus.FINALIZED,\n\n    clone: () => newClick(lifeCycle, history, getUserActivity, base),\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 = assign(\n        {\n          type: ActionType.CLICK as const,\n          duration: activityEndTime && elapsed(base.startClocks.timeStamp, activityEndTime),\n          id,\n          frustrationTypes,\n          target,\n          position,\n          counts: {\n            resourceCount,\n            errorCount,\n            longTaskCount,\n          },\n          events: domEvents ?? [base.event],\n        },\n        base\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 { noop, assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core'\n\nimport type { CommonContext, RawRumActionEvent } from '../../../rawRumEvent.types'\nimport { ActionType, RumEventType } from '../../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { ForegroundContexts } from '../../contexts/foregroundContexts'\nimport type { RumConfiguration } from '../../configuration'\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}\n\nexport type AutoAction = ClickAction\n\nexport function startActionCollection(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  configuration: RumConfiguration,\n  foregroundContexts: ForegroundContexts\n) {\n  lifeCycle.subscribe(LifeCycleEventType.AUTO_ACTION_COMPLETED, (action) =>\n    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processAction(action, foregroundContexts))\n  )\n\n  let actionContexts: ActionContexts = { findActionId: noop as () => undefined }\n  if (configuration.trackInteractions) {\n    actionContexts = trackClickActions(lifeCycle, domMutationObservable, configuration).actionContexts\n  }\n\n  return {\n    addAction: (action: CustomAction, savedCommonContext?: CommonContext) => {\n      lifeCycle.notify(\n        LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n        assign(\n          {\n            savedCommonContext,\n          },\n          processAction(action, foregroundContexts)\n        )\n      )\n    },\n    actionContexts,\n  }\n}\n\nfunction processAction(\n  action: AutoAction | CustomAction,\n  foregroundContexts: ForegroundContexts\n): RawRumEventCollectedData<RawRumActionEvent> {\n  const autoActionProperties = isAutoAction(action)\n    ? {\n        action: {\n          id: action.id,\n          target: action.target,\n          position: action.position,\n          loading_time: toServerDuration(action.duration),\n          frustration: {\n            type: action.frustrationTypes,\n          },\n          error: {\n            count: action.counts.errorCount,\n          },\n          long_task: {\n            count: action.counts.longTaskCount,\n          },\n          resource: {\n            count: action.counts.resourceCount,\n          },\n        },\n      }\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    },\n    autoActionProperties\n  )\n  const inForeground = foregroundContexts.isInForegroundAt(action.startClocks.relative)\n  if (inForeground !== undefined) {\n    actionEvent.view = { in_foreground: inForeground }\n  }\n  return {\n    customerContext,\n    rawRumEvent: actionEvent,\n    startTime: action.startClocks.relative,\n    domainContext: isAutoAction(action) ? { event: action.event, events: action.events } : {},\n  }\n}\n\nfunction isAutoAction(action: AutoAction | CustomAction): action is AutoAction {\n  return action.type !== ActionType.CUSTOM\n}\n","import { instrumentMethodAndCallOriginal } from '../../tools/instrumentMethod'\nimport { computeStackTrace } from './computeStackTrace'\nimport type { UnhandledErrorCallback, StackTrace } from './types'\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): )?(.*)$/\n\n/**\n * Cross-browser collection of unhandled errors\n *\n * Supports:\n * - Firefox: full stack trace with line numbers, plus column number\n * on top frame; column number is not guaranteed\n * - Opera: full stack trace with line and column numbers\n * - Chrome: full stack trace with line and column numbers\n * - Safari: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n * - IE: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n * - IE5.5+ (only 8.0 tested)\n * - Firefox 0.9+ (only 3.5+ tested)\n * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n * Exceptions Have Stacktrace to be enabled in opera:config)\n * - Safari 3+ (only 4+ tested)\n * - Chrome 1+ (only 5+ tested)\n * - Konqueror 3.5+ (untested)\n *\n * Tries to catch all unhandled errors and report them to the\n * callback.\n *\n * Callbacks receive a StackTrace object as described in the\n * computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\n\nexport function startUnhandledErrorCollection(callback: UnhandledErrorCallback) {\n  const { stop: stopInstrumentingOnError } = instrumentOnError(callback)\n  const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(callback)\n\n  return {\n    stop: () => {\n      stopInstrumentingOnError()\n      stopInstrumentingOnUnhandledRejection()\n    },\n  }\n}\n\n/**\n * Install a global onerror handler\n */\nfunction instrumentOnError(callback: UnhandledErrorCallback) {\n  return instrumentMethodAndCallOriginal(window, 'onerror', {\n    before(this: any, message: Event | string, url?: string, lineNo?: number, columnNo?: number, errorObj?: Error) {\n      let stack: StackTrace\n\n      if (errorObj) {\n        stack = computeStackTrace(errorObj)\n        callback(stack, errorObj)\n      } else {\n        const location = {\n          url,\n          column: columnNo,\n          line: lineNo,\n        }\n\n        let name\n        let msg = message\n        if ({}.toString.call(message) === '[object String]') {\n          const groups = ERROR_TYPES_RE.exec(msg as string)\n          if (groups) {\n            name = groups[1]\n            msg = groups[2]\n          }\n        }\n\n        stack = {\n          name,\n          message: typeof msg === 'string' ? msg : undefined,\n          stack: [location],\n        }\n\n        callback(stack, message)\n      }\n    },\n  })\n}\n\n/**\n * Install a global onunhandledrejection handler\n */\nfunction instrumentUnhandledRejection(callback: UnhandledErrorCallback) {\n  return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {\n    before(e: PromiseRejectionEvent) {\n      const reason = e.reason || 'Empty reason'\n      const stack = computeStackTrace(reason)\n      callback(stack, reason)\n    },\n  })\n}\n","import { computeStackTrace } from '../tracekit'\nimport { createHandlingStack, formatErrorMessage, toStackTraceString } from '../../tools/error'\nimport { mergeObservables, Observable } from '../../tools/observable'\nimport { find, jsonStringify } from '../../tools/utils'\nimport { ConsoleApiName } from '../../tools/display'\nimport { callMonitored } from '../../tools/monitor'\n\nexport interface ConsoleLog {\n  message: string\n  api: ConsoleApiName\n  stack?: string\n  handlingStack?: string\n}\n\nconst consoleObservablesByApi: { [k in ConsoleApiName]?: Observable<ConsoleLog> } = {}\n\nexport function initConsoleObservable(apis: ConsoleApiName[]) {\n  const consoleObservables = apis.map((api) => {\n    if (!consoleObservablesByApi[api]) {\n      consoleObservablesByApi[api] = createConsoleObservable(api)\n    }\n    return consoleObservablesByApi[api]!\n  })\n\n  return mergeObservables<ConsoleLog>(...consoleObservables)\n}\n\n/* eslint-disable no-console */\nfunction createConsoleObservable(api: ConsoleApiName) {\n  const observable = new Observable<ConsoleLog>(() => {\n    const originalConsoleApi = console[api]\n\n    console[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      console[api] = originalConsoleApi\n    }\n  })\n\n  return observable\n}\n\nfunction buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {\n  // Todo: remove console error prefix in the next major version\n  let message = params.map((param) => formatConsoleParameters(param)).join(' ')\n  let stack\n\n  if (api === ConsoleApiName.error) {\n    const firstErrorParam = find(params, (param: unknown): param is Error => param instanceof Error)\n    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined\n    message = `console error: ${message}`\n  }\n\n  return {\n    api,\n    message,\n    stack,\n    handlingStack,\n  }\n}\n\nfunction formatConsoleParameters(param: unknown) {\n  if (typeof param === 'string') {\n    return param\n  }\n  if (param instanceof Error) {\n    return formatErrorMessage(computeStackTrace(param))\n  }\n  return jsonStringify(param, undefined, 2)\n}\n","import { toStackTraceString } from '../../tools/error'\nimport { monitor } from '../../tools/monitor'\nimport { mergeObservables, Observable } from '../../tools/observable'\nimport { DOM_EVENT, includes, addEventListener, safeTruncate } from '../../tools/utils'\nimport type { Report, BrowserWindow, ReportType } 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 interface RawReport {\n  type: RawReportType\n  subtype: string\n  message: string\n  stack?: string\n}\n\nexport function initReportObservable(apis: RawReportType[]) {\n  const observables: Array<Observable<RawReport>> = []\n\n  if (includes(apis, RawReportType.cspViolation)) {\n    observables.push(createCspViolationReportObservable())\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<RawReport>(...observables)\n}\n\nfunction createReportObservable(reportTypes: ReportType[]) {\n  const observable = new Observable<RawReport>(() => {\n    if (!(window as BrowserWindow).ReportingObserver) {\n      return\n    }\n\n    const handleReports = monitor((reports: Report[]) =>\n      reports.forEach((report) => {\n        observable.notify(buildRawReportFromReport(report))\n      })\n    )\n\n    const observer = new (window as BrowserWindow).ReportingObserver!(handleReports, {\n      types: reportTypes,\n      buffered: true,\n    })\n\n    observer.observe()\n    return () => {\n      observer.disconnect()\n    }\n  })\n\n  return observable\n}\n\nfunction createCspViolationReportObservable() {\n  const observable = new Observable<RawReport>(() => {\n    const handleCspViolation = monitor((event: SecurityPolicyViolationEvent) => {\n      observable.notify(buildRawReportFromCspViolation(event))\n    })\n\n    const { stop } = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, handleCspViolation)\n\n    return stop\n  })\n  return observable\n}\n\nfunction buildRawReportFromReport({ type, body }: Report): RawReport {\n  return {\n    type,\n    subtype: body.id,\n    message: `${type}: ${body.message}`,\n    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n  }\n}\n\nfunction buildRawReportFromCspViolation(event: SecurityPolicyViolationEvent): RawReport {\n  const type = RawReportType.cspViolation\n  const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`\n  return {\n    type: RawReportType.cspViolation,\n    subtype: event.effectiveDirective,\n    message: `${type}: ${message}`,\n    stack: buildStack(\n      event.effectiveDirective,\n      `${message} of the policy \"${safeTruncate(event.originalPolicy, 100, '...')}\"`,\n      event.sourceFile,\n      event.lineNumber,\n      event.columnNumber\n    ),\n  }\n}\n\nfunction buildStack(\n  name: string,\n  message: string,\n  sourceFile: string | undefined,\n  lineNumber: number | undefined,\n  columnNumber: number | undefined\n): string | undefined {\n  return (\n    sourceFile &&\n    toStackTraceString({\n      name,\n      message,\n      stack: [\n        {\n          func: '?',\n          url: sourceFile,\n          line: lineNumber,\n          column: columnNumber,\n        },\n      ],\n    })\n  )\n}\n","import type { EventEmitter, RelativeTime } from '@datadog/browser-core'\nimport { addEventListeners, DOM_EVENT } from '@datadog/browser-core'\n\nlet trackFirstHiddenSingleton: { timeStamp: RelativeTime } | undefined\nlet stopListeners: (() => void) | undefined\n\nexport function trackFirstHidden(emitter: EventEmitter = window) {\n  if (!trackFirstHiddenSingleton) {\n    if (document.visibilityState === 'hidden') {\n      trackFirstHiddenSingleton = {\n        timeStamp: 0 as RelativeTime,\n      }\n    } else {\n      trackFirstHiddenSingleton = {\n        timeStamp: Infinity as RelativeTime,\n      }\n      ;({ stop: stopListeners } = addEventListeners(\n        emitter,\n        [DOM_EVENT.PAGE_HIDE, DOM_EVENT.VISIBILITY_CHANGE],\n        (event) => {\n          if (event.type === 'pagehide' || document.visibilityState === 'hidden') {\n            trackFirstHiddenSingleton!.timeStamp = event.timeStamp as RelativeTime\n            stopListeners!()\n          }\n        },\n        { capture: true }\n      ))\n    }\n  }\n\n  return trackFirstHiddenSingleton\n}\n\nexport function resetFirstHidden() {\n  if (stopListeners) {\n    stopListeners()\n  }\n  trackFirstHiddenSingleton = undefined\n}\n","import type { Context, RawError, ClocksState } from '@datadog/browser-core'\nimport {\n  assign,\n  computeStackTrace,\n  formatUnknownError,\n  ErrorSource,\n  generateUUID,\n  ErrorHandling,\n  Observable,\n  trackRuntimeError,\n} from '@datadog/browser-core'\nimport type { CommonContext, RawRumErrorEvent } from '../../../rawRumEvent.types'\nimport { RumEventType } from '../../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { ForegroundContexts } from '../../contexts/foregroundContexts'\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}\n\nexport function startErrorCollection(lifeCycle: LifeCycle, foregroundContexts: ForegroundContexts) {\n  const errorObservable = new Observable<RawError>()\n\n  trackConsoleError(errorObservable)\n  trackRuntimeError(errorObservable)\n  trackReportError(errorObservable)\n\n  errorObservable.subscribe((error) => lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error }))\n\n  return doStartErrorCollection(lifeCycle, foregroundContexts)\n}\n\nexport function doStartErrorCollection(lifeCycle: LifeCycle, foregroundContexts: ForegroundContexts) {\n  lifeCycle.subscribe(LifeCycleEventType.RAW_ERROR_COLLECTED, ({ error, customerContext, savedCommonContext }) => {\n    lifeCycle.notify(\n      LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,\n      assign(\n        {\n          customerContext,\n          savedCommonContext,\n        },\n        processError(error, foregroundContexts)\n      )\n    )\n  })\n\n  return {\n    addError: (\n      { error, handlingStack, startClocks, context: customerContext }: ProvidedError,\n      savedCommonContext?: CommonContext\n    ) => {\n      const rawError = computeRawError(error, handlingStack, startClocks)\n      lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, {\n        customerContext,\n        savedCommonContext,\n        error: rawError,\n      })\n    },\n  }\n}\n\nfunction computeRawError(error: unknown, handlingStack: string, startClocks: ClocksState): RawError {\n  const stackTrace = error instanceof Error ? computeStackTrace(error) : undefined\n  return assign(\n    {\n      startClocks,\n      source: ErrorSource.CUSTOM,\n      originalError: error,\n      handling: ErrorHandling.HANDLED,\n    },\n    formatUnknownError(stackTrace, error, 'Provided', handlingStack)\n  )\n}\n\nfunction processError(\n  error: RawError,\n  foregroundContexts: ForegroundContexts\n): 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      type: error.type,\n      handling: error.handling,\n      source_type: 'browser',\n    },\n    type: RumEventType.ERROR as const,\n  }\n  const inForeground = foregroundContexts.isInForegroundAt(error.startClocks.relative)\n  if (inForeground !== undefined) {\n    rawRumEvent.view = { in_foreground: inForeground }\n  }\n\n  return {\n    rawRumEvent,\n    startTime: error.startClocks.relative,\n    domainContext: {\n      error: error.originalError,\n    },\n  }\n}\n","import type { Observable, RawError } from '@datadog/browser-core'\nimport { clocksNow, ErrorHandling, initConsoleObservable, ErrorSource, ConsoleApiName } from '@datadog/browser-core'\n\nexport function trackConsoleError(errorObservable: Observable<RawError>) {\n  const subscription = initConsoleObservable([ConsoleApiName.error]).subscribe((consoleError) =>\n    errorObservable.notify({\n      startClocks: clocksNow(),\n      message: consoleError.message,\n      stack: consoleError.stack,\n      source: ErrorSource.CONSOLE,\n      handling: ErrorHandling.HANDLED,\n      handlingStack: consoleError.handlingStack,\n    })\n  )\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n  }\n}\n","import type { RawError } from '../../tools/error'\nimport { ErrorSource, ErrorHandling, formatUnknownError } from '../../tools/error'\nimport type { Observable } from '../../tools/observable'\nimport { clocksNow } from '../../tools/timeUtils'\nimport { startUnhandledErrorCollection } from '../tracekit'\n\nexport function trackRuntimeError(errorObservable: Observable<RawError>) {\n  return startUnhandledErrorCollection((stackTrace, errorObject) => {\n    const { stack, message, type } = formatUnknownError(stackTrace, errorObject, 'Uncaught')\n    errorObservable.notify({\n      message,\n      stack,\n      type,\n      source: ErrorSource.SOURCE,\n      startClocks: clocksNow(),\n      originalError: errorObject,\n      handling: ErrorHandling.UNHANDLED,\n    })\n  })\n}\n","import type { Observable, RawError } from '@datadog/browser-core'\nimport { clocksNow, ErrorHandling, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core'\n\nexport function trackReportError(errorObservable: Observable<RawError>) {\n  const subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(\n    (reportError) =>\n      errorObservable.notify({\n        startClocks: clocksNow(),\n        message: reportError.message,\n        stack: reportError.stack,\n        type: reportError.subtype,\n        source: ErrorSource.REPORT,\n        handling: ErrorHandling.UNHANDLED,\n      })\n  )\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n  }\n}\n","import type { Duration, RelativeTime } from '@datadog/browser-core'\nimport type { RumPerformanceResourceTiming } from '../../../browser/performanceCollection'\nimport type { RequestCompleteEvent } from '../../requestCollection'\nimport { toValidEntry } from './resourceUtils'\n\ninterface Timing {\n  startTime: RelativeTime\n  duration: Duration\n}\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 * - Browsers generate a timing entry for OPTIONS request\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\n * - if two following timings match (OPTIONS request), return the timing for the actual request\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestTiming(request: RequestCompleteEvent) {\n  if (!performance || !('getEntriesByName' in performance)) {\n    return\n  }\n  const sameNameEntries = performance.getEntriesByName(request.url, 'resource')\n\n  if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n    return\n  }\n\n  const candidates = sameNameEntries\n    .map((entry) => entry.toJSON() as RumPerformanceResourceTiming)\n    .filter(toValidEntry)\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    return candidates[0]\n  }\n\n  if (candidates.length === 2 && firstCanBeOptionRequest(candidates)) {\n    return candidates[1]\n  }\n\n  return\n}\n\nfunction firstCanBeOptionRequest(correspondingEntries: RumPerformanceResourceTiming[]) {\n  return endTime(correspondingEntries[0]) <= correspondingEntries[1].startTime\n}\n\nfunction endTime(timing: Timing) {\n  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n  return (timing.startTime + timing.duration) as RelativeTime\n}\n\nfunction isBetween(timing: Timing, start: RelativeTime, end: RelativeTime) {\n  const errorMargin = 1\n  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n  return timing.startTime >= start - errorMargin && endTime(timing) <= end + errorMargin\n}\n","import {\n  combine,\n  generateUUID,\n  RequestType,\n  ResourceType,\n  toServerDuration,\n  relativeToClocks,\n  assign,\n} from '@datadog/browser-core'\nimport type { RumPerformanceEntry, RumPerformanceResourceTiming } from '../../../browser/performanceCollection'\nimport { supportPerformanceEntry } from '../../../browser/performanceCollection'\nimport type {\n  PerformanceEntryRepresentation,\n  RumXhrResourceEventDomainContext,\n  RumFetchResourceEventDomainContext,\n} from '../../../domainContext.types'\nimport type { RawRumResourceEvent } from '../../../rawRumEvent.types'\nimport { RumEventType } from '../../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { RequestCompleteEvent } from '../../requestCollection'\nimport { matchRequestTiming } from './matchRequestTiming'\nimport {\n  computePerformanceResourceDetails,\n  computePerformanceResourceDuration,\n  computeResourceKind,\n  computeSize,\n  isRequestKind,\n} from './resourceUtils'\n\nexport function startResourceCollection(lifeCycle: LifeCycle) {\n  lifeCycle.subscribe(LifeCycleEventType.REQUEST_COMPLETED, (request: RequestCompleteEvent) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processRequest(request))\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    for (const entry of entries) {\n      if (entry.entryType === 'resource' && !isRequestKind(entry)) {\n        lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processResourceEntry(entry))\n      }\n    }\n  })\n}\n\nfunction processRequest(request: RequestCompleteEvent): RawRumEventCollectedData<RawRumResourceEvent> {\n  const type = request.type === RequestType.XHR ? ResourceType.XHR : ResourceType.FETCH\n\n  const matchingTiming = matchRequestTiming(request)\n  const startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks\n  const correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined\n\n  const tracingInfo = computeRequestTracingInfo(request)\n\n  const resourceEvent = combine(\n    {\n      date: startClocks.timeStamp,\n      resource: {\n        id: generateUUID(),\n        type,\n        duration: toServerDuration(request.duration),\n        method: request.method,\n        status_code: request.status,\n        url: request.url,\n      },\n      type: RumEventType.RESOURCE as const,\n    },\n    tracingInfo,\n    correspondingTimingOverrides\n  )\n  return {\n    startTime: startClocks.relative,\n    rawRumEvent: resourceEvent,\n    domainContext: {\n      performanceEntry: matchingTiming && toPerformanceEntryRepresentation(matchingTiming),\n      xhr: request.xhr,\n      response: request.response,\n      requestInput: request.input,\n      requestInit: request.init,\n      error: request.error,\n    } as RumFetchResourceEventDomainContext | RumXhrResourceEventDomainContext,\n  }\n}\n\nfunction processResourceEntry(entry: RumPerformanceResourceTiming): RawRumEventCollectedData<RawRumResourceEvent> {\n  const type = computeResourceKind(entry)\n  const entryMetrics = computePerformanceEntryMetrics(entry)\n  const tracingInfo = computeEntryTracingInfo(entry)\n\n  const startClocks = relativeToClocks(entry.startTime)\n  const resourceEvent = combine(\n    {\n      date: startClocks.timeStamp,\n      resource: {\n        id: generateUUID(),\n        type,\n        url: entry.name,\n      },\n      type: RumEventType.RESOURCE as const,\n    },\n    tracingInfo,\n    entryMetrics\n  )\n  return {\n    startTime: startClocks.relative,\n    rawRumEvent: resourceEvent,\n    domainContext: {\n      performanceEntry: toPerformanceEntryRepresentation(entry),\n    },\n  }\n}\n\nfunction computePerformanceEntryMetrics(timing: RumPerformanceResourceTiming) {\n  return {\n    resource: assign(\n      {\n        duration: computePerformanceResourceDuration(timing),\n        size: computeSize(timing),\n      },\n      computePerformanceResourceDetails(timing)\n    ),\n  }\n}\n\nfunction computeRequestTracingInfo(request: RequestCompleteEvent) {\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!.toDecimalString(),\n      trace_id: request.traceId!.toDecimalString(),\n    },\n  }\n}\n\nfunction computeEntryTracingInfo(entry: RumPerformanceResourceTiming) {\n  return entry.traceId ? { _dd: { trace_id: entry.traceId } } : undefined\n}\n\nfunction toPerformanceEntryRepresentation(entry: RumPerformanceEntry): PerformanceEntryRepresentation {\n  if (supportPerformanceEntry() && entry instanceof PerformanceEntry) {\n    entry.toJSON()\n  }\n  return entry as PerformanceEntryRepresentation\n}\n","import type { Duration, EventEmitter, RelativeTime } from '@datadog/browser-core'\nimport { assign, addEventListeners, DOM_EVENT, elapsed, ONE_MINUTE, find, findLast } from '@datadog/browser-core'\n\nimport type { LifeCycle } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type {\n  RumFirstInputTiming,\n  RumLargestContentfulPaintTiming,\n  RumPerformancePaintTiming,\n} from '../../../browser/performanceCollection'\nimport { trackFirstHidden } from './trackFirstHidden'\n\n// Discard LCP and FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const TIMING_MAXIMUM_DELAY = 10 * ONE_MINUTE\n\nexport interface Timings {\n  firstContentfulPaint?: Duration\n  domInteractive?: Duration\n  domContentLoaded?: Duration\n  domComplete?: Duration\n  loadEvent?: Duration\n  largestContentfulPaint?: Duration\n  firstInputDelay?: Duration\n  firstInputTime?: Duration\n}\n\nexport function trackInitialViewTimings(lifeCycle: LifeCycle, callback: (timings: Timings) => void) {\n  const timings: Timings = {}\n  function setTimings(newTimings: Partial<Timings>) {\n    assign(timings, newTimings)\n    callback(timings)\n  }\n\n  const { stop: stopNavigationTracking } = trackNavigationTimings(lifeCycle, setTimings)\n  const { stop: stopFCPTracking } = trackFirstContentfulPaintTiming(lifeCycle, (firstContentfulPaint) =>\n    setTimings({ firstContentfulPaint })\n  )\n  const { stop: stopLCPTracking } = trackLargestContentfulPaintTiming(lifeCycle, window, (largestContentfulPaint) => {\n    setTimings({\n      largestContentfulPaint,\n    })\n  })\n  const { stop: stopFIDTracking } = trackFirstInputTimings(lifeCycle, ({ firstInputDelay, firstInputTime }) => {\n    setTimings({\n      firstInputDelay,\n      firstInputTime,\n    })\n  })\n\n  return {\n    stop: () => {\n      stopNavigationTracking()\n      stopFCPTracking()\n      stopLCPTracking()\n      stopFIDTracking()\n    },\n  }\n}\n\nexport function trackNavigationTimings(lifeCycle: LifeCycle, callback: (timings: Partial<Timings>) => void) {\n  const { unsubscribe: stop } = lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    for (const entry of entries) {\n      if (entry.entryType === 'navigation') {\n        callback({\n          domComplete: entry.domComplete,\n          domContentLoaded: entry.domContentLoadedEventEnd,\n          domInteractive: entry.domInteractive,\n          loadEvent: entry.loadEventEnd,\n        })\n      }\n    }\n  })\n\n  return { stop }\n}\n\nexport function trackFirstContentfulPaintTiming(lifeCycle: LifeCycle, callback: (fcpTiming: RelativeTime) => void) {\n  const firstHidden = trackFirstHidden()\n  const { unsubscribe: stop } = lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    const fcpEntry = find(\n      entries,\n      (entry): entry is RumPerformancePaintTiming =>\n        entry.entryType === 'paint' &&\n        entry.name === 'first-contentful-paint' &&\n        entry.startTime < firstHidden.timeStamp &&\n        entry.startTime < TIMING_MAXIMUM_DELAY\n    )\n    if (fcpEntry) {\n      callback(fcpEntry.startTime)\n    }\n  })\n  return { stop }\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/getLCP.ts\n */\nexport function trackLargestContentfulPaintTiming(\n  lifeCycle: LifeCycle,\n  emitter: EventEmitter,\n  callback: (lcpTiming: RelativeTime) => void\n) {\n  const firstHidden = trackFirstHidden()\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    emitter,\n    [DOM_EVENT.POINTER_DOWN, DOM_EVENT.KEY_DOWN],\n    (event) => {\n      firstInteractionTimestamp = event.timeStamp\n    },\n    { capture: true, once: true }\n  )\n\n  const { unsubscribe: unsubscribeLifeCycle } = lifeCycle.subscribe(\n    LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED,\n    (entries) => {\n      const lcpEntry = findLast(\n        entries,\n        (entry): entry is RumLargestContentfulPaintTiming =>\n          entry.entryType === 'largest-contentful-paint' &&\n          entry.startTime < firstInteractionTimestamp &&\n          entry.startTime < firstHidden.timeStamp &&\n          entry.startTime < TIMING_MAXIMUM_DELAY\n      )\n      if (lcpEntry) {\n        callback(lcpEntry.startTime)\n      }\n    }\n  )\n\n  return {\n    stop: () => {\n      stopEventListener()\n      unsubscribeLifeCycle()\n    },\n  }\n}\n\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInputTimings(\n  lifeCycle: LifeCycle,\n  callback: ({ firstInputDelay, firstInputTime }: { firstInputDelay: Duration; firstInputTime: Duration }) => void\n) {\n  const firstHidden = trackFirstHidden()\n\n  const { unsubscribe: stop } = lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    const firstInputEntry = find(\n      entries,\n      (entry): entry is RumFirstInputTiming =>\n        entry.entryType === 'first-input' && entry.startTime < firstHidden.timeStamp\n    )\n    if (firstInputEntry) {\n      const firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart)\n      callback({\n        // Ensure firstInputDelay to be positive, see\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n        firstInputDelay: firstInputDelay >= 0 ? firstInputDelay : (0 as Duration),\n        firstInputTime: firstInputEntry.startTime as Duration,\n      })\n    }\n  })\n\n  return {\n    stop,\n  }\n}\n","import type { Duration, RelativeTime, Observable, ClocksState } from '@datadog/browser-core'\nimport { noop, round, ONE_SECOND, elapsed } from '@datadog/browser-core'\nimport type { RumLayoutShiftTiming } from '../../../browser/performanceCollection'\nimport { supportPerformanceTimingEvent } from '../../../browser/performanceCollection'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { EventCounts } from '../../trackEventCounts'\nimport { trackEventCounts } from '../../trackEventCounts'\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd'\n\nexport interface ViewMetrics {\n  eventCounts: EventCounts\n  loadingTime?: Duration\n  cumulativeLayoutShift?: number\n}\n\nexport function trackViewMetrics(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  configuration: RumConfiguration,\n  scheduleViewUpdate: () => void,\n  loadingType: ViewLoadingType,\n  viewStart: ClocksState\n) {\n  const viewMetrics: ViewMetrics = {\n    eventCounts: {\n      errorCount: 0,\n      longTaskCount: 0,\n      resourceCount: 0,\n      actionCount: 0,\n      frustrationCount: 0,\n    },\n  }\n  const { stop: stopEventCountsTracking } = trackEventCounts(lifeCycle, (newEventCounts) => {\n    viewMetrics.eventCounts = newEventCounts\n    scheduleViewUpdate()\n  })\n\n  const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(\n    lifeCycle,\n    domMutationObservable,\n    configuration,\n    loadingType,\n    viewStart,\n    (newLoadingTime) => {\n      viewMetrics.loadingTime = newLoadingTime\n      scheduleViewUpdate()\n    }\n  )\n\n  let stopCLSTracking: () => void\n  if (isLayoutShiftSupported()) {\n    viewMetrics.cumulativeLayoutShift = 0\n    ;({ stop: stopCLSTracking } = trackCumulativeLayoutShift(lifeCycle, (cumulativeLayoutShift) => {\n      viewMetrics.cumulativeLayoutShift = cumulativeLayoutShift\n      scheduleViewUpdate()\n    }))\n  } else {\n    stopCLSTracking = noop\n  }\n  return {\n    stop: () => {\n      stopEventCountsTracking()\n      stopLoadingTimeTracking()\n      stopCLSTracking()\n    },\n    setLoadEvent,\n    viewMetrics,\n  }\n}\n\nfunction trackLoadingTime(\n  lifeCycle: LifeCycle,\n  domMutationObservable: 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\n  function invokeCallbackIfAllCandidatesAreReceived() {\n    if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n      callback(Math.max(...loadingTimeCandidates) as Duration)\n    }\n  }\n\n  const { stop } = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, (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  return {\n    stop,\n    setLoadEvent: (loadEvent: Duration) => {\n      if (isWaitingForLoadEvent) {\n        isWaitingForLoadEvent = false\n        loadingTimeCandidates.push(loadEvent)\n        invokeCallbackIfAllCandidatesAreReceived()\n      }\n    },\n  }\n}\n\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nfunction trackCumulativeLayoutShift(lifeCycle: LifeCycle, callback: (layoutShift: number) => void) {\n  let maxClsValue = 0\n  const window = slidingSessionWindow()\n  const { unsubscribe: stop } = lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    for (const entry of entries) {\n      if (entry.entryType === 'layout-shift' && !entry.hadRecentInput) {\n        window.update(entry)\n        if (window.value() > maxClsValue) {\n          maxClsValue = window.value()\n          callback(round(maxClsValue, 4))\n        }\n      }\n    }\n  })\n\n  return {\n    stop,\n  }\n}\n\nfunction slidingSessionWindow() {\n  let value = 0\n  let startTime: RelativeTime\n  let endTime: RelativeTime\n  return {\n    update: (entry: RumLayoutShiftTiming) => {\n      const shouldCreateNewWindow =\n        startTime === undefined ||\n        entry.startTime - endTime >= ONE_SECOND ||\n        entry.startTime - startTime >= 5 * ONE_SECOND\n      if (shouldCreateNewWindow) {\n        startTime = endTime = entry.startTime\n        value = entry.value\n      } else {\n        value += entry.value\n        endTime = entry.startTime\n      }\n    },\n    value: () => value,\n  }\n}\n\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nfunction isLayoutShiftSupported() {\n  return supportPerformanceTimingEvent('layout-shift')\n}\n","import type { Duration, ClocksState, TimeStamp, Observable, Subscription, RelativeTime } from '@datadog/browser-core'\nimport {\n  shallowClone,\n  assign,\n  elapsed,\n  generateUUID,\n  monitor,\n  ONE_MINUTE,\n  throttle,\n  clocksNow,\n  clocksOrigin,\n  timeStampNow,\n  display,\n  looksLikeRelativeTime,\n} from '@datadog/browser-core'\n\nimport type { ViewCustomTimings } from '../../../rawRumEvent.types'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\n\nimport type { LifeCycle } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { EventCounts } from '../../trackEventCounts'\nimport type { LocationChange } from '../../../browser/locationChangeObservable'\nimport type { RumConfiguration } from '../../configuration'\nimport type { Timings } from './trackInitialViewTimings'\nimport { trackInitialViewTimings } from './trackInitialViewTimings'\nimport { trackViewMetrics } from './trackViewMetrics'\n\nexport interface ViewEvent {\n  id: string\n  name?: string\n  service?: string\n  version?: string\n  location: Readonly<Location>\n  timings: Timings\n  customTimings: ViewCustomTimings\n  eventCounts: EventCounts\n  documentVersion: number\n  startClocks: ClocksState\n  duration: Duration\n  isActive: boolean\n  loadingTime?: Duration\n  loadingType: ViewLoadingType\n  cumulativeLayoutShift?: number\n}\n\nexport interface ViewCreatedEvent {\n  id: string\n  name?: string\n  service?: string\n  version?: string\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\nexport interface ViewOptions {\n  name?: string\n  service?: string\n  version?: string\n}\n\nexport function trackViews(\n  location: Location,\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<void>,\n  configuration: RumConfiguration,\n  locationChangeObservable: Observable<LocationChange>,\n  areViewsTrackedAutomatically: boolean,\n  initialViewOptions?: ViewOptions\n) {\n  const { stop: stopInitialViewTracking, initialView } = trackInitialView(initialViewOptions)\n  let currentView = initialView\n\n  const { stop: stopViewLifeCycle } = startViewLifeCycle()\n\n  let locationChangeSubscription: Subscription\n  if (areViewsTrackedAutomatically) {\n    locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable)\n  }\n\n  function trackInitialView(options?: ViewOptions) {\n    const initialView = newView(\n      lifeCycle,\n      domMutationObservable,\n      configuration,\n      location,\n      ViewLoadingType.INITIAL_LOAD,\n      clocksOrigin(),\n      options\n    )\n    const { stop } = trackInitialViewTimings(lifeCycle, (timings) => {\n      initialView.updateTimings(timings)\n      initialView.scheduleUpdate()\n    })\n    return { initialView, stop }\n  }\n\n  function trackViewChange(startClocks?: ClocksState, viewOptions?: ViewOptions) {\n    return newView(\n      lifeCycle,\n      domMutationObservable,\n      configuration,\n      location,\n      ViewLoadingType.ROUTE_CHANGE,\n      startClocks,\n      viewOptions\n    )\n  }\n\n  function startViewLifeCycle() {\n    lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n      // do not trigger view update to avoid wrong data\n      currentView.end()\n      // Renew view on session renewal\n      currentView = trackViewChange(undefined, {\n        name: currentView.name,\n        service: currentView.service,\n        version: currentView.version,\n      })\n    })\n\n    // End the current view on page unload\n    lifeCycle.subscribe(LifeCycleEventType.BEFORE_UNLOAD, () => {\n      currentView.end()\n      currentView.triggerUpdate()\n    })\n\n    // Session keep alive\n    const keepAliveInterval = window.setInterval(\n      monitor(() => {\n        currentView.triggerUpdate()\n      }),\n      SESSION_KEEP_ALIVE_INTERVAL\n    )\n\n    return {\n      stop: () => {\n        clearInterval(keepAliveInterval)\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.triggerUpdate()\n        currentView = trackViewChange()\n        return\n      }\n    })\n  }\n\n  return {\n    addTiming: (name: string, time: RelativeTime | TimeStamp = timeStampNow()) => {\n      currentView.addTiming(name, time)\n      currentView.scheduleUpdate()\n    },\n    startView: (options?: ViewOptions, startClocks?: ClocksState) => {\n      currentView.end(startClocks)\n      currentView.triggerUpdate()\n      currentView = trackViewChange(startClocks, options)\n    },\n    stop: () => {\n      locationChangeSubscription?.unsubscribe()\n      stopInitialViewTracking()\n      stopViewLifeCycle()\n      currentView.end()\n    },\n  }\n}\n\nfunction newView(\n  lifeCycle: LifeCycle,\n  domMutationObservable: 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  let timings: Timings = {}\n  const customTimings: ViewCustomTimings = {}\n  let documentVersion = 0\n  let endClocks: ClocksState | undefined\n  const location = shallowClone(initialLocation)\n\n  let name: string | undefined\n  let service: string | undefined\n  let version: string | undefined\n  if (viewOptions) {\n    name = viewOptions.name\n    service = viewOptions.service\n    version = viewOptions.version\n  }\n\n  lifeCycle.notify(LifeCycleEventType.VIEW_CREATED, { id, name, startClocks, service, version })\n\n  // Update the view every time the measures are changing\n  const { throttled: scheduleViewUpdate, cancel: cancelScheduleViewUpdate } = throttle(\n    monitor(triggerViewUpdate),\n    THROTTLE_VIEW_UPDATE_PERIOD,\n    {\n      leading: false,\n    }\n  )\n\n  const {\n    setLoadEvent,\n    stop: stopViewMetricsTracking,\n    viewMetrics,\n  } = trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, startClocks)\n\n  // Initial view update\n  triggerViewUpdate()\n\n  function triggerViewUpdate() {\n    documentVersion += 1\n    const currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp\n    lifeCycle.notify(\n      LifeCycleEventType.VIEW_UPDATED,\n      assign(\n        {\n          customTimings,\n          documentVersion,\n          id,\n          name,\n          service,\n          version,\n          loadingType,\n          location,\n          startClocks,\n          timings,\n          duration: elapsed(startClocks.timeStamp, currentEnd),\n          isActive: endClocks === undefined,\n        },\n        viewMetrics\n      )\n    )\n  }\n\n  return {\n    name,\n    service,\n    version,\n    scheduleUpdate: scheduleViewUpdate,\n    end(clocks = clocksNow()) {\n      endClocks = clocks\n      lifeCycle.notify(LifeCycleEventType.VIEW_ENDED, { endClocks })\n      stopViewMetricsTracking()\n    },\n    triggerUpdate() {\n      // cancel any pending view updates execution\n      cancelScheduleViewUpdate()\n      triggerViewUpdate()\n    },\n    updateTimings(newTimings: Timings) {\n      timings = newTimings\n      if (newTimings.loadEvent !== undefined) {\n        setLoadEvent(newTimings.loadEvent)\n      }\n    },\n    addTiming(name: string, time: RelativeTime | TimeStamp) {\n      const relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time)\n      customTimings[sanitizeTiming(name)] = relativeTime\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.substr(1)\n  return !!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, isNumber } from '@datadog/browser-core'\nimport type { RecorderApi } from '../../../boot/rumPublicApi'\nimport type { RawRumViewEvent } from '../../../rawRumEvent.types'\nimport { RumEventType } from '../../../rawRumEvent.types'\nimport type { LifeCycle, RawRumEventCollectedData } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { ForegroundContexts } from '../../contexts/foregroundContexts'\nimport type { LocationChange } from '../../../browser/locationChangeObservable'\nimport type { RumConfiguration } from '../../configuration'\nimport type { ViewEvent, ViewOptions } from './trackViews'\nimport { trackViews } from './trackViews'\n\nexport function startViewCollection(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  location: Location,\n  domMutationObservable: Observable<void>,\n  locationChangeObservable: Observable<LocationChange>,\n  foregroundContexts: ForegroundContexts,\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, foregroundContexts, recorderApi)\n    )\n  )\n\n  return trackViews(\n    location,\n    lifeCycle,\n    domMutationObservable,\n    configuration,\n    locationChangeObservable,\n    !configuration.trackViewsManually,\n    initialViewOptions\n  )\n}\n\nfunction processViewUpdate(\n  view: ViewEvent,\n  foregroundContexts: ForegroundContexts,\n  recorderApi: RecorderApi\n): RawRumEventCollectedData<RawRumViewEvent> {\n  const replayStats = recorderApi.getReplayStats(view.id)\n  const viewEvent: RawRumViewEvent = {\n    _dd: {\n      document_version: view.documentVersion,\n      replay_stats: replayStats,\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.cumulativeLayoutShift,\n      dom_complete: toServerDuration(view.timings.domComplete),\n      dom_content_loaded: toServerDuration(view.timings.domContentLoaded),\n      dom_interactive: toServerDuration(view.timings.domInteractive),\n      error: {\n        count: view.eventCounts.errorCount,\n      },\n      first_contentful_paint: toServerDuration(view.timings.firstContentfulPaint),\n      first_input_delay: toServerDuration(view.timings.firstInputDelay),\n      first_input_time: toServerDuration(view.timings.firstInputTime),\n      is_active: view.isActive,\n      name: view.name,\n      largest_contentful_paint: toServerDuration(view.timings.largestContentfulPaint),\n      load_event: toServerDuration(view.timings.loadEvent),\n      loading_time: discardNegativeDuration(toServerDuration(view.loadingTime)),\n      loading_type: view.loadingType,\n      long_task: {\n        count: view.eventCounts.longTaskCount,\n      },\n      resource: {\n        count: view.eventCounts.resourceCount,\n      },\n      time_spent: toServerDuration(view.duration),\n      in_foreground_periods: foregroundContexts.selectInForegroundPeriodsFor(view.startClocks.relative, view.duration),\n    },\n    session: {\n      has_replay: replayStats ? true : undefined,\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  return {\n    rawRumEvent: viewEvent,\n    startTime: view.startClocks.relative,\n    domainContext: {\n      location: view.location,\n    },\n  }\n}\n\nfunction discardNegativeDuration(duration: ServerDuration | undefined): ServerDuration | undefined {\n  return isNumber(duration) && duration < 0 ? undefined : duration\n}\n","import type { CookieOptions } from '../../browser/cookie'\nimport { getCookie, setCookie } from '../../browser/cookie'\nimport { isChromium } from '../../tools/browserDetection'\nimport { monitor } from '../../tools/monitor'\nimport { dateNow } from '../../tools/timeUtils'\nimport * as utils from '../../tools/utils'\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants'\nimport type { SessionState } from './sessionStore'\n\nconst SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/\nconst SESSION_ENTRY_SEPARATOR = '&'\n\nexport const SESSION_COOKIE_NAME = '_dd_s'\n\n// arbitrary values\nexport const LOCK_RETRY_DELAY = 10\nexport const MAX_NUMBER_OF_LOCK_RETRIES = 100\n\ntype Operations = {\n  options: CookieOptions\n  process: (cookieSession: SessionState) => SessionState | undefined\n  after?: (cookieSession: SessionState) => void\n}\n\nconst bufferedOperations: Operations[] = []\nlet ongoingOperations: Operations | undefined\n\nexport function withCookieLockAccess(operations: Operations, numberOfRetries = 0) {\n  if (!ongoingOperations) {\n    ongoingOperations = operations\n  }\n  if (operations !== ongoingOperations) {\n    bufferedOperations.push(operations)\n    return\n  }\n  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {\n    next()\n    return\n  }\n  let currentLock: string\n  let currentSession = retrieveSession()\n  if (isCookieLockEnabled()) {\n    // if someone has lock, retry later\n    if (currentSession.lock) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n    // acquire lock\n    currentLock = utils.generateUUID()\n    currentSession.lock = currentLock\n    setSession(currentSession, operations.options)\n    // if lock is not acquired, retry later\n    currentSession = retrieveSession()\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n  }\n  let processedSession = operations.process(currentSession)\n  if (isCookieLockEnabled()) {\n    // if lock corrupted after process, retry later\n    currentSession = retrieveSession()\n    if (currentSession.lock !== currentLock!) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n  }\n  if (processedSession) {\n    persistSession(processedSession, operations.options)\n  }\n  if (isCookieLockEnabled()) {\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 && isExpiredState(processedSession))) {\n      // if lock corrupted after persist, retry later\n      currentSession = retrieveSession()\n      if (currentSession.lock !== currentLock!) {\n        retryLater(operations, numberOfRetries)\n        return\n      }\n      delete currentSession.lock\n      setSession(currentSession, operations.options)\n      processedSession = currentSession\n    }\n  }\n  // call after even if session is not persisted in order to perform operations on\n  // up-to-date cookie value, the value could have been modified by another tab\n  operations.after?.(processedSession || currentSession)\n  next()\n}\n\n/**\n * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.\n * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.\n */\nfunction isCookieLockEnabled() {\n  return isChromium()\n}\n\nfunction retryLater(operations: Operations, currentNumberOfRetries: number) {\n  setTimeout(\n    monitor(() => {\n      withCookieLockAccess(operations, currentNumberOfRetries + 1)\n    }),\n    LOCK_RETRY_DELAY\n  )\n}\n\nfunction next() {\n  ongoingOperations = undefined\n  const nextOperations = bufferedOperations.shift()\n  if (nextOperations) {\n    withCookieLockAccess(nextOperations)\n  }\n}\n\nexport function persistSession(session: SessionState, options: CookieOptions) {\n  if (isExpiredState(session)) {\n    clearSession(options)\n    return\n  }\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)\n  setSession(session, options)\n}\n\nfunction setSession(session: SessionState, options: CookieOptions) {\n  setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options)\n}\n\nexport function toSessionString(session: SessionState) {\n  return utils\n    .objectEntries(session)\n    .map(([key, value]) => `${key}=${value as string}`)\n    .join(SESSION_ENTRY_SEPARATOR)\n}\n\nexport function retrieveSession(): SessionState {\n  const sessionString = getCookie(SESSION_COOKIE_NAME)\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        session[key] = value\n      }\n    })\n  }\n  return session\n}\n\nfunction isValidSessionString(sessionString: string | undefined): sessionString is string {\n  return (\n    sessionString !== undefined &&\n    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))\n  )\n}\n\nfunction isExpiredState(session: SessionState) {\n  return utils.isEmptyObject(session)\n}\n\nfunction clearSession(options: CookieOptions) {\n  setCookie(SESSION_COOKIE_NAME, '', 0, options)\n}\n","import type { CookieOptions } from '../../browser/cookie'\nimport { getCookie } from '../../browser/cookie'\nimport type { SessionState } from './sessionStore'\nimport { SESSION_COOKIE_NAME, persistSession } from './sessionCookieStore'\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(options: CookieOptions) {\n  const sessionString = getCookie(SESSION_COOKIE_NAME)\n  const oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME)\n  const oldRumType = getCookie(OLD_RUM_COOKIE_NAME)\n  const oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME)\n  if (!sessionString) {\n    const session: SessionState = {}\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    persistSession(session, options)\n  }\n}\n","import type { CookieOptions } from '../../browser/cookie'\nimport type { Observable } from '../../tools/observable'\nimport * as utils from '../../tools/utils'\nimport type { Context } from '../../tools/context'\nimport { ContextHistory } from '../../tools/contextHistory'\nimport type { RelativeTime } from '../../tools/timeUtils'\nimport { relativeNow, clocksOrigin } from '../../tools/timeUtils'\nimport { monitor } from '../../tools/monitor'\nimport { tryOldCookiesMigration } from './oldCookiesMigration'\nimport { startSessionStore } from './sessionStore'\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants'\n\nexport interface SessionManager<TrackingType extends string> {\n  findActiveSession: (startTime?: RelativeTime) => SessionContext<TrackingType> | undefined\n  renewObservable: Observable<void>\n  expireObservable: Observable<void>\n}\n\nexport interface SessionContext<TrackingType extends string> extends Context {\n  id: string\n  trackingType: TrackingType\n}\n\nexport const VISIBILITY_CHECK_DELAY = utils.ONE_MINUTE\nconst SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY\nlet stopCallbacks: Array<() => void> = []\n\nexport function startSessionManager<TrackingType extends string>(\n  options: CookieOptions,\n  productKey: string,\n  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean }\n): SessionManager<TrackingType> {\n  tryOldCookiesMigration(options)\n  const sessionStore = startSessionStore(options, productKey, computeSessionState)\n  stopCallbacks.push(() => sessionStore.stop())\n\n  const sessionContextHistory = new ContextHistory<SessionContext<TrackingType>>(SESSION_CONTEXT_TIMEOUT_DELAY)\n  stopCallbacks.push(() => sessionContextHistory.stop())\n\n  sessionStore.renewObservable.subscribe(() => {\n    sessionContextHistory.add(buildSessionContext(), relativeNow())\n  })\n  sessionStore.expireObservable.subscribe(() => {\n    sessionContextHistory.closeActive(relativeNow())\n  })\n\n  sessionStore.expandOrRenewSession()\n  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)\n\n  trackActivity(() => sessionStore.expandOrRenewSession())\n  trackVisibility(() => sessionStore.expandSession())\n\n  function buildSessionContext() {\n    return {\n      id: sessionStore.getSession().id!,\n      trackingType: sessionStore.getSession()[productKey] as TrackingType,\n    }\n  }\n\n  return {\n    findActiveSession: (startTime) => sessionContextHistory.find(startTime),\n    renewObservable: sessionStore.renewObservable,\n    expireObservable: sessionStore.expireObservable,\n  }\n}\n\nexport function stopSessionManager() {\n  stopCallbacks.forEach((e) => e())\n  stopCallbacks = []\n}\n\nfunction trackActivity(expandOrRenewSession: () => void) {\n  const { stop } = utils.addEventListeners(\n    window,\n    [utils.DOM_EVENT.CLICK, utils.DOM_EVENT.TOUCH_START, utils.DOM_EVENT.KEY_DOWN, utils.DOM_EVENT.SCROLL],\n    expandOrRenewSession,\n    { capture: true, passive: true }\n  )\n  stopCallbacks.push(stop)\n}\n\nfunction trackVisibility(expandSession: () => void) {\n  const expandSessionWhenVisible = monitor(() => {\n    if (document.visibilityState === 'visible') {\n      expandSession()\n    }\n  })\n\n  const { stop } = utils.addEventListener(document, utils.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","import type { CookieOptions } from '../../browser/cookie'\nimport { COOKIE_ACCESS_DELAY } from '../../browser/cookie'\nimport { monitor } from '../../tools/monitor'\nimport { Observable } from '../../tools/observable'\nimport { dateNow } from '../../tools/timeUtils'\nimport * as utils from '../../tools/utils'\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants'\nimport { retrieveSession, withCookieLockAccess } from './sessionCookieStore'\n\nexport interface SessionStore {\n  expandOrRenewSession: () => void\n  expandSession: () => void\n  getSession: () => SessionState\n  renewObservable: Observable<void>\n  expireObservable: Observable<void>\n  stop: () => void\n}\n\nexport interface SessionState {\n  id?: string\n  created?: string\n  expire?: string\n  lock?: string\n\n  [key: string]: string | undefined\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  options: CookieOptions,\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\n  const watchSessionTimeoutId = setInterval(monitor(watchSession), COOKIE_ACCESS_DELAY)\n  let sessionCache: SessionState = retrieveActiveSession()\n\n  function expandOrRenewSession() {\n    let isTracked: boolean\n    withCookieLockAccess({\n      options,\n      process: (cookieSession) => {\n        const synchronizedSession = synchronizeSession(cookieSession)\n        isTracked = expandOrRenewCookie(synchronizedSession)\n        return synchronizedSession\n      },\n      after: (cookieSession) => {\n        if (isTracked && !hasSessionInCache()) {\n          renewSession(cookieSession)\n        }\n        sessionCache = cookieSession\n      },\n    })\n  }\n\n  function expandSession() {\n    withCookieLockAccess({\n      options,\n      process: (cookieSession) => (hasSessionInCache() ? synchronizeSession(cookieSession) : undefined),\n    })\n  }\n\n  /**\n   * allows two behaviors:\n   * - if the session is active, synchronize the session cache without updating the session cookie\n   * - if the session is not active, clear the session cookie and expire the session cache\n   */\n  function watchSession() {\n    withCookieLockAccess({\n      options,\n      process: (cookieSession) => (!isActiveSession(cookieSession) ? {} : undefined),\n      after: synchronizeSession,\n    })\n  }\n\n  function synchronizeSession(cookieSession: SessionState) {\n    if (!isActiveSession(cookieSession)) {\n      cookieSession = {}\n    }\n    if (hasSessionInCache()) {\n      if (isSessionInCacheOutdated(cookieSession)) {\n        expireSession()\n      } else {\n        sessionCache = cookieSession\n      }\n    }\n    return cookieSession\n  }\n\n  function expandOrRenewCookie(cookieSession: SessionState) {\n    const { trackingType, isTracked } = computeSessionState(cookieSession[productKey])\n    cookieSession[productKey] = trackingType\n    if (isTracked && !cookieSession.id) {\n      cookieSession.id = utils.generateUUID()\n      cookieSession.created = String(dateNow())\n    }\n    return isTracked\n  }\n\n  function hasSessionInCache() {\n    return sessionCache[productKey] !== undefined\n  }\n\n  function isSessionInCacheOutdated(cookieSession: SessionState) {\n    return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey]\n  }\n\n  function expireSession() {\n    sessionCache = {}\n    expireObservable.notify()\n  }\n\n  function renewSession(cookieSession: SessionState) {\n    sessionCache = cookieSession\n    renewObservable.notify()\n  }\n\n  function retrieveActiveSession(): SessionState {\n    const session = retrieveSession()\n    if (isActiveSession(session)) {\n      return session\n    }\n    return {}\n  }\n\n  function isActiveSession(session: 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      (session.created === undefined || dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&\n      (session.expire === undefined || dateNow() < Number(session.expire))\n    )\n  }\n\n  return {\n    expandOrRenewSession: utils.throttle(monitor(expandOrRenewSession), COOKIE_ACCESS_DELAY).throttled,\n    expandSession,\n    getSession: () => sessionCache,\n    renewObservable,\n    expireObservable,\n    stop: () => {\n      clearInterval(watchSessionTimeoutId)\n    },\n  }\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport { performDraw, startSessionManager } 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}\n\nexport type RumSession = {\n  id: string\n  hasPremiumPlan: boolean\n  hasLitePlan: boolean\n}\n\nexport const enum RumSessionPlan {\n  LITE = 1,\n  PREMIUM = 2,\n}\n\nexport const enum RumTrackingType {\n  NOT_TRACKED = '0',\n  // Note: the \"tracking type\" value (stored in the session cookie) does not match the \"session\n  // plan\" value (sent in RUM events). This is expected, and was done to keep retrocompatibility\n  // with active sessions when upgrading the SDK.\n  TRACKED_PREMIUM = '1',\n  TRACKED_LITE = '2',\n}\n\nexport function startRumSessionManager(configuration: RumConfiguration, lifeCycle: LifeCycle): RumSessionManager {\n  const sessionManager = startSessionManager(configuration.cookieOptions, RUM_SESSION_KEY, (rawTrackingType) =>\n    computeSessionState(configuration, rawTrackingType)\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  return {\n    findTrackedSession: (startTime) => {\n      const session = sessionManager.findActiveSession(startTime)\n      if (!session || !isTypeTracked(session.trackingType)) {\n        return\n      }\n      return {\n        id: session.id,\n        hasPremiumPlan: session.trackingType === RumTrackingType.TRACKED_PREMIUM,\n        hasLitePlan: session.trackingType === RumTrackingType.TRACKED_LITE,\n      }\n    },\n  }\n}\n\n/**\n * Start a tracked replay session stub\n * It needs to be a premium plan in order to get long tasks\n */\nexport function startRumSessionManagerStub(): RumSessionManager {\n  const session = {\n    id: '00000000-aaaa-0000-aaaa-000000000000',\n    hasPremiumPlan: true,\n    hasLitePlan: false,\n  }\n  return {\n    findTrackedSession: () => session,\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.sampleRate)) {\n    trackingType = RumTrackingType.NOT_TRACKED\n  } else if (!performDraw(configuration.premiumSampleRate)) {\n    trackingType = RumTrackingType.TRACKED_LITE\n  } else {\n    trackingType = RumTrackingType.TRACKED_PREMIUM\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_PREMIUM ||\n    trackingType === RumTrackingType.TRACKED_LITE\n  )\n}\n\nfunction isTypeTracked(rumSessionType: RumTrackingType | undefined) {\n  return rumSessionType === RumTrackingType.TRACKED_LITE || rumSessionType === RumTrackingType.TRACKED_PREMIUM\n}\n","import { display } from '../tools/display'\nimport type { Context } from '../tools/context'\nimport { addEventListener, DOM_EVENT, jsonStringify, noop, objectValues } from '../tools/utils'\nimport { monitor } from '../tools/monitor'\nimport type { HttpRequest } from './httpRequest'\n\n// https://en.wikipedia.org/wiki/UTF-8\n// eslint-disable-next-line no-control-regex\nconst HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/\n\nexport class Batch {\n  private pushOnlyBuffer: string[] = []\n  private upsertBuffer: { [key: string]: string } = {}\n  private bufferBytesCount = 0\n  private bufferMessagesCount = 0\n\n  constructor(\n    private request: HttpRequest,\n    private batchMessagesLimit: number,\n    private batchBytesLimit: number,\n    private messageBytesLimit: number,\n    private flushTimeout: number,\n    private beforeUnloadCallback: () => void = noop\n  ) {\n    this.flushOnVisibilityHidden()\n    this.flushPeriodically()\n  }\n\n  add(message: Context) {\n    this.addOrUpdate(message)\n  }\n\n  upsert(message: Context, key: string) {\n    this.addOrUpdate(message, key)\n  }\n\n  flush() {\n    if (this.bufferMessagesCount !== 0) {\n      const messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer))\n      const bytesCount = this.bufferBytesCount\n\n      this.pushOnlyBuffer = []\n      this.upsertBuffer = {}\n      this.bufferBytesCount = 0\n      this.bufferMessagesCount = 0\n\n      this.request.send(messages.join('\\n'), bytesCount)\n    }\n  }\n\n  computeBytesCount(candidate: string) {\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\n  private addOrUpdate(message: Context, key?: string) {\n    const { processedMessage, messageBytesCount } = this.process(message)\n    if (messageBytesCount >= this.messageBytesLimit) {\n      display.warn(\n        `Discarded a message whose size was bigger than the maximum allowed size ${this.messageBytesLimit}KB.`\n      )\n      return\n    }\n    if (this.hasMessageFor(key)) {\n      this.remove(key)\n    }\n    if (this.willReachedBytesLimitWith(messageBytesCount)) {\n      this.flush()\n    }\n\n    this.push(processedMessage, messageBytesCount, key)\n    if (this.isFull()) {\n      this.flush()\n    }\n  }\n\n  private process(message: Context) {\n    const processedMessage = jsonStringify(message)!\n    const messageBytesCount = this.computeBytesCount(processedMessage)\n    return { processedMessage, messageBytesCount }\n  }\n\n  private push(processedMessage: string, messageBytesCount: number, key?: string) {\n    if (this.bufferMessagesCount > 0) {\n      // \\n separator at serialization\n      this.bufferBytesCount += 1\n    }\n    if (key !== undefined) {\n      this.upsertBuffer[key] = processedMessage\n    } else {\n      this.pushOnlyBuffer.push(processedMessage)\n    }\n    this.bufferBytesCount += messageBytesCount\n    this.bufferMessagesCount += 1\n  }\n\n  private remove(key: string) {\n    const removedMessage = this.upsertBuffer[key]\n    delete this.upsertBuffer[key]\n    const messageBytesCount = this.computeBytesCount(removedMessage)\n    this.bufferBytesCount -= messageBytesCount\n    this.bufferMessagesCount -= 1\n    if (this.bufferMessagesCount > 0) {\n      this.bufferBytesCount -= 1\n    }\n  }\n\n  private hasMessageFor(key?: string): key is string {\n    return key !== undefined && this.upsertBuffer[key] !== undefined\n  }\n\n  private willReachedBytesLimitWith(messageBytesCount: number) {\n    // byte of the separator at the end of the message\n    return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit\n  }\n\n  private isFull() {\n    return this.bufferMessagesCount === this.batchMessagesLimit || this.bufferBytesCount >= this.batchBytesLimit\n  }\n\n  private flushPeriodically() {\n    setTimeout(\n      monitor(() => {\n        this.flush()\n        this.flushPeriodically()\n      }),\n      this.flushTimeout\n    )\n  }\n\n  private flushOnVisibilityHidden() {\n    /**\n     * With sendBeacon, requests are guaranteed to be successfully sent during document unload\n     */\n    // @ts-ignore this function is not always defined\n    if (navigator.sendBeacon) {\n      /**\n       * beforeunload is called before visibilitychange\n       * register first to be sure to be called before flush on beforeunload\n       * caveat: unload can still be canceled by another listener\n       */\n      addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, this.beforeUnloadCallback)\n\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      addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, () => {\n        if (document.visibilityState === 'hidden') {\n          this.flush()\n        }\n      })\n      /**\n       * Safari does not support yet to send a request during:\n       * - a visibility change during doc unload (cf: https://bugs.webkit.org/show_bug.cgi?id=194897)\n       * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)\n       */\n      addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, () => this.flush())\n    }\n  }\n}\n","import type { EndpointBuilder } from '../domain/configuration'\nimport { addTelemetryError } from '../domain/telemetry'\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 */\nexport class HttpRequest {\n  constructor(private endpointBuilder: EndpointBuilder, private bytesLimit: number) {}\n\n  send(data: string | FormData, bytesCount: number) {\n    const url = this.endpointBuilder.build()\n    const canUseBeacon = !!navigator.sendBeacon && bytesCount < this.bytesLimit\n    if (canUseBeacon) {\n      try {\n        const isQueued = navigator.sendBeacon(url, data)\n\n        if (isQueued) {\n          return\n        }\n      } catch (e) {\n        reportBeaconError(e)\n      }\n    }\n\n    const request = new XMLHttpRequest()\n    request.open('POST', url, true)\n    request.send(data)\n  }\n}\n\nlet hasReportedBeaconError = false\nfunction reportBeaconError(e: unknown) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true\n    addTelemetryError(e)\n  }\n}\n","import type { RelativeTime, Observable } from '@datadog/browser-core'\nimport { SESSION_TIME_OUT_DELAY, relativeNow, ContextHistory } 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 = new ContextHistory<UrlContext>(URL_CONTEXT_TIME_OUT_DELAY)\n\n  let previousViewUrl: string | undefined\n\n  lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, ({ endClocks }) => {\n    urlContextHistory.closeActive(endClocks.relative)\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.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  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 type * as SessionReplay from './sessionReplay'\n\nexport const RecordType: {\n  FullSnapshot: SessionReplay.BrowserFullSnapshotRecord['type']\n  IncrementalSnapshot: SessionReplay.BrowserIncrementalSnapshotRecord['type']\n  Meta: SessionReplay.MetaRecord['type']\n  Focus: SessionReplay.FocusRecord['type']\n  ViewEnd: SessionReplay.ViewEndRecord['type']\n  VisualViewport: SessionReplay.VisualViewportRecord['type']\n  FrustrationRecord: SessionReplay.FrustrationRecord['type']\n} = {\n  FullSnapshot: 2,\n  IncrementalSnapshot: 3,\n  Meta: 4,\n  Focus: 6,\n  ViewEnd: 7,\n  VisualViewport: 8,\n  FrustrationRecord: 9,\n} as const\n\nexport type RecordType = typeof RecordType[keyof typeof RecordType]\n\nexport const NodeType: {\n  Document: SessionReplay.DocumentNode['type']\n  DocumentType: SessionReplay.DocumentTypeNode['type']\n  Element: SessionReplay.ElementNode['type']\n  Text: SessionReplay.TextNode['type']\n  CDATA: SessionReplay.CDataNode['type']\n} = {\n  Document: 0,\n  DocumentType: 1,\n  Element: 2,\n  Text: 3,\n  CDATA: 4,\n} as const\n\nexport type NodeType = typeof NodeType[keyof typeof NodeType]\n\nexport const IncrementalSource: {\n  Mutation: SessionReplay.BrowserMutationData['source']\n  MouseMove: Exclude<SessionReplay.MousemoveData['source'], 6>\n  MouseInteraction: SessionReplay.MouseInteractionData['source']\n  Scroll: SessionReplay.ScrollData['source']\n  ViewportResize: SessionReplay.ViewportResizeData['source']\n  Input: SessionReplay.InputData['source']\n  TouchMove: Exclude<SessionReplay.MousemoveData['source'], 1>\n  MediaInteraction: SessionReplay.MediaInteractionData['source']\n  StyleSheetRule: SessionReplay.StyleSheetRuleData['source']\n} = {\n  Mutation: 0,\n  MouseMove: 1,\n  MouseInteraction: 2,\n  Scroll: 3,\n  ViewportResize: 4,\n  Input: 5,\n  TouchMove: 6,\n  MediaInteraction: 7,\n  StyleSheetRule: 8,\n  // CanvasMutation : 9,\n  // Font : 10,\n} as const\n\nexport type IncrementalSource = typeof IncrementalSource[keyof typeof IncrementalSource]\n\nexport const MouseInteractionType = {\n  MouseUp: 0,\n  MouseDown: 1,\n  Click: 2,\n  ContextMenu: 3,\n  DblClick: 4,\n  Focus: 5,\n  Blur: 6,\n  TouchStart: 7,\n  TouchEnd: 9,\n} as const\n\nexport type MouseInteractionType = typeof MouseInteractionType[keyof typeof MouseInteractionType]\n\nexport const MediaInteractionType = {\n  Play: 0,\n  Pause: 1,\n} as const\n\nexport type MediaInteractionType = typeof MediaInteractionType[keyof typeof MediaInteractionType]\n","import { DefaultPrivacyLevel } from '@datadog/browser-core'\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_ALLOW = 'dd-privacy-allow'\nexport const PRIVACY_CLASS_MASK = 'dd-privacy-mask'\nexport const PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input'\nexport const PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden'\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","import {\n  NodePrivacyLevel,\n  PRIVACY_ATTR_NAME,\n  PRIVACY_ATTR_VALUE_ALLOW,\n  PRIVACY_ATTR_VALUE_MASK,\n  PRIVACY_ATTR_VALUE_MASK_USER_INPUT,\n  PRIVACY_ATTR_VALUE_HIDDEN,\n  PRIVACY_CLASS_ALLOW,\n  PRIVACY_CLASS_MASK,\n  PRIVACY_CLASS_MASK_USER_INPUT,\n  PRIVACY_CLASS_HIDDEN,\n  FORM_PRIVATE_TAG_NAMES,\n  CENSORED_STRING_MARK,\n} from '../../constants'\n\nexport const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100_000\n\nconst TEXT_MASKING_CHAR = 'x'\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(node: Node, defaultPrivacyLevel: NodePrivacyLevel): NodePrivacyLevel {\n  const parentNodePrivacyLevel = node.parentNode\n    ? getNodePrivacyLevel(node.parentNode, defaultPrivacyLevel)\n    : defaultPrivacyLevel\n  const selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node)\n  return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel)\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 (!isElement(node)) {\n    return\n  }\n\n  const privAttr = node.getAttribute(PRIVACY_ATTR_NAME)\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]\n    if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n      return NodePrivacyLevel.MASK\n    }\n  }\n\n  // Check HTML privacy attributes and classes\n  if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n    return NodePrivacyLevel.HIDDEN\n  }\n\n  if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n    return NodePrivacyLevel.MASK\n  }\n\n  if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n    return NodePrivacyLevel.MASK_USER_INPUT\n  }\n\n  if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_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 isElement(node: Node): node is Element {\n  return node.nodeType === node.ELEMENT_NODE\n}\n\nfunction isTextNode(node: Node): node is Text {\n  return node.nodeType === node.TEXT_NODE\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 isStyle = parentTagName === 'STYLE' ? true : undefined\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 (\n    shouldMaskNode(textNode, nodePrivacyLevel) &&\n    // Style tags are `overruled` (Use `hide` to enforce privacy)\n    !isStyle\n  ) {\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      // Scripts\n      (relAttribute === 'preload' && 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","import type { NodePrivacyLevel } from '../../constants'\nimport { CENSORED_STRING_MARK } from '../../constants'\nimport { shouldMaskNode } from './privacy'\n\nexport type NodeWithSerializedNode = Node & { s: 'Node with serialized node' }\n\nconst serializedNodeIds = new WeakMap<Node, number>()\n\nexport function hasSerializedNode(node: Node): node is NodeWithSerializedNode {\n  return serializedNodeIds.has(node)\n}\n\nexport function nodeAndAncestorsHaveSerializedNode(node: Node): node is NodeWithSerializedNode {\n  let current: Node | null = node\n  while (current) {\n    if (!hasSerializedNode(current)) {\n      return false\n    }\n    current = current.parentNode\n  }\n  return true\n}\n\nexport function getSerializedNodeId(node: NodeWithSerializedNode): number\nexport function getSerializedNodeId(node: Node): number | undefined\nexport function getSerializedNodeId(node: Node) {\n  return serializedNodeIds.get(node)\n}\n\nexport function setSerializedNodeId(node: Node, serializeNodeId: number) {\n  serializedNodeIds.set(node, serializeNodeId)\n}\n\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element: Element, nodePrivacyLevel: NodePrivacyLevel) {\n  /*\n   BROWSER SPEC NOTE: <input>, <select>\n   For some <input> elements, the `value` is an exceptional property/attribute that has the\n   value synced between el.value and el.getAttribute()\n   input[type=button,checkbox,hidden,image,radio,reset,submit]\n   */\n  const tagName = element.tagName\n  const value = (element as HTMLInputElement | HTMLTextAreaElement).value\n\n  if (shouldMaskNode(element, nodePrivacyLevel)) {\n    const type = (element as HTMLInputElement | HTMLTextAreaElement).type\n    if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n      // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n      // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n      return value\n    } else if (!value || tagName === 'OPTION') {\n      // <Option> value provides no benefit\n      return\n    }\n    return CENSORED_STRING_MARK\n  }\n\n  if (tagName === 'OPTION' || tagName === 'SELECT') {\n    return (element as HTMLOptionElement | HTMLSelectElement).value\n  }\n\n  if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n    return\n  }\n\n  return value\n}\n","import { assign, timeStampNow } from '@datadog/browser-core'\nimport type { BrowserIncrementalData, BrowserIncrementalSnapshotRecord } from '../../types'\nimport { RecordType } from '../../types'\n\nexport function isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent {\n  return Boolean((event as TouchEvent).changedTouches)\n}\n\nexport function forEach<List extends { [index: number]: any }>(\n  list: List,\n  callback: (value: List[number], index: number, parent: List) => void\n) {\n  Array.prototype.forEach.call(list, callback as any)\n}\n\nexport function assembleIncrementalSnapshot<Data extends BrowserIncrementalData>(\n  source: Data['source'],\n  data: Omit<Data, 'source'>\n): BrowserIncrementalSnapshotRecord {\n  return {\n    data: assign(\n      {\n        source,\n      },\n      data\n    ) as Data,\n    type: RecordType.IncrementalSnapshot,\n    timestamp: timeStampNow(),\n  }\n}\n","import { assign } from '@datadog/browser-core'\nimport {\n  NodePrivacyLevel,\n  PRIVACY_ATTR_NAME,\n  PRIVACY_ATTR_VALUE_HIDDEN,\n  CENSORED_STRING_MARK,\n  CENSORED_IMG_MARK,\n} from '../../constants'\nimport type {\n  SerializedNode,\n  SerializedNodeWithId,\n  DocumentNode,\n  DocumentTypeNode,\n  ElementNode,\n  TextNode,\n  CDataNode,\n} from '../../types'\nimport { NodeType } from '../../types'\nimport {\n  getTextContent,\n  shouldMaskNode,\n  reducePrivacyLevel,\n  getNodeSelfPrivacyLevel,\n  MAX_ATTRIBUTE_VALUE_CHAR_LENGTH,\n} from './privacy'\nimport { getSerializedNodeId, setSerializedNodeId, getElementInputValue } from './serializationUtils'\nimport { forEach } from './utils'\n\n// Those values are the only one that can be used when inheriting privacy levels from parent to\n// children during serialization, since HIDDEN and IGNORE shouldn't serialize their children. This\n// ensures that no children are serialized when they shouldn't.\ntype ParentNodePrivacyLevel =\n  | typeof NodePrivacyLevel.ALLOW\n  | typeof NodePrivacyLevel.MASK\n  | typeof NodePrivacyLevel.MASK_USER_INPUT\n\nexport interface SerializeOptions {\n  document: Document\n  serializedNodeIds?: Set<number>\n  ignoreWhiteSpace?: boolean\n  parentNodePrivacyLevel: ParentNodePrivacyLevel\n}\n\nexport function serializeDocument(\n  document: Document,\n  defaultPrivacyLevel: ParentNodePrivacyLevel\n): SerializedNodeWithId {\n  // We are sure that Documents are never ignored, so this function never returns null\n  return serializeNodeWithId(document, {\n    document,\n    parentNodePrivacyLevel: defaultPrivacyLevel,\n  })!\n}\n\nexport function serializeNodeWithId(node: Node, options: SerializeOptions): SerializedNodeWithId | null {\n  const serializedNode = serializeNode(node, options)\n  if (!serializedNode) {\n    return null\n  }\n\n  // Try to reuse the previous id\n  const id = getSerializedNodeId(node) || generateNextId()\n  const serializedNodeWithId = serializedNode as SerializedNodeWithId\n  serializedNodeWithId.id = id\n  setSerializedNodeId(node, id)\n  if (options.serializedNodeIds) {\n    options.serializedNodeIds.add(id)\n  }\n  return serializedNodeWithId\n}\n\nfunction serializeNode(node: Node, options: SerializeOptions): SerializedNode | undefined {\n  switch (node.nodeType) {\n    case node.DOCUMENT_NODE:\n      return serializeDocumentNode(node as Document, options)\n    case node.DOCUMENT_TYPE_NODE:\n      return serializeDocumentTypeNode(node as DocumentType)\n    case node.ELEMENT_NODE:\n      return serializeElementNode(node as Element, options)\n    case node.TEXT_NODE:\n      return serializeTextNode(node as Text, options)\n    case node.CDATA_SECTION_NODE:\n      return serializeCDataNode()\n  }\n}\n\nexport function serializeDocumentNode(document: Document, options: SerializeOptions): DocumentNode {\n  return {\n    type: NodeType.Document,\n    childNodes: serializeChildNodes(document, options),\n  }\n}\n\nfunction serializeDocumentTypeNode(documentType: DocumentType): DocumentTypeNode {\n  return {\n    type: NodeType.DocumentType,\n    name: documentType.name,\n    publicId: documentType.publicId,\n    systemId: documentType.systemId,\n  }\n}\n\n/**\n * Serialzing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, otpion selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nexport function serializeElementNode(element: Element, options: SerializeOptions): ElementNode | undefined {\n  const tagName = getValidTagName(element.tagName)\n  const isSVG = isSVGElement(element) || undefined\n\n  // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n  // parentNodePrivacyLevel option to avoid iterating over all parents\n  const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel)\n\n  if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    const { width, height } = element.getBoundingClientRect()\n    return {\n      type: NodeType.Element,\n      tagName,\n      attributes: {\n        rr_width: `${width}px`,\n        rr_height: `${height}px`,\n        [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_HIDDEN,\n      },\n      childNodes: [],\n      isSVG,\n    }\n  }\n\n  // Ignore Elements like Script and some Link, Metas\n  if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n    return\n  }\n\n  const attributes = getAttributesForPrivacyLevel(element, nodePrivacyLevel)\n\n  let childNodes: SerializedNodeWithId[] = []\n  if (element.childNodes.length) {\n    // OBJECT POOLING OPTIMIZATION:\n    // We should not create a new object systematically as it could impact performances. Try to reuse\n    // the same object as much as possible, and clone it only if we need to.\n    let childNodesSerializationOptions\n    if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n      childNodesSerializationOptions = options\n    } else {\n      childNodesSerializationOptions = assign({}, options, {\n        parentNodePrivacyLevel: nodePrivacyLevel,\n        ignoreWhiteSpace: tagName === 'head',\n      })\n    }\n    childNodes = serializeChildNodes(element, childNodesSerializationOptions)\n  }\n\n  return {\n    type: NodeType.Element,\n    tagName,\n    attributes,\n    childNodes,\n    isSVG,\n  }\n}\n\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode: Text, options: SerializeOptions): TextNode | 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  const textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel)\n  if (!textContent) {\n    return\n  }\n  return {\n    type: NodeType.Text,\n    textContent,\n    isStyle: parentTagName === 'STYLE' ? true : undefined,\n  }\n}\n\nfunction serializeCDataNode(): CDataNode {\n  return {\n    type: NodeType.CDATA,\n    textContent: '',\n  }\n}\n\nexport function serializeChildNodes(node: Node, options: SerializeOptions): SerializedNodeWithId[] {\n  const result: SerializedNodeWithId[] = []\n\n  forEach(node.childNodes, (childNode) => {\n    const serializedChildNode = serializeNodeWithId(childNode, options)\n    if (serializedChildNode) {\n      result.push(serializedChildNode)\n    }\n  })\n\n  return result\n}\n\nexport function serializeAttribute(\n  element: Element,\n  nodePrivacyLevel: NodePrivacyLevel,\n  attributeName: string\n): string | number | boolean | null {\n  if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    // dup condition for direct access case\n    return null\n  }\n  const attributeValue = element.getAttribute(attributeName)\n  if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n    const tagName = element.tagName\n\n    switch (attributeName) {\n      // Mask Attribute text content\n      case 'title':\n      case 'alt':\n        return CENSORED_STRING_MARK\n    }\n    // mask image URLs\n    if (tagName === 'IMG' || tagName === 'SOURCE') {\n      if (attributeName === 'src' || attributeName === 'srcset') {\n        return CENSORED_IMG_MARK\n      }\n    }\n    // mask <a> URLs\n    if (tagName === 'A' && attributeName === 'href') {\n      return CENSORED_STRING_MARK\n    }\n    // mask data-* attributes\n    if (attributeValue && attributeName.indexOf('data-') === 0 && attributeName !== PRIVACY_ATTR_NAME) {\n      // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n      return CENSORED_STRING_MARK\n    }\n  }\n\n  if (!attributeValue || typeof attributeValue !== 'string') {\n    return attributeValue\n  }\n\n  // Minimum Fix for customer.\n  if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n    return 'data:truncated'\n  }\n\n  return attributeValue\n}\n\nlet _nextId = 1\nfunction generateNextId(): number {\n  return _nextId++\n}\n\nconst TAG_NAME_REGEX = /[^a-z1-6-_]/\nfunction getValidTagName(tagName: string): string {\n  const processedTagName = tagName.toLowerCase().trim()\n\n  if (TAG_NAME_REGEX.test(processedTagName)) {\n    // if the tag name is odd and we cannot extract\n    // anything from the string, then we return a\n    // generic div\n    return 'div'\n  }\n\n  return processedTagName\n}\n\nfunction getCssRulesString(s: CSSStyleSheet): string | null {\n  try {\n    const rules = s.rules || s.cssRules\n    return rules ? Array.from(rules).map(getCssRuleString).join('') : null\n  } catch (error) {\n    return null\n  }\n}\n\nfunction getCssRuleString(rule: CSSRule): string {\n  return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText\n}\n\nfunction isCSSImportRule(rule: CSSRule): rule is CSSImportRule {\n  return 'styleSheet' in rule\n}\n\nfunction isSVGElement(el: Element): boolean {\n  return el.tagName === 'svg' || el instanceof SVGElement\n}\n\nfunction getAttributesForPrivacyLevel(\n  element: Element,\n  nodePrivacyLevel: NodePrivacyLevel\n): Record<string, string | number | boolean> {\n  if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    return {}\n  }\n  const safeAttrs: Record<string, string | number | boolean> = {}\n  const tagName = getValidTagName(element.tagName)\n  const doc = element.ownerDocument\n\n  type HtmlAttribute = { name: string; value: string }\n  for (let i = 0; i < element.attributes.length; i += 1) {\n    const attribute = element.attributes.item(i) as HtmlAttribute\n    const attributeName = attribute.name\n    const attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName)\n    if (attributeValue !== null) {\n      safeAttrs[attributeName] = attributeValue\n    }\n  }\n\n  if (\n    (element as HTMLInputElement).value &&\n    (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')\n  ) {\n    const formValue = getElementInputValue(element, nodePrivacyLevel)\n    if (formValue !== undefined) {\n      safeAttrs.value = formValue\n    }\n  }\n\n  /**\n   * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n   */\n  if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n    // For privacy=`MASK`, all the values would be the same, so skip.\n    const optionElement = element as HTMLOptionElement\n    if (optionElement.selected) {\n      safeAttrs.selected = optionElement.selected\n    }\n  }\n\n  // remote css\n  if (tagName === 'link') {\n    const stylesheet = Array.from(doc.styleSheets).find((s) => s.href === (element as HTMLLinkElement).href)\n    const cssText = getCssRulesString(stylesheet as CSSStyleSheet)\n    if (cssText && stylesheet) {\n      delete safeAttrs.rel\n      delete safeAttrs.href\n      safeAttrs._cssText = cssText\n    }\n  }\n\n  // dynamic stylesheet\n  if (\n    tagName === 'style' &&\n    (element as HTMLStyleElement).sheet &&\n    // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n    !((element as HTMLStyleElement).innerText || element.textContent || '').trim().length\n  ) {\n    const cssText = getCssRulesString((element as HTMLStyleElement).sheet as CSSStyleSheet)\n    if (cssText) {\n      safeAttrs._cssText = cssText\n    }\n  }\n\n  /**\n   * Forms: input[type=checkbox,radio]\n   * The `checked` property for <input> is a little bit special:\n   * 1. el.checked is a setter that returns if truthy.\n   * 2. getAttribute returns the string value\n   * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n   * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n   */\n  const inputElement = element as HTMLInputElement\n  if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n    if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n      safeAttrs.checked = !!inputElement.checked\n    } else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n      safeAttrs.checked = CENSORED_STRING_MARK\n    }\n  }\n\n  /**\n   * Serialize the media playback state\n   */\n  if (tagName === 'audio' || tagName === 'video') {\n    const mediaElement = element as HTMLMediaElement\n    safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played'\n  }\n\n  /**\n   * Serialize the scroll state for each element\n   */\n  if (element.scrollLeft) {\n    safeAttrs.rr_scrollLeft = Math.round(element.scrollLeft)\n  }\n  if (element.scrollTop) {\n    safeAttrs.rr_scrollTop = Math.round(element.scrollTop)\n  }\n\n  return safeAttrs\n}\n","import { noop, requestIdleCallback } from '@datadog/browser-core'\nimport type { RumMutationRecord } from './mutationObserver'\n\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nconst MUTATION_PROCESS_MAX_DELAY = 100\n\nexport function createMutationBatch(processMutationBatch: (mutations: RumMutationRecord[]) => void) {\n  let cancelScheduledFlush = noop\n  let pendingMutations: RumMutationRecord[] = []\n\n  function flush() {\n    cancelScheduledFlush()\n    processMutationBatch(pendingMutations)\n    pendingMutations = []\n  }\n\n  return {\n    addMutations: (mutations: RumMutationRecord[]) => {\n      if (pendingMutations.length === 0) {\n        cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY })\n      }\n      pendingMutations.push(...mutations)\n    },\n\n    flush,\n\n    stop: () => {\n      cancelScheduledFlush()\n    },\n  }\n}\n","import type { DefaultPrivacyLevel } from '@datadog/browser-core'\nimport { monitor, noop } from '@datadog/browser-core'\nimport { getMutationObserverConstructor } from '@datadog/browser-rum-core'\nimport { NodePrivacyLevel } from '../../constants'\nimport type { AddedNodeMutation, AttributeMutation, RemovedNodeMutation, TextMutation } from '../../types'\nimport { getNodePrivacyLevel, getTextContent } from './privacy'\nimport type { NodeWithSerializedNode } from './serializationUtils'\nimport {\n  getElementInputValue,\n  getSerializedNodeId,\n  hasSerializedNode,\n  nodeAndAncestorsHaveSerializedNode,\n} from './serializationUtils'\nimport { serializeNodeWithId, serializeAttribute } from './serialize'\nimport { forEach } from './utils'\nimport { createMutationBatch } from './mutationBatch'\nimport type { MutationCallBack } from './observer'\n\ntype WithSerializedTarget<T> = T & { target: NodeWithSerializedNode }\n\n// https://dom.spec.whatwg.org/#interface-mutationrecord\ninterface RumCharacterDataMutationRecord {\n  type: 'characterData'\n  target: Node\n  oldValue: string | null\n}\n\ninterface RumAttributesMutationRecord {\n  type: 'attributes'\n  target: Element\n  oldValue: string | null\n  attributeName: string | null\n}\n\ninterface RumChildListMutationRecord {\n  type: 'childList'\n  target: Node\n  addedNodes: NodeList\n  removedNodes: NodeList\n}\n\nexport type RumMutationRecord =\n  | RumCharacterDataMutationRecord\n  | RumAttributesMutationRecord\n  | RumChildListMutationRecord\n\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function startMutationObserver(\n  controller: MutationController,\n  mutationCallback: MutationCallBack,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  const MutationObserver = getMutationObserverConstructor()\n  if (!MutationObserver) {\n    return { stop: noop }\n  }\n  const mutationBatch = createMutationBatch((mutations) => {\n    processMutations(\n      mutations.concat(observer.takeRecords() as RumMutationRecord[]),\n      mutationCallback,\n      defaultPrivacyLevel\n    )\n  })\n\n  const observer = new MutationObserver(monitor(mutationBatch.addMutations) as (callback: MutationRecord[]) => void)\n\n  observer.observe(document, {\n    attributeOldValue: true,\n    attributes: true,\n    characterData: true,\n    characterDataOldValue: true,\n    childList: true,\n    subtree: true,\n  })\n  controller.onFlush(mutationBatch.flush)\n\n  return {\n    stop: () => {\n      observer.disconnect()\n      mutationBatch.stop()\n    },\n  }\n}\n\n/**\n * Controls how mutations are processed, allowing to flush pending mutations.\n */\nexport class MutationController {\n  private flushListener?: () => void\n\n  public flush() {\n    this.flushListener?.()\n  }\n\n  public onFlush(listener: () => void) {\n    this.flushListener = listener\n  }\n}\n\nfunction processMutations(\n  mutations: RumMutationRecord[],\n  mutationCallback: MutationCallBack,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  // Discard any mutation with a 'target' node that:\n  // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n  // part of a mutation occurring in a parent Node\n  // * should be hidden or ignored\n  const filteredMutations = mutations.filter(\n    (mutation): mutation is WithSerializedTarget<RumMutationRecord> =>\n      document.contains(mutation.target) &&\n      nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n      getNodePrivacyLevel(mutation.target, defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN\n  )\n\n  const { adds, removes, hasBeenSerialized } = processChildListMutations(\n    filteredMutations.filter(\n      (mutation): mutation is WithSerializedTarget<RumChildListMutationRecord> => mutation.type === 'childList'\n    ),\n    defaultPrivacyLevel\n  )\n\n  const texts = processCharacterDataMutations(\n    filteredMutations.filter(\n      (mutation): mutation is WithSerializedTarget<RumCharacterDataMutationRecord> =>\n        mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)\n    ),\n    defaultPrivacyLevel\n  )\n\n  const attributes = processAttributesMutations(\n    filteredMutations.filter(\n      (mutation): mutation is WithSerializedTarget<RumAttributesMutationRecord> =>\n        mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)\n    ),\n    defaultPrivacyLevel\n  )\n\n  if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n    return\n  }\n\n  mutationCallback({\n    adds,\n    removes,\n    texts,\n    attributes,\n  })\n}\n\nfunction processChildListMutations(\n  mutations: Array<WithSerializedTarget<RumChildListMutationRecord>>,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  // First, we iterate over mutations to collect:\n  //\n  // * nodes that have been added in the document and not removed by a subsequent mutation\n  // * nodes that have been removed from the document but were not added in a previous mutation\n  //\n  // For this second category, we also collect their previous parent (mutation.target) because we'll\n  // need it to emit a 'remove' mutation.\n  //\n  // Those two categories may overlap: if a node moved from a position to another, it is reported as\n  // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n  // the node will be in both sets.\n  const addedAndMovedNodes = new Set<Node>()\n  const removedNodes = new Map<Node, NodeWithSerializedNode>()\n  for (const mutation of mutations) {\n    forEach(mutation.addedNodes, (node) => {\n      addedAndMovedNodes.add(node)\n    })\n    forEach(mutation.removedNodes, (node) => {\n      if (!addedAndMovedNodes.has(node)) {\n        removedNodes.set(node, mutation.target)\n      }\n      addedAndMovedNodes.delete(node)\n    })\n  }\n\n  // Then, we sort nodes that are still in the document by topological order, for two reasons:\n  //\n  // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n  // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n  // a precedent node.\n  //\n  // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n  // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n  // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n  // already serialized and have an id.\n  const sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes)\n  sortAddedAndMovedNodes(sortedAddedAndMovedNodes)\n\n  // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n  // node ids in a set to be able to skip subsequent related mutations.\n  const serializedNodeIds = new Set<number>()\n\n  const addedNodeMutations: AddedNodeMutation[] = []\n  for (const node of sortedAddedAndMovedNodes) {\n    if (hasBeenSerialized(node)) {\n      continue\n    }\n\n    const parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode!, defaultPrivacyLevel)\n    if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n      continue\n    }\n\n    const serializedNode = serializeNodeWithId(node, {\n      document,\n      serializedNodeIds,\n      parentNodePrivacyLevel,\n    })\n    if (!serializedNode) {\n      continue\n    }\n\n    addedNodeMutations.push({\n      nextId: getNextSibling(node),\n      parentId: getSerializedNodeId(node.parentNode!)!,\n      node: serializedNode,\n    })\n  }\n  // Finally, we emit remove mutations.\n  const removedNodeMutations: RemovedNodeMutation[] = []\n  removedNodes.forEach((parent, node) => {\n    if (hasSerializedNode(node)) {\n      removedNodeMutations.push({\n        parentId: getSerializedNodeId(parent),\n        id: getSerializedNodeId(node),\n      })\n    }\n  })\n\n  return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized }\n\n  function hasBeenSerialized(node: Node) {\n    return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node))\n  }\n\n  function getNextSibling(node: Node): null | number {\n    let nextSibling = node.nextSibling\n    while (nextSibling) {\n      if (hasSerializedNode(nextSibling)) {\n        return getSerializedNodeId(nextSibling)\n      }\n      nextSibling = nextSibling.nextSibling\n    }\n\n    return null\n  }\n}\n\nfunction processCharacterDataMutations(\n  mutations: Array<WithSerializedTarget<RumCharacterDataMutationRecord>>,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  const textMutations: TextMutation[] = []\n\n  // Deduplicate mutations based on their target node\n  const handledNodes = new Set<Node>()\n  const filteredMutations = mutations.filter((mutation) => {\n    if (handledNodes.has(mutation.target)) {\n      return false\n    }\n    handledNodes.add(mutation.target)\n    return true\n  })\n\n  // Emit mutations\n  for (const mutation of filteredMutations) {\n    const value = mutation.target.textContent\n    if (value === mutation.oldValue) {\n      continue\n    }\n\n    const parentNodePrivacyLevel = getNodePrivacyLevel(mutation.target.parentNode!, defaultPrivacyLevel)\n    if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n      continue\n    }\n\n    textMutations.push({\n      id: getSerializedNodeId(mutation.target),\n      // TODO: pass a valid \"ignoreWhiteSpace\" argument\n      value: getTextContent(mutation.target, false, parentNodePrivacyLevel) ?? null,\n    })\n  }\n\n  return textMutations\n}\n\nfunction processAttributesMutations(\n  mutations: Array<WithSerializedTarget<RumAttributesMutationRecord>>,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  const attributeMutations: AttributeMutation[] = []\n\n  // Deduplicate mutations based on their target node and changed attribute\n  const handledElements = new Map<Element, Set<string>>()\n  const filteredMutations = mutations.filter((mutation) => {\n    const handledAttributes = handledElements.get(mutation.target)\n    if (handledAttributes?.has(mutation.attributeName!)) {\n      return false\n    }\n    if (!handledAttributes) {\n      handledElements.set(mutation.target, new Set([mutation.attributeName!]))\n    } else {\n      handledAttributes.add(mutation.attributeName!)\n    }\n    return true\n  })\n\n  // Emit mutations\n  const emittedMutations = new Map<Element, AttributeMutation>()\n  for (const mutation of filteredMutations) {\n    const uncensoredValue = mutation.target.getAttribute(mutation.attributeName!)\n    if (uncensoredValue === mutation.oldValue) {\n      continue\n    }\n    const privacyLevel = getNodePrivacyLevel(mutation.target, defaultPrivacyLevel)\n    const attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName!)\n\n    let transformedValue: string | null\n    if (mutation.attributeName === 'value') {\n      const inputValue = getElementInputValue(mutation.target, privacyLevel)\n      if (inputValue === undefined) {\n        continue\n      }\n      transformedValue = inputValue\n    } else if (typeof attributeValue === 'string') {\n      transformedValue = attributeValue\n    } else {\n      transformedValue = null\n    }\n\n    let emittedMutation = emittedMutations.get(mutation.target)\n    if (!emittedMutation) {\n      emittedMutation = {\n        id: getSerializedNodeId(mutation.target),\n        attributes: {},\n      }\n      attributeMutations.push(emittedMutation)\n      emittedMutations.set(mutation.target, emittedMutation)\n    }\n\n    emittedMutation.attributes[mutation.attributeName!] = transformedValue\n  }\n\n  return attributeMutations\n}\n\nexport function sortAddedAndMovedNodes(nodes: Node[]) {\n  nodes.sort((a, b) => {\n    const position = a.compareDocumentPosition(b)\n    /* eslint-disable no-bitwise */\n    if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n      return -1\n    } else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n      return 1\n    } else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n      return 1\n    } else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n      return -1\n    }\n    /* eslint-enable no-bitwise */\n    return 0\n  })\n}\n","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n\nimport type { VisualViewportRecord } from '../../types'\n\n// Scrollbar widths vary across properties on different devices and browsers\nconst TOLERANCE = 25\n\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn() {\n  const visual = window.visualViewport\n  return (\n    Math.abs(visual.pageTop - visual.offsetTop - window.scrollY) > TOLERANCE ||\n    Math.abs(visual.pageLeft - visual.offsetLeft - window.scrollX) > TOLERANCE\n  )\n}\n\ninterface LayoutCoordinates {\n  layoutViewportX: number\n  layoutViewportY: number\n  visualViewportX: number\n  visualViewportY: number\n}\n\nexport const convertMouseEventToLayoutCoordinates = (clientX: number, clientY: number): LayoutCoordinates => {\n  const visual = window.visualViewport\n  const normalised: LayoutCoordinates = {\n    layoutViewportX: clientX,\n    layoutViewportY: clientY,\n    visualViewportX: clientX,\n    visualViewportY: clientY,\n  }\n\n  if (!visual) {\n    // On old browsers, we cannot normalise, so fallback to clientX/Y\n    return normalised\n  } else if (isVisualViewportFactoredIn()) {\n    // Typically Mobile Devices\n    normalised.layoutViewportX = Math.round(clientX + visual.offsetLeft)\n    normalised.layoutViewportY = Math.round(clientY + visual.offsetTop)\n  } else {\n    // Typically Desktop Devices\n    normalised.visualViewportX = Math.round(clientX - visual.offsetLeft)\n    normalised.visualViewportY = Math.round(clientY - visual.offsetTop)\n  }\n  return normalised\n}\n\nexport const getVisualViewport = (): VisualViewportRecord['data'] => {\n  const visual = window.visualViewport\n  return {\n    scale: visual.scale,\n    offsetLeft: visual.offsetLeft,\n    offsetTop: visual.offsetTop,\n    pageLeft: visual.pageLeft,\n    pageTop: visual.pageTop,\n    height: visual.height,\n    width: visual.width,\n  }\n}\n\nexport function getScrollX() {\n  const visual = window.visualViewport\n  if (visual) {\n    return visual.pageLeft - visual.offsetLeft\n  }\n  if (window.scrollX !== undefined) {\n    return window.scrollX\n  }\n  return window.pageXOffset || 0\n}\n\nexport function getScrollY() {\n  const visual = window.visualViewport\n  if (visual) {\n    return visual.pageTop - visual.offsetTop\n  }\n  if (window.scrollY !== undefined) {\n    return window.scrollY\n  }\n  return window.pageYOffset || 0\n}\n","import type { DefaultPrivacyLevel } from '@datadog/browser-core'\nimport {\n  instrumentSetter,\n  instrumentMethodAndCallOriginal,\n  assign,\n  monitor,\n  throttle,\n  DOM_EVENT,\n  addEventListeners,\n  addEventListener,\n  noop,\n} from '@datadog/browser-core'\nimport type { LifeCycle } from '@datadog/browser-rum-core'\nimport { initViewportObservable, ActionType, RumEventType, LifeCycleEventType } from '@datadog/browser-rum-core'\nimport { NodePrivacyLevel } from '../../constants'\nimport type {\n  InputState,\n  MousePosition,\n  MouseInteraction,\n  BrowserMutationPayload,\n  ScrollPosition,\n  StyleSheetRule,\n  ViewportResizeDimension,\n  MediaInteraction,\n  FocusRecord,\n  VisualViewportRecord,\n  FrustrationRecord,\n  BrowserIncrementalSnapshotRecord,\n  MouseInteractionData,\n} from '../../types'\nimport { RecordType, IncrementalSource, MediaInteractionType, MouseInteractionType } from '../../types'\nimport { getNodePrivacyLevel, shouldMaskNode } from './privacy'\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from './serializationUtils'\nimport { assembleIncrementalSnapshot, forEach, isTouchEvent } from './utils'\nimport type { MutationController } from './mutationObserver'\nimport { startMutationObserver } from './mutationObserver'\n\nimport { getVisualViewport, getScrollX, getScrollY, convertMouseEventToLayoutCoordinates } from './viewports'\n\nconst MOUSE_MOVE_OBSERVER_THRESHOLD = 50\nconst SCROLL_OBSERVER_THRESHOLD = 100\nconst VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200\n\nconst recordIds = new WeakMap<Event, number>()\nlet nextId = 1\n\nfunction getRecordIdForEvent(event: Event): number {\n  if (!recordIds.has(event)) {\n    recordIds.set(event, nextId++)\n  }\n  return recordIds.get(event)!\n}\n\ntype ListenerHandler = () => void\n\ntype MousemoveCallBack = (\n  p: MousePosition[],\n  source: typeof IncrementalSource.MouseMove | typeof IncrementalSource.TouchMove\n) => void\n\nexport type MutationCallBack = (m: BrowserMutationPayload) => void\n\ntype MouseInteractionCallBack = (record: BrowserIncrementalSnapshotRecord) => void\n\ntype ScrollCallback = (p: ScrollPosition) => void\n\ntype StyleSheetRuleCallback = (s: StyleSheetRule) => void\n\ntype ViewportResizeCallback = (d: ViewportResizeDimension) => void\n\nexport type InputCallback = (v: InputState & { id: number }) => void\n\ntype MediaInteractionCallback = (p: MediaInteraction) => void\n\ntype FocusCallback = (data: FocusRecord['data']) => void\n\ntype VisualViewportResizeCallback = (data: VisualViewportRecord['data']) => void\n\nexport type FrustrationCallback = (record: FrustrationRecord) => void\n\ninterface ObserverParam {\n  lifeCycle: LifeCycle\n  defaultPrivacyLevel: DefaultPrivacyLevel\n  mutationController: MutationController\n  mutationCb: MutationCallBack\n  mousemoveCb: MousemoveCallBack\n  mouseInteractionCb: MouseInteractionCallBack\n  scrollCb: ScrollCallback\n  viewportResizeCb: ViewportResizeCallback\n  visualViewportResizeCb: VisualViewportResizeCallback\n  inputCb: InputCallback\n  mediaInteractionCb: MediaInteractionCallback\n  styleSheetRuleCb: StyleSheetRuleCallback\n  focusCb: FocusCallback\n  frustrationCb: FrustrationCallback\n}\n\nexport function initObservers(o: ObserverParam): ListenerHandler {\n  const mutationHandler = initMutationObserver(o.mutationController, o.mutationCb, o.defaultPrivacyLevel)\n  const mousemoveHandler = initMoveObserver(o.mousemoveCb)\n  const mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.defaultPrivacyLevel)\n  const scrollHandler = initScrollObserver(o.scrollCb, o.defaultPrivacyLevel)\n  const viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb)\n  const inputHandler = initInputObserver(o.inputCb, o.defaultPrivacyLevel)\n  const mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.defaultPrivacyLevel)\n  const styleSheetObserver = initStyleSheetObserver(o.styleSheetRuleCb)\n  const focusHandler = initFocusObserver(o.focusCb)\n  const visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb)\n  const frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb)\n\n  return () => {\n    mutationHandler()\n    mousemoveHandler()\n    mouseInteractionHandler()\n    scrollHandler()\n    viewportResizeHandler()\n    inputHandler()\n    mediaInteractionHandler()\n    styleSheetObserver()\n    focusHandler()\n    visualViewportResizeHandler()\n    frustrationHandler()\n  }\n}\n\nfunction initMutationObserver(\n  mutationController: MutationController,\n  cb: MutationCallBack,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n) {\n  return startMutationObserver(mutationController, cb, defaultPrivacyLevel).stop\n}\n\nfunction initMoveObserver(cb: MousemoveCallBack): ListenerHandler {\n  const { throttled: updatePosition } = throttle(\n    monitor((event: MouseEvent | TouchEvent) => {\n      const target = event.target as Node\n      if (hasSerializedNode(target)) {\n        const { clientX, clientY } = isTouchEvent(event) ? event.changedTouches[0] : event\n        const position: MousePosition = {\n          id: getSerializedNodeId(target),\n          timeOffset: 0,\n          x: clientX,\n          y: clientY,\n        }\n        if (window.visualViewport) {\n          const { visualViewportX, visualViewportY } = convertMouseEventToLayoutCoordinates(clientX, clientY)\n          position.x = visualViewportX\n          position.y = visualViewportY\n        }\n        cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove)\n      }\n    }),\n    MOUSE_MOVE_OBSERVER_THRESHOLD,\n    {\n      trailing: false,\n    }\n  )\n\n  return addEventListeners(document, [DOM_EVENT.MOUSE_MOVE, DOM_EVENT.TOUCH_MOVE], updatePosition, {\n    capture: true,\n    passive: true,\n  }).stop\n}\n\nconst eventTypeToMouseInteraction = {\n  [DOM_EVENT.MOUSE_UP]: MouseInteractionType.MouseUp,\n  [DOM_EVENT.MOUSE_DOWN]: MouseInteractionType.MouseDown,\n  [DOM_EVENT.CLICK]: MouseInteractionType.Click,\n  [DOM_EVENT.CONTEXT_MENU]: MouseInteractionType.ContextMenu,\n  [DOM_EVENT.DBL_CLICK]: MouseInteractionType.DblClick,\n  [DOM_EVENT.FOCUS]: MouseInteractionType.Focus,\n  [DOM_EVENT.BLUR]: MouseInteractionType.Blur,\n  [DOM_EVENT.TOUCH_START]: MouseInteractionType.TouchStart,\n  [DOM_EVENT.TOUCH_END]: MouseInteractionType.TouchEnd,\n}\nfunction initMouseInteractionObserver(\n  cb: MouseInteractionCallBack,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n): ListenerHandler {\n  const handler = (event: MouseEvent | TouchEvent) => {\n    const target = event.target as Node\n    if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n      return\n    }\n    const { clientX, clientY } = isTouchEvent(event) ? event.changedTouches[0] : event\n    const position: MouseInteraction = {\n      id: getSerializedNodeId(target),\n      type: eventTypeToMouseInteraction[event.type as keyof typeof eventTypeToMouseInteraction],\n      x: clientX,\n      y: clientY,\n    }\n    if (window.visualViewport) {\n      const { visualViewportX, visualViewportY } = convertMouseEventToLayoutCoordinates(clientX, clientY)\n      position.x = visualViewportX\n      position.y = visualViewportY\n    }\n\n    const record = assign(\n      { id: getRecordIdForEvent(event) },\n      assembleIncrementalSnapshot<MouseInteractionData>(IncrementalSource.MouseInteraction, position)\n    )\n    cb(record)\n  }\n  return addEventListeners(document, Object.keys(eventTypeToMouseInteraction) as DOM_EVENT[], handler, {\n    capture: true,\n    passive: true,\n  }).stop\n}\n\nfunction initScrollObserver(cb: ScrollCallback, defaultPrivacyLevel: DefaultPrivacyLevel): ListenerHandler {\n  const { throttled: updatePosition } = throttle(\n    monitor((event: UIEvent) => {\n      const target = event.target as HTMLElement | Document\n      if (\n        !target ||\n        getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n        !hasSerializedNode(target)\n      ) {\n        return\n      }\n      const id = getSerializedNodeId(target)\n      if (target === document) {\n        cb({\n          id,\n          x: getScrollX(),\n          y: getScrollY(),\n        })\n      } else {\n        cb({\n          id,\n          x: (target as HTMLElement).scrollLeft,\n          y: (target as HTMLElement).scrollTop,\n        })\n      }\n    }),\n    SCROLL_OBSERVER_THRESHOLD\n  )\n  return addEventListener(document, DOM_EVENT.SCROLL, updatePosition, { capture: true, passive: true }).stop\n}\n\nfunction initViewportResizeObserver(cb: ViewportResizeCallback): ListenerHandler {\n  return initViewportObservable().subscribe(cb).unsubscribe\n}\n\nexport function initInputObserver(cb: InputCallback, defaultPrivacyLevel: DefaultPrivacyLevel): ListenerHandler {\n  const lastInputStateMap: WeakMap<Node, InputState> = new WeakMap()\n\n  function onElementChange(target: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement) {\n    const nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel)\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n      return\n    }\n\n    const type = target.type\n\n    let inputState: InputState\n    if (type === 'radio' || type === 'checkbox') {\n      if (shouldMaskNode(target, nodePrivacyLevel)) {\n        return\n      }\n      inputState = { isChecked: (target as HTMLInputElement).checked }\n    } else {\n      const value = getElementInputValue(target, nodePrivacyLevel)\n      if (value === undefined) {\n        return\n      }\n      inputState = { text: value }\n    }\n\n    // Can be multiple changes on the same node within the same batched mutation observation.\n    cbWithDedup(target, inputState)\n\n    // If a radio was checked, other radios with the same name attribute will be unchecked.\n    const name = target.name\n    if (type === 'radio' && name && (target as HTMLInputElement).checked) {\n      forEach(document.querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`), (el: Element) => {\n        if (el !== target) {\n          // TODO: Consider the privacy implications for various differing input privacy levels\n          cbWithDedup(el, { isChecked: false })\n        }\n      })\n    }\n  }\n\n  /**\n   * There can be multiple changes on the same node within the same batched mutation observation.\n   */\n  function cbWithDedup(target: Node, inputState: InputState) {\n    if (!hasSerializedNode(target)) {\n      return\n    }\n    const lastInputState = lastInputStateMap.get(target)\n    if (\n      !lastInputState ||\n      (lastInputState as { text?: string }).text !== (inputState as { text?: string }).text ||\n      (lastInputState as { isChecked?: boolean }).isChecked !== (inputState as { isChecked?: boolean }).isChecked\n    ) {\n      lastInputStateMap.set(target, inputState)\n      cb(\n        assign(\n          {\n            id: getSerializedNodeId(target),\n          },\n          inputState\n        )\n      )\n    }\n  }\n\n  const { stop: stopEventListeners } = addEventListeners(\n    document,\n    [DOM_EVENT.INPUT, DOM_EVENT.CHANGE],\n    (event) => {\n      if (\n        event.target instanceof HTMLInputElement ||\n        event.target instanceof HTMLTextAreaElement ||\n        event.target instanceof HTMLSelectElement\n      ) {\n        onElementChange(event.target)\n      }\n    },\n    {\n      capture: true,\n      passive: true,\n    }\n  )\n\n  const instrumentationStoppers = [\n    instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n    instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n    instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n    instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n    instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n  ]\n\n  return () => {\n    instrumentationStoppers.forEach((stopper) => stopper.stop())\n    stopEventListeners()\n  }\n}\n\nfunction initStyleSheetObserver(cb: StyleSheetRuleCallback): ListenerHandler {\n  const { stop: restoreInsertRule } = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n    before(rule, index) {\n      if (hasSerializedNode(this.ownerNode!)) {\n        cb({\n          id: getSerializedNodeId(this.ownerNode),\n          adds: [{ rule, index }],\n        })\n      }\n    },\n  })\n\n  const { stop: restoreDeleteRule } = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n    before(index) {\n      if (hasSerializedNode(this.ownerNode!)) {\n        cb({\n          id: getSerializedNodeId(this.ownerNode),\n          removes: [{ index }],\n        })\n      }\n    },\n  })\n\n  return () => {\n    restoreInsertRule()\n    restoreDeleteRule()\n  }\n}\n\nfunction initMediaInteractionObserver(\n  mediaInteractionCb: MediaInteractionCallback,\n  defaultPrivacyLevel: DefaultPrivacyLevel\n): ListenerHandler {\n  const handler = (event: Event) => {\n    const target = event.target as Node\n    if (\n      !target ||\n      getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n      !hasSerializedNode(target)\n    ) {\n      return\n    }\n    mediaInteractionCb({\n      id: getSerializedNodeId(target),\n      type: event.type === DOM_EVENT.PLAY ? MediaInteractionType.Play : MediaInteractionType.Pause,\n    })\n  }\n  return addEventListeners(document, [DOM_EVENT.PLAY, DOM_EVENT.PAUSE], handler, { capture: true, passive: true }).stop\n}\n\nfunction initFocusObserver(focusCb: FocusCallback): ListenerHandler {\n  return addEventListeners(window, [DOM_EVENT.FOCUS, DOM_EVENT.BLUR], () => {\n    focusCb({ has_focus: document.hasFocus() })\n  }).stop\n}\n\nfunction initVisualViewportResizeObserver(cb: VisualViewportResizeCallback): ListenerHandler {\n  if (!window.visualViewport) {\n    return noop\n  }\n  const { throttled: updateDimension, cancel: cancelThrottle } = throttle(\n    monitor(() => {\n      cb(getVisualViewport())\n    }),\n    VISUAL_VIEWPORT_OBSERVER_THRESHOLD,\n    {\n      trailing: false,\n    }\n  )\n  const removeListener = addEventListeners(\n    window.visualViewport,\n    [DOM_EVENT.RESIZE, DOM_EVENT.SCROLL],\n    updateDimension,\n    {\n      capture: true,\n      passive: true,\n    }\n  ).stop\n\n  return function stop() {\n    removeListener()\n    cancelThrottle()\n  }\n}\n\nexport function initFrustrationObserver(lifeCycle: LifeCycle, frustrationCb: FrustrationCallback): ListenerHandler {\n  return lifeCycle.subscribe(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, (data) => {\n    if (\n      data.rawRumEvent.type === RumEventType.ACTION &&\n      data.rawRumEvent.action.type === ActionType.CLICK &&\n      data.rawRumEvent.action.frustration?.type?.length &&\n      'events' in data.domainContext &&\n      data.domainContext.events?.length\n    ) {\n      frustrationCb({\n        timestamp: data.rawRumEvent.date,\n        type: RecordType.FrustrationRecord,\n        data: {\n          frustrationTypes: data.rawRumEvent.action.frustration.type,\n          recordIds: data.domainContext.events.map((e) => getRecordIdForEvent(e)),\n        },\n      })\n    }\n  }).unsubscribe\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  if (statsPerView.keys) {\n    statsPerView.delete(statsPerView.keys().next().value)\n  } else {\n    // IE11 doesn't support map.keys\n    let isFirst = true\n    statsPerView.forEach((_value, key) => {\n      if (isFirst) {\n        statsPerView!.delete(key)\n        isFirst = false\n      }\n    })\n  }\n}\n","import { addTelemetryDebug, assign, monitor } from '@datadog/browser-core'\nimport type { BrowserRecord, BrowserSegmentMetadata, CreationReason, SegmentContext } from '../../types'\nimport { RecordType } from '../../types'\nimport * as replayStats from '../replayStats'\nimport type { DeflateWorker, DeflateWorkerListener } from './deflateWorker'\n\nlet nextId = 0\n\nexport class Segment {\n  public isFlushed = false\n\n  public readonly metadata: BrowserSegmentMetadata\n\n  private id = nextId++\n\n  constructor(\n    private worker: DeflateWorker,\n    context: SegmentContext,\n    creationReason: CreationReason,\n    initialRecord: BrowserRecord,\n    onWrote: (compressedBytesCount: number) => void,\n    onFlushed: (data: Uint8Array, rawBytesCount: number) => void\n  ) {\n    const viewId = context.view.id\n\n    this.metadata = assign(\n      {\n        start: initialRecord.timestamp,\n        end: initialRecord.timestamp,\n        creation_reason: creationReason,\n        records_count: 1,\n        has_full_snapshot: initialRecord.type === RecordType.FullSnapshot,\n        index_in_view: replayStats.getSegmentsCount(viewId),\n        source: 'browser' as const,\n      },\n      context\n    )\n\n    replayStats.addSegment(viewId)\n    replayStats.addRecord(viewId)\n\n    const listener: DeflateWorkerListener = monitor(({ data }) => {\n      if (data.type === 'errored' || data.type === 'initialized') {\n        return\n      }\n\n      if (data.id === this.id) {\n        replayStats.addWroteData(viewId, data.additionalBytesCount)\n        if (data.type === 'flushed') {\n          onFlushed(data.result, data.rawBytesCount)\n          worker.removeEventListener('message', listener)\n        } else {\n          onWrote(data.compressedBytesCount)\n        }\n      } else if (data.id > this.id) {\n        // Messages should be received in the same order as they are sent, so if we receive a\n        // message with an id superior to this Segment instance id, we know that another, more\n        // recent Segment instance is being used.\n        //\n        // In theory, a \"flush\" response should have been received at this point, so the listener\n        // should already have been removed. But if something goes wrong and we didn't receive a\n        // \"flush\" response, remove the listener to avoid any leak, and send a monitor message to\n        // help investigate the issue.\n        worker.removeEventListener('message', listener)\n        addTelemetryDebug(\"Segment did not receive a 'flush' response before being replaced.\")\n      }\n    })\n    worker.addEventListener('message', listener)\n    this.worker.postMessage({ data: `{\"records\":[${JSON.stringify(initialRecord)}`, id: this.id, action: 'write' })\n  }\n\n  addRecord(record: BrowserRecord): void {\n    this.metadata.start = Math.min(this.metadata.start, record.timestamp)\n    this.metadata.end = Math.max(this.metadata.end, record.timestamp)\n    this.metadata.records_count += 1\n    replayStats.addRecord(this.metadata.view.id)\n    this.metadata.has_full_snapshot ||= record.type === RecordType.FullSnapshot\n    this.worker.postMessage({ data: `,${JSON.stringify(record)}`, id: this.id, action: 'write' })\n  }\n\n  flush() {\n    this.worker.postMessage({\n      data: `],${JSON.stringify(this.metadata).slice(1)}\\n`,\n      id: this.id,\n      action: 'flush',\n    })\n    this.isFlushed = true\n  }\n}\n","let workerURL\n\nexport function createDeflateWorker() {\n  // Lazily compute the worker URL to allow importing the SDK in NodeJS\n  if (!workerURL) {\n    workerURL = URL.createObjectURL(new Blob([`(${workerCodeFn})(self)`]))\n  }\n  return new Worker(workerURL)\n}\n\nfunction workerCodeFn() {\n  monitor(function () {\n    const { Deflate, constants, string2buf } = makePakoDeflate()\n\n    let deflate = new Deflate()\n    let rawBytesCount = 0\n    self.addEventListener(\n      'message',\n      monitor((event) => {\n        const data = event.data\n        switch (data.action) {\n          case 'init':\n            self.postMessage({\n              type: 'initialized',\n            })\n            break\n          case 'write': {\n            const additionalBytesCount = pushData(data.data)\n            self.postMessage({\n              type: 'wrote',\n              id: data.id,\n              compressedBytesCount: deflate.chunks.reduce((total, chunk) => total + chunk.length, 0),\n              additionalBytesCount,\n            })\n            break\n          }\n          case 'flush': {\n            const additionalBytesCount = data.data ? pushData(data.data) : 0\n            deflate.push('', constants.Z_FINISH)\n            self.postMessage({\n              type: 'flushed',\n              id: data.id,\n              result: deflate.result,\n              additionalBytesCount,\n              rawBytesCount,\n            })\n            deflate = new Deflate()\n            rawBytesCount = 0\n            break\n          }\n        }\n      })\n    )\n\n    function pushData(data) {\n      // TextEncoder is not supported on old browser version like Edge 18, therefore we use string2buf\n      const binaryData = string2buf(data)\n      deflate.push(binaryData, constants.Z_SYNC_FLUSH)\n      rawBytesCount += binaryData.length\n      return binaryData.length\n    }\n  })()\n\n  function monitor(fn) {\n    return function () {\n      try {\n        return fn.apply(this, arguments)\n      } catch (e) {\n        try {\n          self.postMessage({\n            type: 'errored',\n            error: e,\n          })\n        } catch (_) {\n          // DATA_CLONE_ERR, cf https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n          self.postMessage({\n            type: 'errored',\n            error: `${e}`,\n          })\n        }\n      }\n    }\n  }\n\n  // https://github.com/nodeca/pako/blob/034669ba0f1a4c0590e45f7c2820128200f972b3/dist/pako_deflate.es5.js\n  function makePakoDeflate() {\n    /* eslint-disable camelcase, no-bitwise */\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    /* Public constants ========================================================== */\n\n    /* =========================================================================== */\n    // const Z_FILTERED          = 1;\n    // const Z_HUFFMAN_ONLY      = 2;\n    // const Z_RLE               = 3;\n\n    var Z_FIXED = 4 // const Z_DEFAULT_STRATEGY  = 0;\n\n    /* Possible values of the data_type field (though see inflate()) */\n\n    var Z_BINARY = 0\n    var Z_TEXT = 1 // const Z_ASCII             = 1; // = Z_TEXT\n\n    var Z_UNKNOWN = 2\n    /* ============================================================================ */\n\n    function zero(buf) {\n      var len = buf.length\n\n      while (--len >= 0) {\n        buf[len] = 0\n      }\n    } // From zutil.h\n\n    var STORED_BLOCK = 0\n    var STATIC_TREES = 1\n    var DYN_TREES = 2\n    /* The three kinds of block type */\n\n    var MIN_MATCH = 3\n    var MAX_MATCH = 258\n    /* The minimum and maximum match lengths */\n    // From deflate.h\n\n    /* ===========================================================================\n     * Internal compression state.\n     */\n\n    var LENGTH_CODES = 29\n    /* number of length codes, not counting the special END_BLOCK code */\n\n    var LITERALS = 256\n    /* number of literal bytes 0..255 */\n\n    var L_CODES = LITERALS + 1 + LENGTH_CODES\n    /* number of Literal or Length codes, including the END_BLOCK code */\n\n    var D_CODES = 30\n    /* number of distance codes */\n\n    var BL_CODES = 19\n    /* number of codes used to transfer the bit lengths */\n\n    var HEAP_SIZE = 2 * L_CODES + 1\n    /* maximum heap size */\n\n    var MAX_BITS = 15\n    /* All codes must not exceed MAX_BITS bits */\n\n    var Buf_size = 16\n    /* size of bit buffer in bi_buf */\n\n    /* ===========================================================================\n     * Constants\n     */\n\n    var MAX_BL_BITS = 7\n    /* Bit length codes must not exceed MAX_BL_BITS bits */\n\n    var END_BLOCK = 256\n    /* end of block literal code */\n\n    var REP_3_6 = 16\n    /* repeat previous bit length 3-6 times (2 bits of repeat count) */\n\n    var REPZ_3_10 = 17\n    /* repeat a zero length 3-10 times  (3 bits of repeat count) */\n\n    var REPZ_11_138 = 18\n    /* repeat a zero length 11-138 times  (7 bits of repeat count) */\n\n    var extra_lbits =\n      /* extra bits for each length code */\n      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0])\n    var extra_dbits =\n      /* extra bits for each distance code */\n      new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13])\n    var extra_blbits =\n      /* extra bits for each bit length code */\n      new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])\n    var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])\n    /* eslint-enable comma-spacing,array-bracket-spacing */\n\n    /* The lengths of the bit length codes are sent in order of decreasing\n     * probability, to avoid transmitting the lengths for unused bit length codes.\n     */\n\n    /* ===========================================================================\n     * Local data. These are initialized only once.\n     */\n    // We pre-fill arrays with 0 to avoid uninitialized gaps\n\n    var DIST_CODE_LEN = 512\n    /* see definition of array dist_code below */\n    // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\n\n    var static_ltree = new Array((L_CODES + 2) * 2)\n    zero(static_ltree)\n    /* The static literal tree. Since the bit lengths are imposed, there is no\n     * need for the L_CODES extra codes used during heap construction. However\n     * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n     * below).\n     */\n\n    var static_dtree = new Array(D_CODES * 2)\n    zero(static_dtree)\n    /* The static distance tree. (Actually a trivial tree since all codes use\n     * 5 bits.)\n     */\n\n    var _dist_code = new Array(DIST_CODE_LEN)\n\n    zero(_dist_code)\n    /* Distance codes. The first 256 values correspond to the distances\n     * 3 .. 258, the last 256 values correspond to the top 8 bits of\n     * the 15 bit distances.\n     */\n\n    var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1)\n\n    zero(_length_code)\n    /* length code for each normalized match length (0 == MIN_MATCH) */\n\n    var base_length = new Array(LENGTH_CODES)\n    zero(base_length)\n    /* First normalized length for each code (0 = MIN_MATCH) */\n\n    var base_dist = new Array(D_CODES)\n    zero(base_dist)\n    /* First normalized distance for each code (0 = distance of 1) */\n\n    function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n      this.static_tree = static_tree\n      /* static tree or NULL */\n\n      this.extra_bits = extra_bits\n      /* extra bits for each code or NULL */\n\n      this.extra_base = extra_base\n      /* base index for extra_bits */\n\n      this.elems = elems\n      /* max number of elements in the tree */\n\n      this.max_length = max_length\n      /* max bit length for the codes */\n      // show if `static_tree` has data or dummy - needed for monomorphic objects\n\n      this.has_stree = static_tree && static_tree.length\n    }\n\n    var static_l_desc\n    var static_d_desc\n    var static_bl_desc\n\n    function TreeDesc(dyn_tree, stat_desc) {\n      this.dyn_tree = dyn_tree\n      /* the dynamic tree */\n\n      this.max_code = 0\n      /* largest code with non zero frequency */\n\n      this.stat_desc = stat_desc\n      /* the corresponding static tree */\n    }\n\n    var d_code = function d_code(dist) {\n      return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]\n    }\n    /* ===========================================================================\n     * Output a short LSB first on the stream.\n     * IN assertion: there is enough room in pendingBuf.\n     */\n\n    var put_short = function put_short(s, w) {\n      //    put_byte(s, (uch)((w) & 0xff));\n      //    put_byte(s, (uch)((ush)(w) >> 8));\n      s.pending_buf[s.pending++] = w & 0xff\n      s.pending_buf[s.pending++] = (w >>> 8) & 0xff\n    }\n    /* ===========================================================================\n     * Send a value on a given number of bits.\n     * IN assertion: length <= 16 and value fits in length bits.\n     */\n\n    var send_bits = function send_bits(s, value, length) {\n      if (s.bi_valid > Buf_size - length) {\n        s.bi_buf |= (value << s.bi_valid) & 0xffff\n        put_short(s, s.bi_buf)\n        s.bi_buf = value >> (Buf_size - s.bi_valid)\n        s.bi_valid += length - Buf_size\n      } else {\n        s.bi_buf |= (value << s.bi_valid) & 0xffff\n        s.bi_valid += length\n      }\n    }\n\n    var send_code = function send_code(s, c, tree) {\n      send_bits(\n        s,\n        tree[c * 2],\n        /* .Code */\n        tree[c * 2 + 1]\n        /* .Len */\n      )\n    }\n    /* ===========================================================================\n     * Reverse the first len bits of a code, using straightforward code (a faster\n     * method would use a table)\n     * IN assertion: 1 <= len <= 15\n     */\n\n    var bi_reverse = function bi_reverse(code, len) {\n      var res = 0\n\n      do {\n        res |= code & 1\n        code >>>= 1\n        res <<= 1\n      } while (--len > 0)\n\n      return res >>> 1\n    }\n    /* ===========================================================================\n     * Flush the bit buffer, keeping at most 7 bits in it.\n     */\n\n    var bi_flush = function bi_flush(s) {\n      if (s.bi_valid === 16) {\n        put_short(s, s.bi_buf)\n        s.bi_buf = 0\n        s.bi_valid = 0\n      } else if (s.bi_valid >= 8) {\n        s.pending_buf[s.pending++] = s.bi_buf & 0xff\n        s.bi_buf >>= 8\n        s.bi_valid -= 8\n      }\n    }\n    /* ===========================================================================\n     * Compute the optimal bit lengths for a tree and update the total bit length\n     * for the current block.\n     * IN assertion: the fields freq and dad are set, heap[heap_max] and\n     *    above are the tree nodes sorted by increasing frequency.\n     * OUT assertions: the field len is set to the optimal bit length, the\n     *     array bl_count contains the frequencies for each bit length.\n     *     The length opt_len is updated; static_len is also updated if stree is\n     *     not null.\n     */\n\n    var gen_bitlen = function gen_bitlen(\n      s,\n      desc //    deflate_state *s; //    tree_desc *desc;    /* the tree descriptor */\n    ) {\n      var tree = desc.dyn_tree\n      var max_code = desc.max_code\n      var stree = desc.stat_desc.static_tree\n      var has_stree = desc.stat_desc.has_stree\n      var extra = desc.stat_desc.extra_bits\n      var base = desc.stat_desc.extra_base\n      var max_length = desc.stat_desc.max_length\n      var h\n      /* heap index */\n\n      var n\n      var m\n      /* iterate over the tree elements */\n\n      var bits\n      /* bit length */\n\n      var xbits\n      /* extra bits */\n\n      var f\n      /* frequency */\n\n      var overflow = 0\n      /* number of elements with bit length too large */\n\n      for (bits = 0; bits <= MAX_BITS; bits++) {\n        s.bl_count[bits] = 0\n      }\n      /* In a first pass, compute the optimal bit lengths (which may\n       * overflow in the case of the bit length tree).\n       */\n\n      tree[s.heap[s.heap_max] * 2 + 1] =\n        /* .Len */\n        0\n      /* root of the heap */\n\n      for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n        n = s.heap[h]\n        bits =\n          tree[\n            tree[n * 2 + 1] *\n              /* .Dad */\n              2 +\n              1\n          ] +\n          /* .Len */\n          1\n\n        if (bits > max_length) {\n          bits = max_length\n          overflow++\n        }\n\n        tree[n * 2 + 1] =\n          /* .Len */\n          bits\n        /* We overwrite tree[n].Dad which is no longer needed */\n\n        if (n > max_code) {\n          continue\n        }\n        /* not a leaf node */\n\n        s.bl_count[bits]++\n        xbits = 0\n\n        if (n >= base) {\n          xbits = extra[n - base]\n        }\n\n        f = tree[n * 2]\n        /* .Freq */\n        s.opt_len += f * (bits + xbits)\n\n        if (has_stree) {\n          s.static_len +=\n            f *\n            (stree[n * 2 + 1] +\n              /* .Len */\n              xbits)\n        }\n      }\n\n      if (overflow === 0) {\n        return\n      } // Trace((stderr,\"\\nbit length overflow\\n\"));\n\n      /* This happens for example on obj2 and pic of the Calgary corpus */\n\n      /* Find the first bit length which could increase: */\n\n      do {\n        bits = max_length - 1\n\n        while (s.bl_count[bits] === 0) {\n          bits--\n        }\n\n        s.bl_count[bits]--\n        /* move one leaf down the tree */\n\n        s.bl_count[bits + 1] += 2\n        /* move one overflow item as its brother */\n\n        s.bl_count[max_length]--\n        /* The brother of the overflow item also moves one step up,\n         * but this does not affect bl_count[max_length]\n         */\n\n        overflow -= 2\n      } while (overflow > 0)\n      /* Now recompute all bit lengths, scanning in increasing frequency.\n       * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n       * lengths instead of fixing only the wrong ones. This idea is taken\n       * from 'ar' written by Haruhiko Okumura.)\n       */\n\n      for (bits = max_length; bits !== 0; bits--) {\n        n = s.bl_count[bits]\n\n        while (n !== 0) {\n          m = s.heap[--h]\n\n          if (m > max_code) {\n            continue\n          }\n\n          if (\n            tree[m * 2 + 1] !==\n            /* .Len */\n            bits\n          ) {\n            // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n            s.opt_len +=\n              (bits - tree[m * 2 + 1]) *\n              /* .Len */\n              tree[m * 2]\n            /* .Freq */\n            tree[m * 2 + 1] =\n              /* .Len */\n              bits\n          }\n\n          n--\n        }\n      }\n    }\n    /* ===========================================================================\n     * Generate the codes for a given tree and bit counts (which need not be\n     * optimal).\n     * IN assertion: the array bl_count contains the bit length statistics for\n     * the given tree and the field len is set for all tree elements.\n     * OUT assertion: the field code is set for all tree elements of non\n     *     zero code length.\n     */\n\n    var gen_codes = function gen_codes(\n      tree,\n      max_code,\n      bl_count\n      //    ct_data *tree;             /* the tree to decorate */\n      //    int max_code;              /* largest code with non zero frequency */\n      //    ushf *bl_count;            /* number of codes at each bit length */\n    ) {\n      var next_code = new Array(MAX_BITS + 1)\n      /* next code value for each bit length */\n\n      var code = 0\n      /* running code value */\n\n      var bits\n      /* bit index */\n\n      var n\n      /* code index */\n\n      /* The distribution counts are first used to generate the code values\n       * without bit reversal.\n       */\n\n      for (bits = 1; bits <= MAX_BITS; bits++) {\n        next_code[bits] = code = (code + bl_count[bits - 1]) << 1\n      }\n      /* Check that the bit counts in bl_count are consistent. The last code\n       * must be all ones.\n       */\n      // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n      //        \"inconsistent bit counts\");\n      // Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n\n      for (n = 0; n <= max_code; n++) {\n        var len = tree[n * 2 + 1]\n        /* .Len */\n        if (len === 0) {\n          continue\n        }\n        /* Now reverse the bits */\n\n        tree[n * 2] =\n          /* .Code */\n          bi_reverse(next_code[len]++, len) // Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n        //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n      }\n    }\n    /* ===========================================================================\n     * Initialize the various 'constant' tables.\n     */\n\n    var tr_static_init = function tr_static_init() {\n      var n\n      /* iterates over tree elements */\n\n      var bits\n      /* bit counter */\n\n      var length\n      /* length value */\n\n      var code\n      /* code value */\n\n      var dist\n      /* distance index */\n\n      var bl_count = new Array(MAX_BITS + 1)\n      /* number of codes at each bit length for an optimal tree */\n      // do check in _tr_init()\n      // if (static_init_done) return;\n\n      /* For some embedded targets, global variables are not initialized: */\n\n      /* #ifdef NO_INIT_GLOBAL_POINTERS\n      static_l_desc.static_tree = static_ltree;\n      static_l_desc.extra_bits = extra_lbits;\n      static_d_desc.static_tree = static_dtree;\n      static_d_desc.extra_bits = extra_dbits;\n      static_bl_desc.extra_bits = extra_blbits;\n    #endif */\n\n      /* Initialize the mapping length (0..255) -> length code (0..28) */\n\n      length = 0\n\n      for (code = 0; code < LENGTH_CODES - 1; code++) {\n        base_length[code] = length\n\n        for (n = 0; n < 1 << extra_lbits[code]; n++) {\n          _length_code[length++] = code\n        }\n      } // Assert (length == 256, \"tr_static_init: length != 256\");\n\n      /* Note that the length 255 (match length 258) can be represented\n       * in two different ways: code 284 + 5 bits or code 285, so we\n       * overwrite length_code[255] to use the best encoding:\n       */\n\n      _length_code[length - 1] = code\n      /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n\n      dist = 0\n\n      for (code = 0; code < 16; code++) {\n        base_dist[code] = dist\n\n        for (n = 0; n < 1 << extra_dbits[code]; n++) {\n          _dist_code[dist++] = code\n        }\n      } // Assert (dist == 256, \"tr_static_init: dist != 256\");\n\n      dist >>= 7\n      /* from now on, all distances are divided by 128 */\n\n      for (; code < D_CODES; code++) {\n        base_dist[code] = dist << 7\n\n        for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {\n          _dist_code[256 + dist++] = code\n        }\n      } // Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n\n      /* Construct the codes of the static literal tree */\n\n      for (bits = 0; bits <= MAX_BITS; bits++) {\n        bl_count[bits] = 0\n      }\n\n      n = 0\n\n      while (n <= 143) {\n        static_ltree[n * 2 + 1] =\n          /* .Len */\n          8\n        n++\n        bl_count[8]++\n      }\n\n      while (n <= 255) {\n        static_ltree[n * 2 + 1] =\n          /* .Len */\n          9\n        n++\n        bl_count[9]++\n      }\n\n      while (n <= 279) {\n        static_ltree[n * 2 + 1] =\n          /* .Len */\n          7\n        n++\n        bl_count[7]++\n      }\n\n      while (n <= 287) {\n        static_ltree[n * 2 + 1] =\n          /* .Len */\n          8\n        n++\n        bl_count[8]++\n      }\n      /* Codes 286 and 287 do not exist, but we must include them in the\n       * tree construction to get a canonical Huffman tree (longest code\n       * all ones)\n       */\n\n      gen_codes(static_ltree, L_CODES + 1, bl_count)\n      /* The static distance tree is trivial: */\n\n      for (n = 0; n < D_CODES; n++) {\n        static_dtree[n * 2 + 1] =\n          /* .Len */\n          5\n        static_dtree[n * 2] =\n          /* .Code */\n          bi_reverse(n, 5)\n      } // Now data ready and we can init static trees\n\n      static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS)\n      static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS)\n      static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS)\n      // static_init_done = true;\n    }\n    /* ===========================================================================\n     * Initialize a new block.\n     */\n\n    var init_block = function init_block(s) {\n      var n\n      /* iterates over tree elements */\n\n      /* Initialize the trees. */\n\n      for (n = 0; n < L_CODES; n++) {\n        s.dyn_ltree[n * 2] =\n          /* .Freq */\n          0\n      }\n\n      for (n = 0; n < D_CODES; n++) {\n        s.dyn_dtree[n * 2] =\n          /* .Freq */\n          0\n      }\n\n      for (n = 0; n < BL_CODES; n++) {\n        s.bl_tree[n * 2] =\n          /* .Freq */\n          0\n      }\n\n      s.dyn_ltree[END_BLOCK * 2] =\n        /* .Freq */\n        1\n      s.opt_len = s.static_len = 0\n      s.last_lit = s.matches = 0\n    }\n    /* ===========================================================================\n     * Flush the bit buffer and align the output on a byte boundary\n     */\n\n    var bi_windup = function bi_windup(s) {\n      if (s.bi_valid > 8) {\n        put_short(s, s.bi_buf)\n      } else if (s.bi_valid > 0) {\n        // put_byte(s, (Byte)s->bi_buf);\n        s.pending_buf[s.pending++] = s.bi_buf\n      }\n\n      s.bi_buf = 0\n      s.bi_valid = 0\n    }\n    /* ===========================================================================\n     * Copy a stored block, storing first the length and its\n     * one's complement if requested.\n     */\n\n    var copy_block = function copy_block(\n      s,\n      buf,\n      len,\n      header\n      // DeflateState *s;\n      // charf    *buf;    /* the input data */\n      // unsigned len;     /* its length */\n      // int      header;  /* true if block header must be written */\n    ) {\n      bi_windup(s)\n      /* align on byte boundary */\n\n      if (header) {\n        put_short(s, len)\n        put_short(s, ~len)\n      }\n      //  while (len--) {\n      //    put_byte(s, *buf++);\n      //  }\n\n      s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending)\n      s.pending += len\n    }\n    /* ===========================================================================\n     * Compares to subtrees, using the tree depth as tie breaker when\n     * the subtrees have equal frequency. This minimizes the worst case length.\n     */\n\n    var smaller = function smaller(tree, n, m, depth) {\n      var _n2 = n * 2\n\n      var _m2 = m * 2\n\n      return (\n        tree[_n2] <\n          /* .Freq */\n          tree[_m2] ||\n        /* .Freq */\n        (tree[_n2] ===\n          /* .Freq */\n          tree[_m2] &&\n          /* .Freq */\n          depth[n] <= depth[m])\n      )\n    }\n    /* ===========================================================================\n     * Restore the heap property by moving down the tree starting at node k,\n     * exchanging a node with the smallest of its two sons if necessary, stopping\n     * when the heap property is re-established (each father smaller than its\n     * two sons).\n     */\n\n    var pqdownheap = function pqdownheap(\n      s,\n      tree,\n      k\n      //    deflate_state *s;\n      //    ct_data *tree;  /* the tree to restore */\n      //    int k;               /* node to move down */\n    ) {\n      var v = s.heap[k]\n      var j = k << 1\n      /* left son of k */\n\n      while (j <= s.heap_len) {\n        /* Set j to the smallest of the two sons: */\n        if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n          j++\n        }\n        /* Exit if v is smaller than both sons */\n\n        if (smaller(tree, v, s.heap[j], s.depth)) {\n          break\n        }\n        /* Exchange v with the smallest son */\n\n        s.heap[k] = s.heap[j]\n        k = j\n        /* And continue down the tree, setting j to the left son of k */\n\n        j <<= 1\n      }\n\n      s.heap[k] = v\n    } // inlined manually\n    // const SMALLEST = 1;\n\n    /* ===========================================================================\n     * Send the block data compressed using the given Huffman trees\n     */\n\n    var compress_block = function compress_block(\n      s,\n      ltree,\n      dtree\n      //    deflate_state *s;\n      //    const ct_data *ltree; /* literal tree */\n      //    const ct_data *dtree; /* distance tree */\n    ) {\n      var dist\n      /* distance of matched string */\n\n      var lc\n      /* match length or unmatched char (if dist == 0) */\n\n      var lx = 0\n      /* running index in l_buf */\n\n      var code\n      /* the code to send */\n\n      var extra\n      /* number of extra bits to send */\n\n      if (s.last_lit !== 0) {\n        do {\n          dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | s.pending_buf[s.d_buf + lx * 2 + 1]\n          lc = s.pending_buf[s.l_buf + lx]\n          lx++\n\n          if (dist === 0) {\n            send_code(s, lc, ltree)\n            /* send a literal byte */\n            // Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n          } else {\n            /* Here, lc is the match length - MIN_MATCH */\n            code = _length_code[lc]\n            send_code(s, code + LITERALS + 1, ltree)\n            /* send the length code */\n\n            extra = extra_lbits[code]\n\n            if (extra !== 0) {\n              lc -= base_length[code]\n              send_bits(s, lc, extra)\n              /* send the extra length bits */\n            }\n\n            dist--\n            /* dist is now the match distance - 1 */\n\n            code = d_code(dist) // Assert (code < D_CODES, \"bad d_code\");\n\n            send_code(s, code, dtree)\n            /* send the distance code */\n\n            extra = extra_dbits[code]\n\n            if (extra !== 0) {\n              dist -= base_dist[code]\n              send_bits(s, dist, extra)\n              /* send the extra distance bits */\n            }\n          }\n          /* literal or match pair ? */\n\n          /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n          // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n          //       \"pendingBuf overflow\");\n        } while (lx < s.last_lit)\n      }\n\n      send_code(s, END_BLOCK, ltree)\n    }\n    /* ===========================================================================\n     * Construct one Huffman tree and assigns the code bit strings and lengths.\n     * Update the total bit length for the current block.\n     * IN assertion: the field freq is set for all tree elements.\n     * OUT assertions: the fields len and code are set to the optimal bit length\n     *     and corresponding code. The length opt_len is updated; static_len is\n     *     also updated if stree is not null. The field max_code is set.\n     */\n\n    var build_tree = function build_tree(\n      s,\n      desc //    deflate_state *s; //    tree_desc *desc; /* the tree descriptor */\n    ) {\n      var tree = desc.dyn_tree\n      var stree = desc.stat_desc.static_tree\n      var has_stree = desc.stat_desc.has_stree\n      var elems = desc.stat_desc.elems\n      var n\n      var m\n      /* iterate over heap elements */\n\n      var max_code = -1\n      /* largest code with non zero frequency */\n\n      var node\n      /* new node being created */\n\n      /* Construct the initial heap, with least frequent element in\n       * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n       * heap[0] is not used.\n       */\n\n      s.heap_len = 0\n      s.heap_max = HEAP_SIZE\n\n      for (n = 0; n < elems; n++) {\n        if (\n          tree[n * 2] !==\n          /* .Freq */\n          0\n        ) {\n          s.heap[++s.heap_len] = max_code = n\n          s.depth[n] = 0\n        } else {\n          tree[n * 2 + 1] =\n            /* .Len */\n            0\n        }\n      }\n      /* The pkzip format requires that at least one distance code exists,\n       * and that at least one bit should be sent even if there is only one\n       * possible code. So to avoid special checks later on we force at least\n       * two codes of non zero frequency.\n       */\n\n      while (s.heap_len < 2) {\n        node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0\n        tree[node * 2] =\n          /* .Freq */\n          1\n        s.depth[node] = 0\n        s.opt_len--\n\n        if (has_stree) {\n          s.static_len -= stree[node * 2 + 1]\n          /* .Len */\n        }\n        /* node is 0 or 1 so it does not have extra bits */\n      }\n\n      desc.max_code = max_code\n      /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n       * establish sub-heaps of increasing lengths:\n       */\n\n      for (\n        n = s.heap_len >> 1;\n        /* int /2 */\n        n >= 1;\n        n--\n      ) {\n        pqdownheap(s, tree, n)\n      }\n      /* Construct the Huffman tree by repeatedly combining the least two\n       * frequent nodes.\n       */\n\n      node = elems\n      /* next internal node of the tree */\n\n      do {\n        // pqremove(s, tree, n);  /* n = node of least frequency */\n\n        /** * pqremove ** */\n        n = s.heap[1]\n        /* SMALLEST */\n        s.heap[1] = s.heap[s.heap_len--]\n        /* SMALLEST */\n        pqdownheap(\n          s,\n          tree,\n          1\n          /* SMALLEST */\n        )\n        /***/\n\n        m = s.heap[1]\n        /* SMALLEST */\n        /* m = node of next least frequency */\n\n        s.heap[--s.heap_max] = n\n        /* keep the nodes sorted by frequency */\n\n        s.heap[--s.heap_max] = m\n        /* Create a new node father of n and m */\n\n        tree[node * 2] =\n          /* .Freq */\n          tree[n * 2] +\n          /* .Freq */\n          tree[m * 2]\n        /* .Freq */\n        s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1\n        tree[n * 2 + 1] =\n          /* .Dad */\n          tree[m * 2 + 1] =\n            /* .Dad */\n            node\n        /* and insert the new node in the heap */\n\n        s.heap[1] = node++\n        /* SMALLEST */\n        pqdownheap(\n          s,\n          tree,\n          1\n          /* SMALLEST */\n        )\n      } while (s.heap_len >= 2)\n\n      s.heap[--s.heap_max] = s.heap[1]\n      /* SMALLEST */\n      /* At this point, the fields freq and dad are set. We can now\n       * generate the bit lengths.\n       */\n\n      gen_bitlen(s, desc)\n      /* The field len is now set, we can generate the bit codes */\n\n      gen_codes(tree, max_code, s.bl_count)\n    }\n    /* ===========================================================================\n     * Scan a literal or distance tree to determine the frequencies of the codes\n     * in the bit length tree.\n     */\n\n    var scan_tree = function scan_tree(\n      s,\n      tree,\n      max_code\n      //    deflate_state *s;\n      //    ct_data *tree;   /* the tree to be scanned */\n      //    int max_code;    /* and its largest code of non zero frequency */\n    ) {\n      var n\n      /* iterates over all tree elements */\n\n      var prevlen = -1\n      /* last emitted length */\n\n      var curlen\n      /* length of current code */\n\n      var nextlen = tree[0 * 2 + 1]\n      /* .Len */\n      /* length of next code */\n\n      var count = 0\n      /* repeat count of the current code */\n\n      var max_count = 7\n      /* max repeat count */\n\n      var min_count = 4\n      /* min repeat count */\n\n      if (nextlen === 0) {\n        max_count = 138\n        min_count = 3\n      }\n\n      tree[(max_code + 1) * 2 + 1] =\n        /* .Len */\n        0xffff\n      /* guard */\n\n      for (n = 0; n <= max_code; n++) {\n        curlen = nextlen\n        nextlen = tree[(n + 1) * 2 + 1]\n        /* .Len */\n\n        if (++count < max_count && curlen === nextlen) {\n          continue\n        } else if (count < min_count) {\n          s.bl_tree[curlen * 2] +=\n            /* .Freq */\n            count\n        } else if (curlen !== 0) {\n          if (curlen !== prevlen) {\n            s.bl_tree[curlen * 2] /* .Freq */++\n          }\n\n          s.bl_tree[REP_3_6 * 2] /* .Freq */++\n        } else if (count <= 10) {\n          s.bl_tree[REPZ_3_10 * 2] /* .Freq */++\n        } else {\n          s.bl_tree[REPZ_11_138 * 2] /* .Freq */++\n        }\n\n        count = 0\n        prevlen = curlen\n\n        if (nextlen === 0) {\n          max_count = 138\n          min_count = 3\n        } else if (curlen === nextlen) {\n          max_count = 6\n          min_count = 3\n        } else {\n          max_count = 7\n          min_count = 4\n        }\n      }\n    }\n    /* ===========================================================================\n     * Send a literal or distance tree in compressed form, using the codes in\n     * bl_tree.\n     */\n\n    var send_tree = function send_tree(\n      s,\n      tree,\n      max_code\n      //    deflate_state *s;\n      //    ct_data *tree; /* the tree to be scanned */\n      //    int max_code;       /* and its largest code of non zero frequency */\n    ) {\n      var n\n      /* iterates over all tree elements */\n\n      var prevlen = -1\n      /* last emitted length */\n\n      var curlen\n      /* length of current code */\n\n      var nextlen = tree[0 * 2 + 1]\n      /* .Len */\n      /* length of next code */\n\n      var count = 0\n      /* repeat count of the current code */\n\n      var max_count = 7\n      /* max repeat count */\n\n      var min_count = 4\n      /* min repeat count */\n\n      /* tree[max_code+1].Len = -1; */\n\n      /* guard already set */\n\n      if (nextlen === 0) {\n        max_count = 138\n        min_count = 3\n      }\n\n      for (n = 0; n <= max_code; n++) {\n        curlen = nextlen\n        nextlen = tree[(n + 1) * 2 + 1]\n        /* .Len */\n\n        if (++count < max_count && curlen === nextlen) {\n          continue\n        } else if (count < min_count) {\n          do {\n            send_code(s, curlen, s.bl_tree)\n          } while (--count !== 0)\n        } else if (curlen !== 0) {\n          if (curlen !== prevlen) {\n            send_code(s, curlen, s.bl_tree)\n            count--\n          } // Assert(count >= 3 && count <= 6, \" 3_6?\");\n\n          send_code(s, REP_3_6, s.bl_tree)\n          send_bits(s, count - 3, 2)\n        } else if (count <= 10) {\n          send_code(s, REPZ_3_10, s.bl_tree)\n          send_bits(s, count - 3, 3)\n        } else {\n          send_code(s, REPZ_11_138, s.bl_tree)\n          send_bits(s, count - 11, 7)\n        }\n\n        count = 0\n        prevlen = curlen\n\n        if (nextlen === 0) {\n          max_count = 138\n          min_count = 3\n        } else if (curlen === nextlen) {\n          max_count = 6\n          min_count = 3\n        } else {\n          max_count = 7\n          min_count = 4\n        }\n      }\n    }\n    /* ===========================================================================\n     * Construct the Huffman tree for the bit lengths and return the index in\n     * bl_order of the last bit length code to send.\n     */\n\n    var build_bl_tree = function build_bl_tree(s) {\n      var max_blindex\n      /* index of last bit length code of non zero freq */\n\n      /* Determine the bit length frequencies for literal and distance trees */\n\n      scan_tree(s, s.dyn_ltree, s.l_desc.max_code)\n      scan_tree(s, s.dyn_dtree, s.d_desc.max_code)\n      /* Build the bit length tree: */\n\n      build_tree(s, s.bl_desc)\n      /* opt_len now includes the length of the tree representations, except\n       * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n       */\n\n      /* Determine the number of bit length codes to send. The pkzip format\n       * requires that at least 4 bit length codes be sent. (appnote.txt says\n       * 3 but the actual value used is 4.)\n       */\n\n      for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n        if (\n          s.bl_tree[bl_order[max_blindex] * 2 + 1] !==\n          /* .Len */\n          0\n        ) {\n          break\n        }\n      }\n      /* Update opt_len to include the bit length tree and counts */\n\n      s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4 // Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n      //        s->opt_len, s->static_len));\n\n      return max_blindex\n    }\n    /* ===========================================================================\n     * Send the header for a block using dynamic Huffman trees: the counts, the\n     * lengths of the bit length codes, the literal tree and the distance tree.\n     * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n     */\n\n    var send_all_trees = function send_all_trees(\n      s,\n      lcodes,\n      dcodes,\n      blcodes //    deflate_state *s; //    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n    ) {\n      var rank\n      /* index in bl_order */\n      // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n      // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n      //        \"too many codes\");\n      // Tracev((stderr, \"\\nbl counts: \"));\n\n      send_bits(s, lcodes - 257, 5)\n      /* not +255 as stated in appnote.txt */\n\n      send_bits(s, dcodes - 1, 5)\n      send_bits(s, blcodes - 4, 4)\n      /* not -3 as stated in appnote.txt */\n\n      for (rank = 0; rank < blcodes; rank++) {\n        // Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n        send_bits(\n          s,\n          s.bl_tree[bl_order[rank] * 2 + 1],\n          /* .Len */\n          3\n        )\n      } // Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n\n      send_tree(s, s.dyn_ltree, lcodes - 1)\n      /* literal tree */\n      // Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n\n      send_tree(s, s.dyn_dtree, dcodes - 1)\n      /* distance tree */\n      // Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n    }\n    /* ===========================================================================\n     * Check if the data type is TEXT or BINARY, using the following algorithm:\n     * - TEXT if the two conditions below are satisfied:\n     *    a) There are no non-portable control characters belonging to the\n     *       \"black list\" (0..6, 14..25, 28..31).\n     *    b) There is at least one printable character belonging to the\n     *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n     * - BINARY otherwise.\n     * - The following partially-portable control characters form a\n     *   \"gray list\" that is ignored in this detection algorithm:\n     *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n     * IN assertion: the fields Freq of dyn_ltree are set.\n     */\n\n    var detect_data_type = function detect_data_type(s) {\n      /* black_mask is the bit mask of black-listed bytes\n       * set bits 0..6, 14..25, and 28..31\n       * 0xf3ffc07f = binary 11110011111111111100000001111111\n       */\n      var black_mask = 0xf3ffc07f\n      var n\n      /* Check for non-textual (\"black-listed\") bytes. */\n\n      for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n        if (\n          black_mask & 1 &&\n          s.dyn_ltree[n * 2] !==\n            /* .Freq */\n            0\n        ) {\n          return Z_BINARY\n        }\n      }\n      /* Check for textual (\"white-listed\") bytes. */\n\n      if (\n        s.dyn_ltree[9 * 2] !==\n          /* .Freq */\n          0 ||\n        s.dyn_ltree[10 * 2] !==\n          /* .Freq */\n          0 ||\n        s.dyn_ltree[13 * 2] !==\n          /* .Freq */\n          0\n      ) {\n        return Z_TEXT\n      }\n\n      for (n = 32; n < LITERALS; n++) {\n        if (\n          s.dyn_ltree[n * 2] !==\n          /* .Freq */\n          0\n        ) {\n          return Z_TEXT\n        }\n      }\n      /* There are no \"black-listed\" or \"white-listed\" bytes:\n       * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n       */\n\n      return Z_BINARY\n    }\n\n    var static_init_done = false\n    /* ===========================================================================\n     * Initialize the tree data structures for a new zlib stream.\n     */\n\n    var _tr_init = function _tr_init(s) {\n      if (!static_init_done) {\n        tr_static_init()\n        static_init_done = true\n      }\n\n      s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc)\n      s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc)\n      s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc)\n      s.bi_buf = 0\n      s.bi_valid = 0\n      /* Initialize the first block of the first file: */\n\n      init_block(s)\n    }\n    /* ===========================================================================\n     * Send a stored block\n     */\n\n    var _tr_stored_block = function _tr_stored_block(\n      s,\n      buf,\n      stored_len,\n      last\n      // DeflateState *s;\n      // charf *buf;       /* input block */\n      // ulg stored_len;   /* length of input block */\n      // int last;         /* one if this is the last block for a file */\n    ) {\n      send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3)\n      /* send block type */\n\n      copy_block(s, buf, stored_len, true)\n      /* with header */\n    }\n    /* ===========================================================================\n     * Send one empty static block to give enough lookahead for inflate.\n     * This takes 10 bits, of which 7 may remain in the bit buffer.\n     */\n\n    var _tr_align = function _tr_align(s) {\n      send_bits(s, STATIC_TREES << 1, 3)\n      send_code(s, END_BLOCK, static_ltree)\n      bi_flush(s)\n    }\n    /* ===========================================================================\n     * Determine the best encoding for the current block: dynamic trees, static\n     * trees or store, and output the encoded block to the zip file.\n     */\n\n    var _tr_flush_block = function _tr_flush_block(\n      s,\n      buf,\n      stored_len,\n      last\n      // DeflateState *s;\n      // charf *buf;       /* input block, or NULL if too old */\n      // ulg stored_len;   /* length of input block */\n      // int last;         /* one if this is the last block for a file */\n    ) {\n      var opt_lenb\n      var static_lenb\n      /* opt_len and static_len in bytes */\n\n      var max_blindex = 0\n      /* index of last bit length code of non zero freq */\n\n      /* Build the Huffman trees unless a stored block is forced */\n\n      if (s.level > 0) {\n        /* Check if the file is binary or text */\n        if (s.strm.data_type === Z_UNKNOWN) {\n          s.strm.data_type = detect_data_type(s)\n        }\n        /* Construct the literal and distance trees */\n\n        build_tree(s, s.l_desc) // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n        //        s->static_len));\n\n        build_tree(s, s.d_desc) // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n        //        s->static_len));\n\n        /* At this point, opt_len and static_len are the total bit lengths of\n         * the compressed block data, excluding the tree representations.\n         */\n\n        /* Build the bit length tree for the above two trees, and get the index\n         * in bl_order of the last bit length code to send.\n         */\n\n        max_blindex = build_bl_tree(s)\n        /* Determine the best encoding. Compute the block lengths in bytes. */\n\n        opt_lenb = (s.opt_len + 3 + 7) >>> 3\n        static_lenb = (s.static_len + 3 + 7) >>> 3 // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n        //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n        //        s->last_lit));\n\n        if (static_lenb <= opt_lenb) {\n          opt_lenb = static_lenb\n        }\n      } else {\n        // Assert(buf != (char*)0, \"lost buf\");\n        opt_lenb = static_lenb = stored_len + 5\n        /* force a stored block */\n      }\n\n      if (stored_len + 4 <= opt_lenb && buf !== -1) {\n        /* 4: two words for the lengths */\n\n        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n         * Otherwise we can't have processed more than WSIZE input bytes since\n         * the last block flush, because compression would have been\n         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n         * transform a block into a stored block.\n         */\n        _tr_stored_block(s, buf, stored_len, last)\n      } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n        send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3)\n        compress_block(s, static_ltree, static_dtree)\n      } else {\n        send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3)\n        send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1)\n        compress_block(s, s.dyn_ltree, s.dyn_dtree)\n      } // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n\n      /* The above check is made mod 2^32, for files larger than 512 MB\n       * and uLong implemented on 32 bits.\n       */\n\n      init_block(s)\n\n      if (last) {\n        bi_windup(s)\n      } // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n      //       s->compressed_len-7*last));\n    }\n    /* ===========================================================================\n     * Save the match info and tally the frequency counts. Return true if\n     * the current block must be flushed.\n     */\n\n    var _tr_tally = function _tr_tally(\n      s,\n      dist,\n      lc\n      //    deflate_state *s;\n      //    unsigned dist;  /* distance of matched string */\n      //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n    ) {\n      // let out_length, in_length, dcode;\n      s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff\n      s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff\n      s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff\n      s.last_lit++\n\n      if (dist === 0) {\n        /* lc is the unmatched char */\n        s.dyn_ltree[lc * 2] /* .Freq */++\n      } else {\n        s.matches++\n        /* Here, lc is the match length - MIN_MATCH */\n\n        dist--\n        /* dist = match distance - 1 */\n        // Assert((ush)dist < (ush)MAX_DIST(s) &&\n        //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n        //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n\n        s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /* .Freq */++\n        s.dyn_dtree[d_code(dist) * 2] /* .Freq */++\n      } // (!) This block is disabled in zlib defaults,\n      // don't enable it for binary compatibility\n      // #ifdef TRUNCATE_BLOCK\n      //  /* Try to guess if it is profitable to stop the current block here */\n      //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n      //    /* Compute an upper bound for the compressed length */\n      //    out_length = s.last_lit*8;\n      //    in_length = s.strstart - s.block_start;\n      //\n      //    for (dcode = 0; dcode < D_CODES; dcode++) {\n      //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n      //    }\n      //    out_length >>>= 3;\n      //    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n      //    //       s->last_lit, in_length, out_length,\n      //    //       100L - out_length*100L/in_length));\n      //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n      //      return true;\n      //    }\n      //  }\n      // #endif\n\n      return s.last_lit === s.lit_bufsize - 1\n      /* We avoid equality with lit_bufsize because of wraparound at 64K\n       * on 16 bit machines and because stored blocks are restricted to\n       * 64K-1 bytes.\n       */\n    }\n\n    var _tr_init_1 = _tr_init\n    var _tr_stored_block_1 = _tr_stored_block\n    var _tr_flush_block_1 = _tr_flush_block\n    var _tr_tally_1 = _tr_tally\n    var _tr_align_1 = _tr_align\n    var trees = {\n      _tr_init: _tr_init_1,\n      _tr_stored_block: _tr_stored_block_1,\n      _tr_flush_block: _tr_flush_block_1,\n      _tr_tally: _tr_tally_1,\n      _tr_align: _tr_align_1,\n    }\n\n    // It isn't worth it to make additional optimizations as in original.\n    // Small size is preferable.\n    // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    var adler32 = function adler32(adler, buf, len, pos) {\n      var s1 = (adler & 0xffff) | 0\n      var s2 = ((adler >>> 16) & 0xffff) | 0\n      var n = 0\n\n      while (len !== 0) {\n        // Set limit ~ twice less than 5552, to keep\n        // s2 in 31-bits, because we force signed ints.\n        // in other case %= will fail.\n        n = len > 2000 ? 2000 : len\n        len -= n\n\n        do {\n          s1 = (s1 + buf[pos++]) | 0\n          s2 = (s2 + s1) | 0\n        } while (--n)\n\n        s1 %= 65521\n        s2 %= 65521\n      }\n\n      return s1 | (s2 << 16) | 0\n    }\n\n    var adler32_1 = adler32\n\n    // So write code to minimize size - no pregenerated tables\n    // and array tools dependencies.\n    // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n    // Use ordinary array, since untyped makes no boost here\n\n    var makeTable = function makeTable() {\n      var c\n      var table = []\n\n      for (var n = 0; n < 256; n++) {\n        c = n\n\n        for (var k = 0; k < 8; k++) {\n          c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1\n        }\n\n        table[n] = c\n      }\n\n      return table\n    } // Create table on load. Just 255 signed longs. Not a problem.\n\n    var crcTable = new Uint32Array(makeTable())\n\n    var crc32 = function crc32(crc, buf, len, pos) {\n      var t = crcTable\n      var end = pos + len\n      crc ^= -1\n\n      for (var i = pos; i < end; i++) {\n        crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xff]\n      }\n\n      return crc ^ -1 // >>> 0;\n    }\n\n    var crc32_1 = crc32\n\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    var messages = {\n      2: 'need dictionary',\n\n      /* Z_NEED_DICT       2  */\n      1: 'stream end',\n\n      /* Z_STREAM_END      1  */\n      0: '',\n\n      /* Z_OK              0  */\n      '-1': 'file error',\n\n      /* Z_ERRNO         (-1) */\n      '-2': 'stream error',\n\n      /* Z_STREAM_ERROR  (-2) */\n      '-3': 'data error',\n\n      /* Z_DATA_ERROR    (-3) */\n      '-4': 'insufficient memory',\n\n      /* Z_MEM_ERROR     (-4) */\n      '-5': 'buffer error',\n\n      /* Z_BUF_ERROR     (-5) */\n      '-6': 'incompatible version',\n      /* Z_VERSION_ERROR (-6) */\n    }\n\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    var constants = {\n      /* Allowed flush values; see deflate() and inflate() below for details */\n      Z_NO_FLUSH: 0,\n      Z_PARTIAL_FLUSH: 1,\n      Z_SYNC_FLUSH: 2,\n      Z_FULL_FLUSH: 3,\n      Z_FINISH: 4,\n      Z_BLOCK: 5,\n      Z_TREES: 6,\n\n      /* Return codes for the compression/decompression functions. Negative values\n       * are errors, positive values are used for special but normal events.\n       */\n      Z_OK: 0,\n      Z_STREAM_END: 1,\n      Z_NEED_DICT: 2,\n      Z_ERRNO: -1,\n      Z_STREAM_ERROR: -2,\n      Z_DATA_ERROR: -3,\n      Z_MEM_ERROR: -4,\n      Z_BUF_ERROR: -5,\n      // Z_VERSION_ERROR: -6,\n\n      /* compression levels */\n      Z_NO_COMPRESSION: 0,\n      Z_BEST_SPEED: 1,\n      Z_BEST_COMPRESSION: 9,\n      Z_DEFAULT_COMPRESSION: -1,\n      Z_FILTERED: 1,\n      Z_HUFFMAN_ONLY: 2,\n      Z_RLE: 3,\n      Z_FIXED: 4,\n      Z_DEFAULT_STRATEGY: 0,\n\n      /* Possible values of the data_type field (though see inflate()) */\n      Z_BINARY: 0,\n      Z_TEXT: 1,\n      // Z_ASCII:                1, // = Z_TEXT (deprecated)\n      Z_UNKNOWN: 2,\n\n      /* The deflate compression method */\n      Z_DEFLATED: 8, // Z_NULL:                 null // Use -1 or null inline, depending on var type\n    }\n\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    var _tr_init$1 = trees._tr_init\n    var _tr_stored_block$1 = trees._tr_stored_block\n    var _tr_flush_block$1 = trees._tr_flush_block\n    var _tr_tally$1 = trees._tr_tally\n    var _tr_align$1 = trees._tr_align\n    /* Public constants ========================================================== */\n\n    /* =========================================================================== */\n\n    var Z_NO_FLUSH = constants.Z_NO_FLUSH\n    var Z_PARTIAL_FLUSH = constants.Z_PARTIAL_FLUSH\n    var Z_FULL_FLUSH = constants.Z_FULL_FLUSH\n    var Z_FINISH = constants.Z_FINISH\n    var Z_BLOCK = constants.Z_BLOCK\n    var Z_OK = constants.Z_OK\n    var Z_STREAM_END = constants.Z_STREAM_END\n    var Z_STREAM_ERROR = constants.Z_STREAM_ERROR\n    var Z_DATA_ERROR = constants.Z_DATA_ERROR\n    var Z_BUF_ERROR = constants.Z_BUF_ERROR\n    var Z_DEFAULT_COMPRESSION = constants.Z_DEFAULT_COMPRESSION\n    var Z_FILTERED = constants.Z_FILTERED\n    var Z_HUFFMAN_ONLY = constants.Z_HUFFMAN_ONLY\n    var Z_RLE = constants.Z_RLE\n    var Z_FIXED$1 = constants.Z_FIXED\n    var Z_DEFAULT_STRATEGY = constants.Z_DEFAULT_STRATEGY\n    var Z_UNKNOWN$1 = constants.Z_UNKNOWN\n    var Z_DEFLATED = constants.Z_DEFLATED\n    /* ============================================================================ */\n\n    var MAX_MEM_LEVEL = 9\n    /* Maximum value for memLevel in deflateInit2 */\n\n    var MAX_WBITS = 15\n    /* 32K LZ77 window */\n\n    var DEF_MEM_LEVEL = 8\n    var LENGTH_CODES$1 = 29\n    /* number of length codes, not counting the special END_BLOCK code */\n\n    var LITERALS$1 = 256\n    /* number of literal bytes 0..255 */\n\n    var L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1\n    /* number of Literal or Length codes, including the END_BLOCK code */\n\n    var D_CODES$1 = 30\n    /* number of distance codes */\n\n    var BL_CODES$1 = 19\n    /* number of codes used to transfer the bit lengths */\n\n    var HEAP_SIZE$1 = 2 * L_CODES$1 + 1\n    /* maximum heap size */\n\n    var MAX_BITS$1 = 15\n    /* All codes must not exceed MAX_BITS bits */\n\n    var MIN_MATCH$1 = 3\n    var MAX_MATCH$1 = 258\n    var MIN_LOOKAHEAD = MAX_MATCH$1 + MIN_MATCH$1 + 1\n    var PRESET_DICT = 0x20\n    var INIT_STATE = 42\n    var EXTRA_STATE = 69\n    var NAME_STATE = 73\n    var COMMENT_STATE = 91\n    var HCRC_STATE = 103\n    var BUSY_STATE = 113\n    var FINISH_STATE = 666\n    var BS_NEED_MORE = 1\n    /* block not completed, need more input or more output */\n\n    var BS_BLOCK_DONE = 2\n    /* block flush performed */\n\n    var BS_FINISH_STARTED = 3\n    /* finish started, need only more output at next deflate */\n\n    var BS_FINISH_DONE = 4\n    /* finish done, accept no more input or output */\n\n    var OS_CODE = 0x03 // Unix :) . Don't detect, use this default.\n\n    var err = function err(strm, errorCode) {\n      strm.msg = messages[errorCode]\n      return errorCode\n    }\n\n    var rank = function rank(f) {\n      return (f << 1) - (f > 4 ? 9 : 0)\n    }\n\n    var zero$1 = function zero(buf) {\n      var len = buf.length\n\n      while (--len >= 0) {\n        buf[len] = 0\n      }\n    }\n\n    var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {\n      return ((prev << s.hash_shift) ^ data) & s.hash_mask\n    } // This hash causes less collisions, https://github.com/nodeca/pako/issues/135\n    // But breaks binary compatibility\n    // let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;\n\n    var HASH = HASH_ZLIB\n    /* =========================================================================\n     * Flush as much pending output as possible. All deflate() output goes\n     * through this function so some applications may wish to modify it\n     * to avoid allocating a large strm->output buffer and copying into it.\n     * (See also read_buf()).\n     */\n\n    var flush_pending = function flush_pending(strm) {\n      var s = strm.state // _tr_flush_bits(s);\n\n      var len = s.pending\n\n      if (len > strm.avail_out) {\n        len = strm.avail_out\n      }\n\n      if (len === 0) {\n        return\n      }\n\n      strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out)\n      strm.next_out += len\n      s.pending_out += len\n      strm.total_out += len\n      strm.avail_out -= len\n      s.pending -= len\n\n      if (s.pending === 0) {\n        s.pending_out = 0\n      }\n    }\n\n    var flush_block_only = function flush_block_only(s, last) {\n      _tr_flush_block$1(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last)\n\n      s.block_start = s.strstart\n      flush_pending(s.strm)\n    }\n\n    var put_byte = function put_byte(s, b) {\n      s.pending_buf[s.pending++] = b\n    }\n    /* =========================================================================\n     * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n     * IN assertion: the stream state is correct and there is enough room in\n     * pending_buf.\n     */\n\n    var putShortMSB = function putShortMSB(s, b) {\n      //  put_byte(s, (Byte)(b >> 8));\n      //  put_byte(s, (Byte)(b & 0xff));\n      s.pending_buf[s.pending++] = (b >>> 8) & 0xff\n      s.pending_buf[s.pending++] = b & 0xff\n    }\n    /* ===========================================================================\n     * Read a new buffer from the current input stream, update the adler32\n     * and total number of bytes read.  All deflate() input goes through\n     * this function so some applications may wish to modify it to avoid\n     * allocating a large strm->input buffer and copying from it.\n     * (See also flush_pending()).\n     */\n\n    var read_buf = function read_buf(strm, buf, start, size) {\n      var len = strm.avail_in\n\n      if (len > size) {\n        len = size\n      }\n\n      if (len === 0) {\n        return 0\n      }\n\n      strm.avail_in -= len // zmemcpy(buf, strm->next_in, len);\n\n      buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start)\n\n      if (strm.state.wrap === 1) {\n        strm.adler = adler32_1(strm.adler, buf, len, start)\n      } else if (strm.state.wrap === 2) {\n        strm.adler = crc32_1(strm.adler, buf, len, start)\n      }\n\n      strm.next_in += len\n      strm.total_in += len\n      return len\n    }\n    /* ===========================================================================\n     * Set match_start to the longest match starting at the given string and\n     * return its length. Matches shorter or equal to prev_length are discarded,\n     * in which case the result is equal to prev_length and match_start is\n     * garbage.\n     * IN assertions: cur_match is the head of the hash chain for the current\n     *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n     * OUT assertion: the match length is not greater than s->lookahead.\n     */\n\n    var longest_match = function longest_match(s, cur_match) {\n      var chain_length = s.max_chain_length\n      /* max hash chain length */\n\n      var scan = s.strstart\n      /* current string */\n\n      var match\n      /* matched string */\n\n      var len\n      /* length of current match */\n\n      var best_len = s.prev_length\n      /* best match length so far */\n\n      var nice_match = s.nice_match\n      /* stop if match long enough */\n\n      var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0\n      /* NIL */\n      var _win = s.window // shortcut\n\n      var wmask = s.w_mask\n      var prev = s.prev\n      /* Stop when cur_match becomes <= limit. To simplify the code,\n       * we prevent matches with the string of window index 0.\n       */\n\n      var strend = s.strstart + MAX_MATCH$1\n      var scan_end1 = _win[scan + best_len - 1]\n      var scan_end = _win[scan + best_len]\n      /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n       * It is easy to get rid of this optimization if necessary.\n       */\n      // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n\n      /* Do not waste too much time if we already have a good match: */\n\n      if (s.prev_length >= s.good_match) {\n        chain_length >>= 2\n      }\n      /* Do not look for matches beyond the end of the input. This is necessary\n       * to make deflate deterministic.\n       */\n\n      if (nice_match > s.lookahead) {\n        nice_match = s.lookahead\n      } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n\n      do {\n        // Assert(cur_match < s->strstart, \"no future\");\n        match = cur_match\n        /* Skip to next match if the match length cannot increase\n         * or if the match length is less than 2.  Note that the checks below\n         * for insufficient lookahead only occur occasionally for performance\n         * reasons.  Therefore uninitialized memory will be accessed, and\n         * conditional jumps will be made that depend on those values.\n         * However the length of the match is limited to the lookahead, so\n         * the output of deflate is not affected by the uninitialized values.\n         */\n\n        if (\n          _win[match + best_len] !== scan_end ||\n          _win[match + best_len - 1] !== scan_end1 ||\n          _win[match] !== _win[scan] ||\n          _win[++match] !== _win[scan + 1]\n        ) {\n          continue\n        }\n        /* The check at best_len-1 can be removed because it will be made\n         * again later. (This heuristic is not always a win.)\n         * It is not necessary to compare scan[2] and match[2] since they\n         * are always equal when the other bytes match, given that\n         * the hash keys are equal and that HASH_BITS >= 8.\n         */\n\n        scan += 2\n        match++ // Assert(*scan == *match, \"match[2]?\");\n\n        /* We check for insufficient lookahead only every 8th comparison;\n         * the 256th check will be made at strstart+258.\n         */\n\n        do {\n          /* jshint noempty:false */\n        } while (\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          _win[++scan] === _win[++match] &&\n          scan < strend\n        ) // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n\n        len = MAX_MATCH$1 - (strend - scan)\n        scan = strend - MAX_MATCH$1\n\n        if (len > best_len) {\n          s.match_start = cur_match\n          best_len = len\n\n          if (len >= nice_match) {\n            break\n          }\n\n          scan_end1 = _win[scan + best_len - 1]\n          scan_end = _win[scan + best_len]\n        }\n      } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0)\n\n      if (best_len <= s.lookahead) {\n        return best_len\n      }\n\n      return s.lookahead\n    }\n    /* ===========================================================================\n     * Fill the window when the lookahead becomes insufficient.\n     * Updates strstart and lookahead.\n     *\n     * IN assertion: lookahead < MIN_LOOKAHEAD\n     * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n     *    At least one byte has been read, or avail_in == 0; reads are\n     *    performed for at least two bytes (required for the zip translate_eol\n     *    option -- not supported here).\n     */\n\n    var fill_window = function fill_window(s) {\n      var _w_size = s.w_size\n      var p\n      var n\n      var m\n      var more\n      var str // Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n\n      do {\n        more = s.window_size - s.lookahead - s.strstart // JS ints have 32 bit, block below not needed\n\n        /* Deal with !@#$% 64K limit: */\n        // if (sizeof(int) <= 2) {\n        //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n        //        more = wsize;\n        //\n        //  } else if (more == (unsigned)(-1)) {\n        //        /* Very unlikely, but possible on 16 bit machine if\n        //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n        //         */\n        //        more--;\n        //    }\n        // }\n\n        /* If the window is almost full and there is insufficient lookahead,\n         * move the upper half to the lower one to make room in the upper half.\n         */\n\n        if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n          s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0)\n          s.match_start -= _w_size\n          s.strstart -= _w_size\n          /* we now have strstart >= MAX_DIST */\n\n          s.block_start -= _w_size\n          /* Slide the hash table (could be avoided with 32 bit values\n         at the expense of memory usage). We slide even when level == 0\n         to keep the hash table consistent if we switch back to level > 0\n         later. (Using level 0 permanently is not an optimal usage of\n         zlib, so we don't care about this pathological case.)\n         */\n\n          n = s.hash_size\n          p = n\n\n          do {\n            m = s.head[--p]\n            s.head[p] = m >= _w_size ? m - _w_size : 0\n          } while (--n)\n\n          n = _w_size\n          p = n\n\n          do {\n            m = s.prev[--p]\n            s.prev[p] = m >= _w_size ? m - _w_size : 0\n            /* If n is not on any hash chain, prev[n] is garbage but\n             * its value will never be used.\n             */\n          } while (--n)\n\n          more += _w_size\n        }\n\n        if (s.strm.avail_in === 0) {\n          break\n        }\n        /* If there was no sliding:\n         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n         *    more == window_size - lookahead - strstart\n         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n         * => more >= window_size - 2*WSIZE + 2\n         * In the BIG_MEM or MMAP case (not yet supported),\n         *   window_size == input_size + MIN_LOOKAHEAD  &&\n         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n         * Otherwise, window_size == 2*WSIZE so more >= 2.\n         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n         */\n        // Assert(more >= 2, \"more < 2\");\n\n        n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more)\n        s.lookahead += n\n        /* Initialize the hash value now that we have some input: */\n\n        if (s.lookahead + s.insert >= MIN_MATCH$1) {\n          str = s.strstart - s.insert\n          s.ins_h = s.window[str]\n          /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n\n          s.ins_h = HASH(s, s.ins_h, s.window[str + 1]) // #if MIN_MATCH != 3\n          //        Call update_hash() MIN_MATCH-3 more times\n          // #endif\n\n          while (s.insert) {\n            /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n            s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1])\n            s.prev[str & s.w_mask] = s.head[s.ins_h]\n            s.head[s.ins_h] = str\n            str++\n            s.insert--\n\n            if (s.lookahead + s.insert < MIN_MATCH$1) {\n              break\n            }\n          }\n        }\n        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n         * but this is not important since only literal bytes will be emitted.\n         */\n      } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0)\n      /* If the WIN_INIT bytes after the end of the current data have never been\n       * written, then zero those bytes in order to avoid memory check reports of\n       * the use of uninitialized (or uninitialised as Julian writes) bytes by\n       * the longest match routines.  Update the high water mark for the next\n       * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n       * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n       */\n      //  if (s.high_water < s.window_size) {\n      //    const curr = s.strstart + s.lookahead;\n      //    let init = 0;\n      //\n      //    if (s.high_water < curr) {\n      //      /* Previous high water mark below current data -- zero WIN_INIT\n      //       * bytes or up to end of window, whichever is less.\n      //       */\n      //      init = s.window_size - curr;\n      //      if (init > WIN_INIT)\n      //        init = WIN_INIT;\n      //      zmemzero(s->window + curr, (unsigned)init);\n      //      s->high_water = curr + init;\n      //    }\n      //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n      //      /* High water mark at or above current data, but below current data\n      //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n      //       * to end of window, whichever is less.\n      //       */\n      //      init = (ulg)curr + WIN_INIT - s->high_water;\n      //      if (init > s->window_size - s->high_water)\n      //        init = s->window_size - s->high_water;\n      //      zmemzero(s->window + s->high_water, (unsigned)init);\n      //      s->high_water += init;\n      //    }\n      //  }\n      //\n      //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n      //    \"not enough room for search\");\n    }\n    /* ===========================================================================\n     * Copy without compression as much as possible from the input stream, return\n     * the current block state.\n     * This function does not insert new strings in the dictionary since\n     * uncompressible data is probably not useful. This function is used\n     * only for the level=0 compression option.\n     * NOTE: this function should be optimized to avoid extra copying from\n     * window to pending_buf.\n     */\n\n    var deflate_stored = function deflate_stored(s, flush) {\n      /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n       * to pending_buf_size, and each stored block has a 5 byte header:\n       */\n      var max_block_size = 0xffff\n\n      if (max_block_size > s.pending_buf_size - 5) {\n        max_block_size = s.pending_buf_size - 5\n      }\n      /* Copy as much as possible from input to output: */\n\n      for (;;) {\n        /* Fill the window as much as possible: */\n        if (s.lookahead <= 1) {\n          // Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n          //  s->block_start >= (long)s->w_size, \"slide too late\");\n          //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n          //        s.block_start >= s.w_size)) {\n          //        throw  new Error(\"slide too late\");\n          //      }\n          fill_window(s)\n\n          if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n            return BS_NEED_MORE\n          }\n\n          if (s.lookahead === 0) {\n            break\n          }\n          /* flush the current block */\n        } // Assert(s->block_start >= 0L, \"block gone\");\n        //    if (s.block_start < 0) throw new Error(\"block gone\");\n\n        s.strstart += s.lookahead\n        s.lookahead = 0\n        /* Emit a stored block if pending_buf will be full: */\n\n        var max_start = s.block_start + max_block_size\n\n        if (s.strstart === 0 || s.strstart >= max_start) {\n          /* strstart == 0 is possible when wraparound on 16-bit machine */\n          s.lookahead = s.strstart - max_start\n          s.strstart = max_start\n          /** * FLUSH_BLOCK(s, 0); ** */\n\n          flush_block_only(s, false)\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n          /***/\n        }\n        /* Flush if we may have to slide, otherwise block_start may become\n         * negative and the data will be gone:\n         */\n\n        if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n          /** * FLUSH_BLOCK(s, 0); ** */\n          flush_block_only(s, false)\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n          /***/\n        }\n      }\n\n      s.insert = 0\n\n      if (flush === Z_FINISH) {\n        /** * FLUSH_BLOCK(s, 1); ** */\n        flush_block_only(s, true)\n\n        if (s.strm.avail_out === 0) {\n          return BS_FINISH_STARTED\n        }\n        /***/\n\n        return BS_FINISH_DONE\n      }\n\n      if (s.strstart > s.block_start) {\n        /** * FLUSH_BLOCK(s, 0); ** */\n        flush_block_only(s, false)\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE\n        }\n        /***/\n      }\n\n      return BS_NEED_MORE\n    }\n    /* ===========================================================================\n     * Compress as much as possible from the input stream, return the current\n     * block state.\n     * This function does not perform lazy evaluation of matches and inserts\n     * new strings in the dictionary only for unmatched strings or for short\n     * matches. It is used only for the fast compression options.\n     */\n\n    var deflate_fast = function deflate_fast(s, flush) {\n      var hash_head\n      /* head of the hash chain */\n\n      var bflush\n      /* set if current block must be flushed */\n\n      for (;;) {\n        /* Make sure that we always have enough lookahead, except\n         * at the end of the input file. We need MAX_MATCH bytes\n         * for the next match, plus MIN_MATCH bytes to insert the\n         * string following the next match.\n         */\n        if (s.lookahead < MIN_LOOKAHEAD) {\n          fill_window(s)\n\n          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n            return BS_NEED_MORE\n          }\n\n          if (s.lookahead === 0) {\n            break\n            /* flush the current block */\n          }\n        }\n        /* Insert the string window[strstart .. strstart+2] in the\n         * dictionary, and set hash_head to the head of the hash chain:\n         */\n\n        hash_head = 0\n        /* NIL */\n\n        if (s.lookahead >= MIN_MATCH$1) {\n          /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1])\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]\n          s.head[s.ins_h] = s.strstart\n          /***/\n        }\n        /* Find the longest match, discarding those <= prev_length.\n         * At this point we have always match_length < MIN_MATCH\n         */\n\n        if (\n          hash_head !== 0 &&\n          /* NIL */\n          s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n        ) {\n          /* To simplify the code, we prevent matches with the string\n           * of window index 0 (in particular we have to avoid a match\n           * of the string with itself at the start of the input file).\n           */\n          s.match_length = longest_match(s, hash_head)\n          /* longest_match() sets match_start */\n        }\n\n        if (s.match_length >= MIN_MATCH$1) {\n          // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n\n          /** * _tr_tally_dist(s, s.strstart - s.match_start,\n                       s.match_length - MIN_MATCH, bflush); ** */\n          bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1)\n          s.lookahead -= s.match_length\n          /* Insert new strings in the hash table only if the match length\n           * is not too large. This saves time but degrades compression.\n           */\n\n          if (\n            s.match_length <= s.max_lazy_match &&\n            /* max_insert_length */\n            s.lookahead >= MIN_MATCH$1\n          ) {\n            s.match_length--\n            /* string at strstart already in table */\n\n            do {\n              s.strstart++\n              /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n\n              s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1])\n              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]\n              s.head[s.ins_h] = s.strstart\n              /***/\n\n              /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n               * always MIN_MATCH bytes ahead.\n               */\n            } while (--s.match_length !== 0)\n\n            s.strstart++\n          } else {\n            s.strstart += s.match_length\n            s.match_length = 0\n            s.ins_h = s.window[s.strstart]\n            /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n\n            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]) // #if MIN_MATCH != 3\n            //                Call UPDATE_HASH() MIN_MATCH-3 more times\n            // #endif\n\n            /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n             * matter since it will be recomputed at next deflate call.\n             */\n          }\n        } else {\n          /* No match, output a literal byte */\n          // Tracevv((stderr,\"%c\", s.window[s.strstart]));\n\n          /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n          bflush = _tr_tally$1(s, 0, s.window[s.strstart])\n          s.lookahead--\n          s.strstart++\n        }\n\n        if (bflush) {\n          /** * FLUSH_BLOCK(s, 0); ** */\n          flush_block_only(s, false)\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n          /***/\n        }\n      }\n\n      s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1\n\n      if (flush === Z_FINISH) {\n        /** * FLUSH_BLOCK(s, 1); ** */\n        flush_block_only(s, true)\n\n        if (s.strm.avail_out === 0) {\n          return BS_FINISH_STARTED\n        }\n        /***/\n\n        return BS_FINISH_DONE\n      }\n\n      if (s.last_lit) {\n        /** * FLUSH_BLOCK(s, 0); ** */\n        flush_block_only(s, false)\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE\n        }\n        /***/\n      }\n\n      return BS_BLOCK_DONE\n    }\n    /* ===========================================================================\n     * Same as above, but achieves better compression. We use a lazy\n     * evaluation for matches: a match is finally adopted only if there is\n     * no better match at the next window position.\n     */\n\n    var deflate_slow = function deflate_slow(s, flush) {\n      var hash_head\n      /* head of hash chain */\n\n      var bflush\n      /* set if current block must be flushed */\n\n      var max_insert\n      /* Process the input block. */\n\n      for (;;) {\n        /* Make sure that we always have enough lookahead, except\n         * at the end of the input file. We need MAX_MATCH bytes\n         * for the next match, plus MIN_MATCH bytes to insert the\n         * string following the next match.\n         */\n        if (s.lookahead < MIN_LOOKAHEAD) {\n          fill_window(s)\n\n          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n            return BS_NEED_MORE\n          }\n\n          if (s.lookahead === 0) {\n            break\n          }\n          /* flush the current block */\n        }\n        /* Insert the string window[strstart .. strstart+2] in the\n         * dictionary, and set hash_head to the head of the hash chain:\n         */\n\n        hash_head = 0\n        /* NIL */\n\n        if (s.lookahead >= MIN_MATCH$1) {\n          /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1])\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]\n          s.head[s.ins_h] = s.strstart\n          /***/\n        }\n        /* Find the longest match, discarding those <= prev_length.\n         */\n\n        s.prev_length = s.match_length\n        s.prev_match = s.match_start\n        s.match_length = MIN_MATCH$1 - 1\n\n        if (\n          hash_head !== 0 &&\n          /* NIL */\n          s.prev_length < s.max_lazy_match &&\n          s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n          /* MAX_DIST(s) */\n        ) {\n          /* To simplify the code, we prevent matches with the string\n           * of window index 0 (in particular we have to avoid a match\n           * of the string with itself at the start of the input file).\n           */\n          s.match_length = longest_match(s, hash_head)\n          /* longest_match() sets match_start */\n\n          if (\n            s.match_length <= 5 &&\n            (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096))\n            /* TOO_FAR */\n          ) {\n            /* If prev_match is also MIN_MATCH, match_start is garbage\n             * but we will ignore the current match anyway.\n             */\n            s.match_length = MIN_MATCH$1 - 1\n          }\n        }\n        /* If there was a match at the previous step and the current\n         * match is not better, output the previous match:\n         */\n\n        if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {\n          max_insert = s.strstart + s.lookahead - MIN_MATCH$1\n          /* Do not insert strings in hash table beyond this. */\n          // check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n\n          /** *_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                       s.prev_length - MIN_MATCH, bflush);** */\n\n          bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1)\n          /* Insert in hash table all strings up to the end of the match.\n           * strstart-1 and strstart are already inserted. If there is not\n           * enough lookahead, the last two strings are not inserted in\n           * the hash table.\n           */\n\n          s.lookahead -= s.prev_length - 1\n          s.prev_length -= 2\n\n          do {\n            if (++s.strstart <= max_insert) {\n              /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n              s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1])\n              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]\n              s.head[s.ins_h] = s.strstart\n              /***/\n            }\n          } while (--s.prev_length !== 0)\n\n          s.match_available = 0\n          s.match_length = MIN_MATCH$1 - 1\n          s.strstart++\n\n          if (bflush) {\n            /** * FLUSH_BLOCK(s, 0); ** */\n            flush_block_only(s, false)\n\n            if (s.strm.avail_out === 0) {\n              return BS_NEED_MORE\n            }\n            /***/\n          }\n        } else if (s.match_available) {\n          /* If there was no match at the previous position, output a\n           * single literal. If there was a match but the current match\n           * is longer, truncate the previous match to a single literal.\n           */\n          // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n\n          /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n          bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1])\n\n          if (bflush) {\n            /** * FLUSH_BLOCK_ONLY(s, 0) ** */\n            flush_block_only(s, false)\n            /***/\n          }\n\n          s.strstart++\n          s.lookahead--\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n        } else {\n          /* There is no previous match to compare with, wait for\n           * the next step to decide.\n           */\n          s.match_available = 1\n          s.strstart++\n          s.lookahead--\n        }\n      } // Assert (flush != Z_NO_FLUSH, \"no flush?\");\n\n      if (s.match_available) {\n        // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n\n        /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n        bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1])\n        s.match_available = 0\n      }\n\n      s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1\n\n      if (flush === Z_FINISH) {\n        /** * FLUSH_BLOCK(s, 1); ** */\n        flush_block_only(s, true)\n\n        if (s.strm.avail_out === 0) {\n          return BS_FINISH_STARTED\n        }\n        /***/\n\n        return BS_FINISH_DONE\n      }\n\n      if (s.last_lit) {\n        /** * FLUSH_BLOCK(s, 0); ** */\n        flush_block_only(s, false)\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE\n        }\n        /***/\n      }\n\n      return BS_BLOCK_DONE\n    }\n    /* ===========================================================================\n     * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n     * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n     * deflate switches away from Z_RLE.)\n     */\n\n    var deflate_rle = function deflate_rle(s, flush) {\n      var bflush\n      /* set if current block must be flushed */\n\n      var prev\n      /* byte at distance one to match */\n\n      var scan\n      var strend\n      /* scan goes up to strend for length of run */\n\n      var _win = s.window\n\n      for (;;) {\n        /* Make sure that we always have enough lookahead, except\n         * at the end of the input file. We need MAX_MATCH bytes\n         * for the longest run, plus one for the unrolled loop.\n         */\n        if (s.lookahead <= MAX_MATCH$1) {\n          fill_window(s)\n\n          if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {\n            return BS_NEED_MORE\n          }\n\n          if (s.lookahead === 0) {\n            break\n          }\n          /* flush the current block */\n        }\n        /* See how many times the previous byte repeats */\n\n        s.match_length = 0\n\n        if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {\n          scan = s.strstart - 1\n          prev = _win[scan]\n\n          if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n            strend = s.strstart + MAX_MATCH$1\n\n            do {\n              /* jshint noempty:false */\n            } while (\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              prev === _win[++scan] &&\n              scan < strend\n            )\n\n            s.match_length = MAX_MATCH$1 - (strend - scan)\n\n            if (s.match_length > s.lookahead) {\n              s.match_length = s.lookahead\n            }\n          } // Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n        }\n        /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n\n        if (s.match_length >= MIN_MATCH$1) {\n          // check_match(s, s.strstart, s.strstart - 1, s.match_length);\n\n          /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */\n          bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1)\n          s.lookahead -= s.match_length\n          s.strstart += s.match_length\n          s.match_length = 0\n        } else {\n          /* No match, output a literal byte */\n          // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n\n          /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n          bflush = _tr_tally$1(s, 0, s.window[s.strstart])\n          s.lookahead--\n          s.strstart++\n        }\n\n        if (bflush) {\n          /** * FLUSH_BLOCK(s, 0); ** */\n          flush_block_only(s, false)\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n          /***/\n        }\n      }\n\n      s.insert = 0\n\n      if (flush === Z_FINISH) {\n        /** * FLUSH_BLOCK(s, 1); ** */\n        flush_block_only(s, true)\n\n        if (s.strm.avail_out === 0) {\n          return BS_FINISH_STARTED\n        }\n        /***/\n\n        return BS_FINISH_DONE\n      }\n\n      if (s.last_lit) {\n        /** * FLUSH_BLOCK(s, 0); ** */\n        flush_block_only(s, false)\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE\n        }\n        /***/\n      }\n\n      return BS_BLOCK_DONE\n    }\n    /* ===========================================================================\n     * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n     * (It will be regenerated if this run of deflate switches away from Huffman.)\n     */\n\n    var deflate_huff = function deflate_huff(s, flush) {\n      var bflush\n      /* set if current block must be flushed */\n\n      for (;;) {\n        /* Make sure that we have a literal to write. */\n        if (s.lookahead === 0) {\n          fill_window(s)\n\n          if (s.lookahead === 0) {\n            if (flush === Z_NO_FLUSH) {\n              return BS_NEED_MORE\n            }\n\n            break\n            /* flush the current block */\n          }\n        }\n        /* Output a literal byte */\n\n        s.match_length = 0 // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n\n        /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n\n        bflush = _tr_tally$1(s, 0, s.window[s.strstart])\n        s.lookahead--\n        s.strstart++\n\n        if (bflush) {\n          /** * FLUSH_BLOCK(s, 0); ** */\n          flush_block_only(s, false)\n\n          if (s.strm.avail_out === 0) {\n            return BS_NEED_MORE\n          }\n          /***/\n        }\n      }\n\n      s.insert = 0\n\n      if (flush === Z_FINISH) {\n        /** * FLUSH_BLOCK(s, 1); ** */\n        flush_block_only(s, true)\n\n        if (s.strm.avail_out === 0) {\n          return BS_FINISH_STARTED\n        }\n        /***/\n\n        return BS_FINISH_DONE\n      }\n\n      if (s.last_lit) {\n        /** * FLUSH_BLOCK(s, 0); ** */\n        flush_block_only(s, false)\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE\n        }\n        /***/\n      }\n\n      return BS_BLOCK_DONE\n    }\n    /* Values for max_lazy_match, good_match and max_chain_length, depending on\n     * the desired pack level (0..9). The values given below have been tuned to\n     * exclude worst case performance for pathological files. Better values may be\n     * found for specific files.\n     */\n\n    function Config(good_length, max_lazy, nice_length, max_chain, func) {\n      this.good_length = good_length\n      this.max_lazy = max_lazy\n      this.nice_length = nice_length\n      this.max_chain = max_chain\n      this.func = func\n    }\n\n    var configuration_table = [\n      /*      good lazy nice chain */\n      new Config(0, 0, 0, 0, deflate_stored),\n      /* 0 store only */\n      new Config(4, 4, 8, 4, deflate_fast),\n      /* 1 max speed, no lazy matches */\n      new Config(4, 5, 16, 8, deflate_fast),\n      /* 2 */\n      new Config(4, 6, 32, 32, deflate_fast),\n      /* 3 */\n      new Config(4, 4, 16, 16, deflate_slow),\n      /* 4 lazy matches */\n      new Config(8, 16, 32, 32, deflate_slow),\n      /* 5 */\n      new Config(8, 16, 128, 128, deflate_slow),\n      /* 6 */\n      new Config(8, 32, 128, 256, deflate_slow),\n      /* 7 */\n      new Config(32, 128, 258, 1024, deflate_slow),\n      /* 8 */\n      new Config(32, 258, 258, 4096, deflate_slow),\n      /* 9 max compression */\n    ]\n    /* ===========================================================================\n     * Initialize the \"longest match\" routines for a new zlib stream\n     */\n\n    var lm_init = function lm_init(s) {\n      s.window_size = 2 * s.w_size\n      /** * CLEAR_HASH(s); ** */\n\n      zero$1(s.head) // Fill with NIL (= 0);\n\n      /* Set the default configuration parameters:\n       */\n\n      s.max_lazy_match = configuration_table[s.level].max_lazy\n      s.good_match = configuration_table[s.level].good_length\n      s.nice_match = configuration_table[s.level].nice_length\n      s.max_chain_length = configuration_table[s.level].max_chain\n      s.strstart = 0\n      s.block_start = 0\n      s.lookahead = 0\n      s.insert = 0\n      s.match_length = s.prev_length = MIN_MATCH$1 - 1\n      s.match_available = 0\n      s.ins_h = 0\n    }\n\n    function DeflateState() {\n      this.strm = null\n      /* pointer back to this zlib stream */\n\n      this.status = 0\n      /* as the name implies */\n\n      this.pending_buf = null\n      /* output still pending */\n\n      this.pending_buf_size = 0\n      /* size of pending_buf */\n\n      this.pending_out = 0\n      /* next pending byte to output to the stream */\n\n      this.pending = 0\n      /* nb of bytes in the pending buffer */\n\n      this.wrap = 0\n      /* bit 0 true for zlib, bit 1 true for gzip */\n\n      this.gzhead = null\n      /* gzip header information to write */\n\n      this.gzindex = 0\n      /* where in extra, name, or comment */\n\n      this.method = Z_DEFLATED\n      /* can only be DEFLATED */\n\n      this.last_flush = -1\n      /* value of flush param for previous deflate call */\n\n      this.w_size = 0\n      /* LZ77 window size (32K by default) */\n\n      this.w_bits = 0\n      /* log2(w_size)  (8..16) */\n\n      this.w_mask = 0\n      /* w_size - 1 */\n\n      this.window = null\n      /* Sliding window. Input bytes are read into the second half of the window,\n       * and move to the first half later to keep a dictionary of at least wSize\n       * bytes. With this organization, matches are limited to a distance of\n       * wSize-MAX_MATCH bytes, but this ensures that IO is always\n       * performed with a length multiple of the block size.\n       */\n\n      this.window_size = 0\n      /* Actual size of window: 2*wSize, except when the user input buffer\n       * is directly used as sliding window.\n       */\n\n      this.prev = null\n      /* Link to older string with same hash index. To limit the size of this\n       * array to 64K, this link is maintained only for the last 32K strings.\n       * An index in this array is thus a window index modulo 32K.\n       */\n\n      this.head = null\n      /* Heads of the hash chains or NIL. */\n\n      this.ins_h = 0\n      /* hash index of string to be inserted */\n\n      this.hash_size = 0\n      /* number of elements in hash table */\n\n      this.hash_bits = 0\n      /* log2(hash_size) */\n\n      this.hash_mask = 0\n      /* hash_size-1 */\n\n      this.hash_shift = 0\n      /* Number of bits by which ins_h must be shifted at each input\n       * step. It must be such that after MIN_MATCH steps, the oldest\n       * byte no longer takes part in the hash key, that is:\n       *   hash_shift * MIN_MATCH >= hash_bits\n       */\n\n      this.block_start = 0\n      /* Window position at the beginning of the current output block. Gets\n       * negative when the window is moved backwards.\n       */\n\n      this.match_length = 0\n      /* length of best match */\n\n      this.prev_match = 0\n      /* previous match */\n\n      this.match_available = 0\n      /* set if previous match exists */\n\n      this.strstart = 0\n      /* start of string to insert */\n\n      this.match_start = 0\n      /* start of matching string */\n\n      this.lookahead = 0\n      /* number of valid bytes ahead in window */\n\n      this.prev_length = 0\n      /* Length of the best match at previous step. Matches not greater than this\n       * are discarded. This is used in the lazy match evaluation.\n       */\n\n      this.max_chain_length = 0\n      /* To speed up deflation, hash chains are never searched beyond this\n       * length.  A higher limit improves compression ratio but degrades the\n       * speed.\n       */\n\n      this.max_lazy_match = 0\n      /* Attempt to find a better match only when the current match is strictly\n       * smaller than this value. This mechanism is used only for compression\n       * levels >= 4.\n       */\n      // That's alias to max_lazy_match, don't use directly\n      // this.max_insert_length = 0;\n\n      /* Insert new strings in the hash table only if the match length is not\n       * greater than this length. This saves time but degrades compression.\n       * max_insert_length is used only for compression levels <= 3.\n       */\n\n      this.level = 0\n      /* compression level (1..9) */\n\n      this.strategy = 0\n      /* favor or force Huffman coding */\n\n      this.good_match = 0\n      /* Use a faster search when the previous match is longer than this */\n\n      this.nice_match = 0\n      /* Stop searching when current match exceeds this */\n\n      /* used by trees.c: */\n\n      /* Didn't use ct_data typedef below to suppress compiler warning */\n      // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n      // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n      // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n      // Use flat array of DOUBLE size, with interleaved fata,\n      // because JS does not support effective\n\n      this.dyn_ltree = new Uint16Array(HEAP_SIZE$1 * 2)\n      this.dyn_dtree = new Uint16Array((2 * D_CODES$1 + 1) * 2)\n      this.bl_tree = new Uint16Array((2 * BL_CODES$1 + 1) * 2)\n      zero$1(this.dyn_ltree)\n      zero$1(this.dyn_dtree)\n      zero$1(this.bl_tree)\n      this.l_desc = null\n      /* desc. for literal tree */\n\n      this.d_desc = null\n      /* desc. for distance tree */\n\n      this.bl_desc = null\n      /* desc. for bit length tree */\n      // ush bl_count[MAX_BITS+1];\n\n      this.bl_count = new Uint16Array(MAX_BITS$1 + 1)\n      /* number of codes at each bit length for an optimal tree */\n      // int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n\n      this.heap = new Uint16Array(2 * L_CODES$1 + 1)\n      /* heap used to build the Huffman trees */\n\n      zero$1(this.heap)\n      this.heap_len = 0\n      /* number of elements in the heap */\n\n      this.heap_max = 0\n      /* element of largest frequency */\n\n      /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n       * The same heap array is used to build all trees.\n       */\n\n      this.depth = new Uint16Array(2 * L_CODES$1 + 1) // uch depth[2*L_CODES+1];\n\n      zero$1(this.depth)\n      /* Depth of each subtree used as tie breaker for trees of equal frequency\n       */\n\n      this.l_buf = 0\n      /* buffer index for literals or lengths */\n\n      this.lit_bufsize = 0\n      /* Size of match buffer for literals/lengths.  There are 4 reasons for\n       * limiting lit_bufsize to 64K:\n       *   - frequencies can be kept in 16 bit counters\n       *   - if compression is not successful for the first block, all input\n       *     data is still in the window so we can still emit a stored block even\n       *     when input comes from standard input.  (This can also be done for\n       *     all blocks if lit_bufsize is not greater than 32K.)\n       *   - if compression is not successful for a file smaller than 64K, we can\n       *     even emit a stored file instead of a stored block (saving 5 bytes).\n       *     This is applicable only for zip (not gzip or zlib).\n       *   - creating new Huffman trees less frequently may not provide fast\n       *     adaptation to changes in the input data statistics. (Take for\n       *     example a binary file with poorly compressible code followed by\n       *     a highly compressible string table.) Smaller buffer sizes give\n       *     fast adaptation but have of course the overhead of transmitting\n       *     trees more frequently.\n       *   - I can't count above 4\n       */\n\n      this.last_lit = 0\n      /* running index in l_buf */\n\n      this.d_buf = 0\n      /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n       * the same number of elements. To use different lengths, an extra flag\n       * array would be necessary.\n       */\n\n      this.opt_len = 0\n      /* bit length of current block with optimal trees */\n\n      this.static_len = 0\n      /* bit length of current block with static trees */\n\n      this.matches = 0\n      /* number of string matches in current block */\n\n      this.insert = 0\n      /* bytes at end of window left to insert */\n\n      this.bi_buf = 0\n      /* Output buffer. bits are inserted starting at the bottom (least\n       * significant bits).\n       */\n\n      this.bi_valid = 0\n      /* Number of valid bits in bi_buf.  All bits above the last valid bit\n       * are always zero.\n       */\n      // Used for window memory init. We safely ignore it for JS. That makes\n      // sense only for pointers and memory check tools.\n      // this.high_water = 0;\n\n      /* High water mark offset in window for initialized bytes -- bytes above\n       * this are set to zero in order to avoid memory check warnings when\n       * longest match routines access bytes past the input.  This is then\n       * updated to the new high water mark.\n       */\n    }\n\n    var deflateResetKeep = function deflateResetKeep(strm) {\n      if (!strm || !strm.state) {\n        return err(strm, Z_STREAM_ERROR)\n      }\n\n      strm.total_in = strm.total_out = 0\n      strm.data_type = Z_UNKNOWN$1\n      var s = strm.state\n      s.pending = 0\n      s.pending_out = 0\n\n      if (s.wrap < 0) {\n        s.wrap = -s.wrap\n        /* was made negative by deflate(..., Z_FINISH); */\n      }\n\n      s.status = s.wrap ? INIT_STATE : BUSY_STATE\n      strm.adler =\n        s.wrap === 2\n          ? 0 // crc32(0, Z_NULL, 0)\n          : 1 // adler32(0, Z_NULL, 0)\n\n      s.last_flush = Z_NO_FLUSH\n\n      _tr_init$1(s)\n\n      return Z_OK\n    }\n\n    var deflateReset = function deflateReset(strm) {\n      var ret = deflateResetKeep(strm)\n\n      if (ret === Z_OK) {\n        lm_init(strm.state)\n      }\n\n      return ret\n    }\n\n    var deflateSetHeader = function deflateSetHeader(strm, head) {\n      if (!strm || !strm.state) {\n        return Z_STREAM_ERROR\n      }\n\n      if (strm.state.wrap !== 2) {\n        return Z_STREAM_ERROR\n      }\n\n      strm.state.gzhead = head\n      return Z_OK\n    }\n\n    var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n      if (!strm) {\n        // === Z_NULL\n        return Z_STREAM_ERROR\n      }\n\n      var wrap = 1\n\n      if (level === Z_DEFAULT_COMPRESSION) {\n        level = 6\n      }\n\n      if (windowBits < 0) {\n        /* suppress zlib wrapper */\n        wrap = 0\n        windowBits = -windowBits\n      } else if (windowBits > 15) {\n        wrap = 2\n        /* write gzip wrapper instead */\n\n        windowBits -= 16\n      }\n\n      if (\n        memLevel < 1 ||\n        memLevel > MAX_MEM_LEVEL ||\n        method !== Z_DEFLATED ||\n        windowBits < 8 ||\n        windowBits > 15 ||\n        level < 0 ||\n        level > 9 ||\n        strategy < 0 ||\n        strategy > Z_FIXED$1\n      ) {\n        return err(strm, Z_STREAM_ERROR)\n      }\n\n      if (windowBits === 8) {\n        windowBits = 9\n      }\n      /* until 256-byte window bug fixed */\n\n      var s = new DeflateState()\n      strm.state = s\n      s.strm = strm\n      s.wrap = wrap\n      s.gzhead = null\n      s.w_bits = windowBits\n      s.w_size = 1 << s.w_bits\n      s.w_mask = s.w_size - 1\n      s.hash_bits = memLevel + 7\n      s.hash_size = 1 << s.hash_bits\n      s.hash_mask = s.hash_size - 1\n      s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1)\n      s.window = new Uint8Array(s.w_size * 2)\n      s.head = new Uint16Array(s.hash_size)\n      s.prev = new Uint16Array(s.w_size) // Don't need mem init magic for JS.\n      // s.high_water = 0;  /* nothing written to s->window yet */\n\n      s.lit_bufsize = 1 << (memLevel + 6)\n      /* 16K elements by default */\n\n      s.pending_buf_size = s.lit_bufsize * 4\n      // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n      // s->pending_buf = (uchf *) overlay;\n\n      // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n      s.pending_buf = new Uint8Array(s.pending_buf_size)\n      // s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n\n      s.d_buf = 1 * s.lit_bufsize // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n\n      s.l_buf = (1 + 2) * s.lit_bufsize\n      s.level = level\n      s.strategy = strategy\n      s.method = method\n      return deflateReset(strm)\n    }\n\n    var deflateInit = function deflateInit(strm, level) {\n      return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)\n    }\n\n    var deflate = function deflate(strm, flush) {\n      var beg\n      var val // for gzip header write only\n\n      if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n        return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR\n      }\n\n      var s = strm.state\n\n      if (!strm.output || (!strm.input && strm.avail_in !== 0) || (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n        return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR)\n      }\n\n      s.strm = strm\n      /* just in case */\n\n      var old_flush = s.last_flush\n      s.last_flush = flush\n      /* Write the header */\n\n      if (s.status === INIT_STATE) {\n        if (s.wrap === 2) {\n          // GZIP header\n          strm.adler = 0 // crc32(0L, Z_NULL, 0);\n\n          put_byte(s, 31)\n          put_byte(s, 139)\n          put_byte(s, 8)\n\n          if (!s.gzhead) {\n            // s->gzhead == Z_NULL\n            put_byte(s, 0)\n            put_byte(s, 0)\n            put_byte(s, 0)\n            put_byte(s, 0)\n            put_byte(s, 0)\n            put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0)\n            put_byte(s, OS_CODE)\n            s.status = BUSY_STATE\n          } else {\n            put_byte(\n              s,\n              (s.gzhead.text ? 1 : 0) +\n                (s.gzhead.hcrc ? 2 : 0) +\n                (!s.gzhead.extra ? 0 : 4) +\n                (!s.gzhead.name ? 0 : 8) +\n                (!s.gzhead.comment ? 0 : 16)\n            )\n            put_byte(s, s.gzhead.time & 0xff)\n            put_byte(s, (s.gzhead.time >> 8) & 0xff)\n            put_byte(s, (s.gzhead.time >> 16) & 0xff)\n            put_byte(s, (s.gzhead.time >> 24) & 0xff)\n            put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0)\n            put_byte(s, s.gzhead.os & 0xff)\n\n            if (s.gzhead.extra && s.gzhead.extra.length) {\n              put_byte(s, s.gzhead.extra.length & 0xff)\n              put_byte(s, (s.gzhead.extra.length >> 8) & 0xff)\n            }\n\n            if (s.gzhead.hcrc) {\n              strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0)\n            }\n\n            s.gzindex = 0\n            s.status = EXTRA_STATE\n          }\n        } // DEFLATE header\n        else {\n          var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8\n          var level_flags = -1\n\n          if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n            level_flags = 0\n          } else if (s.level < 6) {\n            level_flags = 1\n          } else if (s.level === 6) {\n            level_flags = 2\n          } else {\n            level_flags = 3\n          }\n\n          header |= level_flags << 6\n\n          if (s.strstart !== 0) {\n            header |= PRESET_DICT\n          }\n\n          header += 31 - (header % 31)\n          s.status = BUSY_STATE\n          putShortMSB(s, header)\n          /* Save the adler32 of the preset dictionary: */\n\n          if (s.strstart !== 0) {\n            putShortMSB(s, strm.adler >>> 16)\n            putShortMSB(s, strm.adler & 0xffff)\n          }\n\n          strm.adler = 1 // adler32(0L, Z_NULL, 0);\n        }\n      } // #ifdef GZIP\n\n      if (s.status === EXTRA_STATE) {\n        if (\n          s.gzhead.extra\n          /* != Z_NULL */\n        ) {\n          beg = s.pending\n          /* start of bytes to update crc */\n\n          while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n            if (s.pending === s.pending_buf_size) {\n              if (s.gzhead.hcrc && s.pending > beg) {\n                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n              }\n\n              flush_pending(strm)\n              beg = s.pending\n\n              if (s.pending === s.pending_buf_size) {\n                break\n              }\n            }\n\n            put_byte(s, s.gzhead.extra[s.gzindex] & 0xff)\n            s.gzindex++\n          }\n\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n          }\n\n          if (s.gzindex === s.gzhead.extra.length) {\n            s.gzindex = 0\n            s.status = NAME_STATE\n          }\n        } else {\n          s.status = NAME_STATE\n        }\n      }\n\n      if (s.status === NAME_STATE) {\n        if (\n          s.gzhead.name\n          /* != Z_NULL */\n        ) {\n          beg = s.pending\n          /* start of bytes to update crc */\n          // int val;\n\n          do {\n            if (s.pending === s.pending_buf_size) {\n              if (s.gzhead.hcrc && s.pending > beg) {\n                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n              }\n\n              flush_pending(strm)\n              beg = s.pending\n\n              if (s.pending === s.pending_buf_size) {\n                val = 1\n                break\n              }\n            } // JS specific: little magic to add zero terminator to end of string\n\n            if (s.gzindex < s.gzhead.name.length) {\n              val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff\n            } else {\n              val = 0\n            }\n\n            put_byte(s, val)\n          } while (val !== 0)\n\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n          }\n\n          if (val === 0) {\n            s.gzindex = 0\n            s.status = COMMENT_STATE\n          }\n        } else {\n          s.status = COMMENT_STATE\n        }\n      }\n\n      if (s.status === COMMENT_STATE) {\n        if (\n          s.gzhead.comment\n          /* != Z_NULL */\n        ) {\n          beg = s.pending\n          /* start of bytes to update crc */\n          // int val;\n\n          do {\n            if (s.pending === s.pending_buf_size) {\n              if (s.gzhead.hcrc && s.pending > beg) {\n                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n              }\n\n              flush_pending(strm)\n              beg = s.pending\n\n              if (s.pending === s.pending_buf_size) {\n                val = 1\n                break\n              }\n            } // JS specific: little magic to add zero terminator to end of string\n\n            if (s.gzindex < s.gzhead.comment.length) {\n              val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff\n            } else {\n              val = 0\n            }\n\n            put_byte(s, val)\n          } while (val !== 0)\n\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg)\n          }\n\n          if (val === 0) {\n            s.status = HCRC_STATE\n          }\n        } else {\n          s.status = HCRC_STATE\n        }\n      }\n\n      if (s.status === HCRC_STATE) {\n        if (s.gzhead.hcrc) {\n          if (s.pending + 2 > s.pending_buf_size) {\n            flush_pending(strm)\n          }\n\n          if (s.pending + 2 <= s.pending_buf_size) {\n            put_byte(s, strm.adler & 0xff)\n            put_byte(s, (strm.adler >> 8) & 0xff)\n            strm.adler = 0 // crc32(0L, Z_NULL, 0);\n\n            s.status = BUSY_STATE\n          }\n        } else {\n          s.status = BUSY_STATE\n        }\n      } // #endif\n\n      /* Flush as much pending output as possible */\n\n      if (s.pending !== 0) {\n        flush_pending(strm)\n\n        if (strm.avail_out === 0) {\n          /* Since avail_out is 0, deflate will be called again with\n           * more output space, but possibly with both pending and\n           * avail_in equal to zero. There won't be anything to do,\n           * but this is not an error situation so make sure we\n           * return OK instead of BUF_ERROR at next call of deflate:\n           */\n          s.last_flush = -1\n          return Z_OK\n        }\n        /* Make sure there is something to do and avoid duplicate consecutive\n         * flushes. For repeated and useless calls with Z_FINISH, we keep\n         * returning Z_STREAM_END instead of Z_BUF_ERROR.\n         */\n      } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n        return err(strm, Z_BUF_ERROR)\n      }\n      /* User must not provide more input after the first FINISH: */\n\n      if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n        return err(strm, Z_BUF_ERROR)\n      }\n      /* Start a new block or continue the current one.\n       */\n\n      if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n        var bstate =\n          s.strategy === Z_HUFFMAN_ONLY\n            ? deflate_huff(s, flush)\n            : s.strategy === Z_RLE\n            ? deflate_rle(s, flush)\n            : configuration_table[s.level].func(s, flush)\n\n        if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n          s.status = FINISH_STATE\n        }\n\n        if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n          if (strm.avail_out === 0) {\n            s.last_flush = -1\n            /* avoid BUF_ERROR next call, see above */\n          }\n\n          return Z_OK\n          /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n           * of deflate should use the same flush parameter to make sure\n           * that the flush is complete. So we don't have to output an\n           * empty block here, this will be done at next call. This also\n           * ensures that for a very small output buffer, we emit at most\n           * one empty block.\n           */\n        }\n\n        if (bstate === BS_BLOCK_DONE) {\n          if (flush === Z_PARTIAL_FLUSH) {\n            _tr_align$1(s)\n          } else if (flush !== Z_BLOCK) {\n            /* FULL_FLUSH or SYNC_FLUSH */\n            _tr_stored_block$1(s, 0, 0, false)\n            /* For a full flush, this empty block will be recognized\n             * as a special marker by inflate_sync().\n             */\n\n            if (flush === Z_FULL_FLUSH) {\n              /** * CLEAR_HASH(s); ** */\n\n              /* forget history */\n              zero$1(s.head) // Fill with NIL (= 0);\n\n              if (s.lookahead === 0) {\n                s.strstart = 0\n                s.block_start = 0\n                s.insert = 0\n              }\n            }\n          }\n\n          flush_pending(strm)\n\n          if (strm.avail_out === 0) {\n            s.last_flush = -1\n            /* avoid BUF_ERROR at next call, see above */\n\n            return Z_OK\n          }\n        }\n      } // Assert(strm->avail_out > 0, \"bug2\");\n      // if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n\n      if (flush !== Z_FINISH) {\n        return Z_OK\n      }\n\n      if (s.wrap <= 0) {\n        return Z_STREAM_END\n      }\n      /* Write the trailer */\n\n      if (s.wrap === 2) {\n        put_byte(s, strm.adler & 0xff)\n        put_byte(s, (strm.adler >> 8) & 0xff)\n        put_byte(s, (strm.adler >> 16) & 0xff)\n        put_byte(s, (strm.adler >> 24) & 0xff)\n        put_byte(s, strm.total_in & 0xff)\n        put_byte(s, (strm.total_in >> 8) & 0xff)\n        put_byte(s, (strm.total_in >> 16) & 0xff)\n        put_byte(s, (strm.total_in >> 24) & 0xff)\n      } else {\n        putShortMSB(s, strm.adler >>> 16)\n        putShortMSB(s, strm.adler & 0xffff)\n      }\n\n      flush_pending(strm)\n      /* If avail_out is zero, the application will call deflate again\n       * to flush the rest.\n       */\n\n      if (s.wrap > 0) {\n        s.wrap = -s.wrap\n      }\n      /* write the trailer only once! */\n\n      return s.pending !== 0 ? Z_OK : Z_STREAM_END\n    }\n\n    var deflateEnd = function deflateEnd(strm) {\n      if (\n        !strm ||\n        /* == Z_NULL */\n        !strm.state\n        /* == Z_NULL */\n      ) {\n        return Z_STREAM_ERROR\n      }\n\n      var status = strm.state.status\n\n      if (\n        status !== INIT_STATE &&\n        status !== EXTRA_STATE &&\n        status !== NAME_STATE &&\n        status !== COMMENT_STATE &&\n        status !== HCRC_STATE &&\n        status !== BUSY_STATE &&\n        status !== FINISH_STATE\n      ) {\n        return err(strm, Z_STREAM_ERROR)\n      }\n\n      strm.state = null\n      return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK\n    }\n    /* =========================================================================\n     * Initializes the compression dictionary from the given byte\n     * sequence without producing any compressed output.\n     */\n\n    var deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {\n      var dictLength = dictionary.length\n\n      if (\n        !strm ||\n        /* == Z_NULL */\n        !strm.state\n        /* == Z_NULL */\n      ) {\n        return Z_STREAM_ERROR\n      }\n\n      var s = strm.state\n      var wrap = s.wrap\n\n      if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n        return Z_STREAM_ERROR\n      }\n      /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n\n      if (wrap === 1) {\n        /* adler32(strm->adler, dictionary, dictLength); */\n        strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0)\n      }\n\n      s.wrap = 0\n      /* avoid computing Adler-32 in read_buf */\n\n      /* if dictionary would fill window, just replace the history */\n\n      if (dictLength >= s.w_size) {\n        if (wrap === 0) {\n          /* already empty otherwise */\n\n          /** * CLEAR_HASH(s); ** */\n          zero$1(s.head) // Fill with NIL (= 0);\n\n          s.strstart = 0\n          s.block_start = 0\n          s.insert = 0\n        }\n        /* use the tail */\n        // dictionary = dictionary.slice(dictLength - s.w_size);\n\n        var tmpDict = new Uint8Array(s.w_size)\n        tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0)\n        dictionary = tmpDict\n        dictLength = s.w_size\n      }\n      /* insert dictionary into window and hash */\n\n      var avail = strm.avail_in\n      var next = strm.next_in\n      var input = strm.input\n      strm.avail_in = dictLength\n      strm.next_in = 0\n      strm.input = dictionary\n      fill_window(s)\n\n      while (s.lookahead >= MIN_MATCH$1) {\n        var str = s.strstart\n        var n = s.lookahead - (MIN_MATCH$1 - 1)\n\n        do {\n          /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n          s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1])\n          s.prev[str & s.w_mask] = s.head[s.ins_h]\n          s.head[s.ins_h] = str\n          str++\n        } while (--n)\n\n        s.strstart = str\n        s.lookahead = MIN_MATCH$1 - 1\n        fill_window(s)\n      }\n\n      s.strstart += s.lookahead\n      s.block_start = s.strstart\n      s.insert = s.lookahead\n      s.lookahead = 0\n      s.match_length = s.prev_length = MIN_MATCH$1 - 1\n      s.match_available = 0\n      strm.next_in = next\n      strm.input = input\n      strm.avail_in = avail\n      s.wrap = wrap\n      return Z_OK\n    }\n\n    var deflateInit_1 = deflateInit\n    var deflateInit2_1 = deflateInit2\n    var deflateReset_1 = deflateReset\n    var deflateResetKeep_1 = deflateResetKeep\n    var deflateSetHeader_1 = deflateSetHeader\n    var deflate_2 = deflate\n    var deflateEnd_1 = deflateEnd\n    var deflateSetDictionary_1 = deflateSetDictionary\n    var deflateInfo = 'pako deflate (from Nodeca project)'\n    /* Not implemented\n  module.exports.deflateBound = deflateBound;\n  module.exports.deflateCopy = deflateCopy;\n  module.exports.deflateParams = deflateParams;\n  module.exports.deflatePending = deflatePending;\n  module.exports.deflatePrime = deflatePrime;\n  module.exports.deflateTune = deflateTune;\n  */\n\n    var deflate_1 = {\n      deflateInit: deflateInit_1,\n      deflateInit2: deflateInit2_1,\n      deflateReset: deflateReset_1,\n      deflateResetKeep: deflateResetKeep_1,\n      deflateSetHeader: deflateSetHeader_1,\n      deflate: deflate_2,\n      deflateEnd: deflateEnd_1,\n      deflateSetDictionary: deflateSetDictionary_1,\n      deflateInfo,\n    }\n\n    // Join array of chunks to single array.\n    function flattenChunks(chunks) {\n      // calculate data length\n      var len = 0\n\n      for (var i = 0, l = chunks.length; i < l; i++) {\n        len += chunks[i].length\n      } // join chunks\n\n      var result = new Uint8Array(len)\n\n      for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {\n        var chunk = chunks[_i]\n        result.set(chunk, pos)\n        pos += chunk.length\n      }\n\n      return result\n    }\n\n    // String encode/decode helpers\n    //\n    // - apply(Array) can fail on Android 2.2\n    // - apply(Uint8Array) can fail on iOS 5.1 Safari\n    //\n\n    // Table with utf8 lengths (calculated by first byte of sequence)\n    // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n    // because max possible codepoint is 0x10ffff\n\n    var _utf8len = new Uint8Array(256)\n\n    for (var q = 0; q < 256; q++) {\n      _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1\n    }\n\n    _utf8len[254] = _utf8len[254] = 1 // Invalid sequence start\n    // convert string to array (typed, when possible)\n\n    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n    //\n    // This software is provided 'as-is', without any express or implied\n    // warranty. In no event will the authors be held liable for any damages\n    // arising from the use of this software.\n    //\n    // Permission is granted to anyone to use this software for any purpose,\n    // including commercial applications, and to alter it and redistribute it\n    // freely, subject to the following restrictions:\n    //\n    // 1. The origin of this software must not be misrepresented; you must not\n    //   claim that you wrote the original software. If you use this software\n    //   in a product, an acknowledgment in the product documentation would be\n    //   appreciated but is not required.\n    // 2. Altered source versions must be plainly marked as such, and must not be\n    //   misrepresented as being the original software.\n    // 3. This notice may not be removed or altered from any source distribution.\n\n    function ZStream() {\n      /* next input byte */\n      this.input = null // JS specific, because we have no pointers\n\n      this.next_in = 0\n      /* number of bytes available at input */\n\n      this.avail_in = 0\n      /* total number of input bytes read so far */\n\n      this.total_in = 0\n      /* next output byte should be put there */\n\n      this.output = null // JS specific, because we have no pointers\n\n      this.next_out = 0\n      /* remaining free space at output */\n\n      this.avail_out = 0\n      /* total number of bytes output so far */\n\n      this.total_out = 0\n      /* last error message, NULL if no error */\n\n      this.msg = ''\n      /* Z_NULL */\n      /* not visible by applications */\n\n      this.state = null\n      /* best guess about the data type: binary or text */\n\n      this.data_type = 2\n      /* Z_UNKNOWN */\n      /* adler32 value of the uncompressed data */\n\n      this.adler = 0\n    }\n\n    var zstream = ZStream\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    var toString = Object.prototype.toString\n    /* Public constants ========================================================== */\n\n    /* =========================================================================== */\n\n    var Z_NO_FLUSH$1 = constants.Z_NO_FLUSH\n    var Z_SYNC_FLUSH = constants.Z_SYNC_FLUSH\n    var Z_FULL_FLUSH$1 = constants.Z_FULL_FLUSH\n    var Z_FINISH$1 = constants.Z_FINISH\n    var Z_OK$1 = constants.Z_OK\n    var Z_STREAM_END$1 = constants.Z_STREAM_END\n    var Z_DEFAULT_COMPRESSION$1 = constants.Z_DEFAULT_COMPRESSION\n    var Z_DEFAULT_STRATEGY$1 = constants.Z_DEFAULT_STRATEGY\n    var Z_DEFLATED$1 = constants.Z_DEFLATED\n    /* =========================================================================== */\n\n    /**\n     * class Deflate\n     *\n     * Generic JS-style wrapper for zlib calls. If you don't need\n     * streaming behaviour - use more simple functions: [[deflate]],\n     * [[deflateRaw]] and [[gzip]].\n     * */\n\n    /* internal\n     * Deflate.chunks -> Array\n     *\n     * Chunks of output data, if [[Deflate#onData]] not overridden.\n     * */\n\n    /**\n     * Deflate.result -> Uint8Array\n     *\n     * Compressed result, generated by default [[Deflate#onData]]\n     * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n     * (call [[Deflate#push]] with `Z_FINISH` / `true` param).\n     * */\n\n    /**\n     * Deflate.err -> Number\n     *\n     * Error code after deflate finished. 0 (Z_OK) on success.\n     * You will not need it in real life, because deflate errors\n     * are possible only on wrong options or bad `onData` / `onEnd`\n     * custom handlers.\n     * */\n\n    /**\n     * Deflate.msg -> String\n     *\n     * Error message, if [[Deflate.err]] != 0\n     * */\n\n    /**\n     * new Deflate(options)\n     * - options (Object): zlib deflate options.\n     *\n     * Creates new deflator instance with specified params. Throws exception\n     * on bad params. Supported options:\n     *\n     * - `level`\n     * - `windowBits`\n     * - `memLevel`\n     * - `strategy`\n     * - `dictionary`\n     *\n     * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n     * for more information on these.\n     *\n     * Additional options, for internal needs:\n     *\n     * * `chunkSize` - size of generated data chunks (16K by default)\n     * * `raw` (Boolean) - do raw deflate\n     * * `gzip` (Boolean) - create gzip wrapper\n     * * `header` (Object) - custom header for gzip\n     * ** `text` (Boolean) - true if compressed data believed to be text\n     * ** `time` (Number) - modification time, unix timestamp\n     * ** `os` (Number) - operation system code\n     * ** `extra` (Array) - array of bytes with extra data (max 65536)\n     * ** `name` (String) - file name (binary string)\n     * ** `comment` (String) - comment (binary string)\n     * ** `hcrc` (Boolean) - true if header crc should be added\n     *\n     * ##### Example:\n     *\n     * ```javascript\n     * const pako = require('pako')\n     *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n     *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n     *\n     * const deflate = new pako.Deflate({ level: 3});\n     *\n     * deflate.push(chunk1, false);\n     * deflate.push(chunk2, true);  // true -> last chunk\n     *\n     * if (deflate.err) { throw new Error(deflate.err); }\n     *\n     * console.log(deflate.result);\n     * ```\n     * */\n\n    function Deflate() {\n      this.options = {\n        level: Z_DEFAULT_COMPRESSION$1,\n        method: Z_DEFLATED$1,\n        chunkSize: 16384,\n        windowBits: 15,\n        memLevel: 8,\n        strategy: Z_DEFAULT_STRATEGY$1,\n      }\n      var opt = this.options\n\n      if (opt.raw && opt.windowBits > 0) {\n        opt.windowBits = -opt.windowBits\n      } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {\n        opt.windowBits += 16\n      }\n\n      this.err = 0 // error code, if happens (0 = Z_OK)\n\n      this.msg = '' // error message\n\n      this.ended = false // used to avoid multiple onEnd() calls\n\n      this.chunks = [] // chunks of compressed data\n\n      this.strm = new zstream()\n      this.strm.avail_out = 0\n      var status = deflate_1.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy)\n\n      if (status !== Z_OK$1) {\n        throw new Error(messages[status])\n      }\n\n      if (opt.header) {\n        deflate_1.deflateSetHeader(this.strm, opt.header)\n      }\n\n      if (opt.dictionary) {\n        var dict // Convert data if needed\n\n        if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n          dict = new Uint8Array(opt.dictionary)\n        } else {\n          dict = opt.dictionary\n        }\n\n        status = deflate_1.deflateSetDictionary(this.strm, dict)\n\n        if (status !== Z_OK$1) {\n          throw new Error(messages[status])\n        }\n\n        this._dict_set = true\n      }\n    }\n    /**\n     * Deflate#push(data[, flush_mode]) -> Boolean\n     * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be\n     * converted to utf8 byte sequence.\n     * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n     * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n     *\n     * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n     * new compressed chunks. Returns `true` on success. The last data block must\n     * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending\n     * buffers and call [[Deflate#onEnd]].\n     *\n     * On fail call [[Deflate#onEnd]] with error code and return false.\n     *\n     * ##### Example\n     *\n     * ```javascript\n     * push(chunk, false); // push one of data chunks\n     * ...\n     * push(chunk, true);  // push last chunk\n     * ```\n     * */\n\n    Deflate.prototype.push = function (data, flush_mode) {\n      var strm = this.strm\n      var chunkSize = this.options.chunkSize\n\n      var status\n      var _flush_mode\n\n      if (this.ended) {\n        return false\n      }\n\n      if (flush_mode === ~~flush_mode) {\n        _flush_mode = flush_mode\n      } else {\n        _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1\n      } // Convert data if needed\n\n      if (toString.call(data) === '[object ArrayBuffer]') {\n        strm.input = new Uint8Array(data)\n      } else {\n        strm.input = data\n      }\n\n      strm.next_in = 0\n      strm.avail_in = strm.input.length\n\n      for (;;) {\n        if (strm.avail_out === 0) {\n          strm.output = new Uint8Array(chunkSize)\n          strm.next_out = 0\n          strm.avail_out = chunkSize\n        } // Make sure avail_out > 6 to avoid repeating markers\n\n        if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {\n          this.onData(strm.output.subarray(0, strm.next_out))\n          strm.avail_out = 0\n          continue\n        }\n\n        status = deflate_1.deflate(strm, _flush_mode) // Ended => flush and finish\n\n        if (status === Z_STREAM_END$1) {\n          if (strm.next_out > 0) {\n            this.onData(strm.output.subarray(0, strm.next_out))\n          }\n\n          status = deflate_1.deflateEnd(this.strm)\n          this.onEnd(status)\n          this.ended = true\n          return status === Z_OK$1\n        } // Flush if out buffer full\n\n        if (strm.avail_out === 0) {\n          this.onData(strm.output)\n          continue\n        } // Flush if requested and has data\n\n        if (_flush_mode > 0 && strm.next_out > 0) {\n          this.onData(strm.output.subarray(0, strm.next_out))\n          strm.avail_out = 0\n          continue\n        }\n\n        if (strm.avail_in === 0) {\n          break\n        }\n      }\n\n      return true\n    }\n    /**\n     * Deflate#onData(chunk) -> Void\n     * - chunk (Uint8Array): output data.\n     *\n     * By default, stores data blocks in `chunks[]` property and glue\n     * those in `onEnd`. Override this handler, if you need another behaviour.\n     * */\n\n    Deflate.prototype.onData = function (chunk) {\n      this.chunks.push(chunk)\n    }\n    /**\n     * Deflate#onEnd(status) -> Void\n     * - status (Number): deflate status. 0 (Z_OK) on success,\n     * other if not.\n     *\n     * Called once after you tell deflate that the input stream is\n     * complete (Z_FINISH). By default - join collected chunks,\n     * free memory and fill `results` / `err` properties.\n     * */\n\n    Deflate.prototype.onEnd = function (status) {\n      // On success - join\n      if (status === Z_OK$1) {\n        this.result = flattenChunks(this.chunks)\n      }\n\n      this.chunks = []\n      this.err = status\n      this.msg = this.strm.msg\n    }\n\n    // https://github.com/nodeca/pako/blob/26dff4fb3472c5532b3bd8856421146d35ab7592/lib/utils/strings.js#L26\n    function string2buf(str) {\n      if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n        return new TextEncoder().encode(str)\n      }\n\n      let buf\n      let c\n      let c2\n      let m_pos\n      let i\n      let str_len = str.length\n      let buf_len = 0\n\n      // count binary size\n      for (m_pos = 0; m_pos < str_len; m_pos++) {\n        c = str.charCodeAt(m_pos)\n        if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n          c2 = str.charCodeAt(m_pos + 1)\n          if ((c2 & 0xfc00) === 0xdc00) {\n            c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00)\n            m_pos++\n          }\n        }\n        buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4\n      }\n\n      // allocate buffer\n      buf = new Uint8Array(buf_len)\n\n      // convert\n      for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n        c = str.charCodeAt(m_pos)\n        if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n          c2 = str.charCodeAt(m_pos + 1)\n          if ((c2 & 0xfc00) === 0xdc00) {\n            c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00)\n            m_pos++\n          }\n        }\n        if (c < 0x80) {\n          /* one byte */\n          buf[i++] = c\n        } else if (c < 0x800) {\n          /* two bytes */\n          buf[i++] = 0xc0 | (c >>> 6)\n          buf[i++] = 0x80 | (c & 0x3f)\n        } else if (c < 0x10000) {\n          /* three bytes */\n          buf[i++] = 0xe0 | (c >>> 12)\n          buf[i++] = 0x80 | ((c >>> 6) & 0x3f)\n          buf[i++] = 0x80 | (c & 0x3f)\n        } else {\n          /* four bytes */\n          buf[i++] = 0xf0 | (c >>> 18)\n          buf[i++] = 0x80 | ((c >>> 12) & 0x3f)\n          buf[i++] = 0x80 | ((c >>> 6) & 0x3f)\n          buf[i++] = 0x80 | (c & 0x3f)\n        }\n      }\n\n      return buf\n    }\n\n    return { Deflate, constants, string2buf }\n  }\n}\n","import type { EventEmitter, TimeoutId } from '@datadog/browser-core'\nimport { ONE_SECOND, addEventListener, DOM_EVENT, monitor } from '@datadog/browser-core'\nimport type { LifeCycle, ViewContexts, RumSessionManager } from '@datadog/browser-rum-core'\nimport { LifeCycleEventType } from '@datadog/browser-rum-core'\nimport type { BrowserRecord, BrowserSegmentMetadata, CreationReason, SegmentContext } from '../../types'\nimport type { DeflateWorker } from './deflateWorker'\nimport { Segment } from './segment'\n\nexport const SEGMENT_DURATION_LIMIT = 30 * ONE_SECOND\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport let SEGMENT_BYTES_LIMIT = 60_000\n\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as many records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment bytes count reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\n\nexport function startSegmentCollection(\n  lifeCycle: LifeCycle,\n  applicationId: string,\n  sessionManager: RumSessionManager,\n  viewContexts: ViewContexts,\n  send: (data: Uint8Array, metadata: BrowserSegmentMetadata, rawSegmentBytesCount: number) => void,\n  worker: DeflateWorker\n) {\n  return doStartSegmentCollection(\n    lifeCycle,\n    () => computeSegmentContext(applicationId, sessionManager, viewContexts),\n    send,\n    worker\n  )\n}\n\nconst enum SegmentCollectionStatus {\n  WaitingForInitialRecord,\n  SegmentPending,\n  Stopped,\n}\ntype SegmentCollectionState =\n  | {\n      status: SegmentCollectionStatus.WaitingForInitialRecord\n      nextSegmentCreationReason: CreationReason\n    }\n  | {\n      status: SegmentCollectionStatus.SegmentPending\n      segment: Segment\n      expirationTimeoutId: TimeoutId\n    }\n  | {\n      status: SegmentCollectionStatus.Stopped\n    }\n\nexport function doStartSegmentCollection(\n  lifeCycle: LifeCycle,\n  getSegmentContext: () => SegmentContext | undefined,\n  send: (data: Uint8Array, metadata: BrowserSegmentMetadata, rawSegmentBytesCount: number) => void,\n  worker: DeflateWorker,\n  emitter: EventEmitter = window\n) {\n  let state: SegmentCollectionState = {\n    status: SegmentCollectionStatus.WaitingForInitialRecord,\n    nextSegmentCreationReason: 'init',\n  }\n\n  const { unsubscribe: unsubscribeViewCreated } = lifeCycle.subscribe(LifeCycleEventType.VIEW_CREATED, () => {\n    flushSegment('view_change')\n  })\n\n  const { unsubscribe: unsubscribeBeforeUnload } = lifeCycle.subscribe(LifeCycleEventType.BEFORE_UNLOAD, () => {\n    flushSegment('before_unload')\n  })\n\n  const { stop: unsubscribeVisibilityChange } = addEventListener(\n    emitter,\n    DOM_EVENT.VISIBILITY_CHANGE,\n    () => {\n      if (document.visibilityState === 'hidden') {\n        flushSegment('visibility_hidden')\n      }\n    },\n    { capture: true }\n  )\n\n  function flushSegment(nextSegmentCreationReason?: CreationReason) {\n    if (state.status === SegmentCollectionStatus.SegmentPending) {\n      state.segment.flush()\n      clearTimeout(state.expirationTimeoutId)\n    }\n\n    if (nextSegmentCreationReason) {\n      state = {\n        status: SegmentCollectionStatus.WaitingForInitialRecord,\n        nextSegmentCreationReason,\n      }\n    } else {\n      state = {\n        status: SegmentCollectionStatus.Stopped,\n      }\n    }\n  }\n\n  function createNewSegment(creationReason: CreationReason, initialRecord: BrowserRecord) {\n    const context = getSegmentContext()\n    if (!context) {\n      return\n    }\n\n    const segment = new Segment(\n      worker,\n      context,\n      creationReason,\n      initialRecord,\n      (compressedSegmentBytesCount) => {\n        if (!segment.isFlushed && compressedSegmentBytesCount > SEGMENT_BYTES_LIMIT) {\n          flushSegment('segment_bytes_limit')\n        }\n      },\n      (data, rawSegmentBytesCount) => {\n        send(data, segment.metadata, rawSegmentBytesCount)\n      }\n    )\n\n    state = {\n      status: SegmentCollectionStatus.SegmentPending,\n      segment,\n      expirationTimeoutId: setTimeout(\n        monitor(() => {\n          flushSegment('segment_duration_limit')\n        }),\n        SEGMENT_DURATION_LIMIT\n      ),\n    }\n  }\n\n  return {\n    addRecord: (record: BrowserRecord) => {\n      switch (state.status) {\n        case SegmentCollectionStatus.WaitingForInitialRecord:\n          createNewSegment(state.nextSegmentCreationReason, record)\n          break\n\n        case SegmentCollectionStatus.SegmentPending:\n          state.segment.addRecord(record)\n          break\n      }\n    },\n\n    stop: () => {\n      flushSegment()\n      unsubscribeViewCreated()\n      unsubscribeBeforeUnload()\n      unsubscribeVisibilityChange()\n    },\n  }\n}\n\nexport function computeSegmentContext(\n  applicationId: string,\n  sessionManager: RumSessionManager,\n  viewContexts: ViewContexts\n) {\n  const session = sessionManager.findTrackedSession()\n  const viewContext = viewContexts.findView()\n  if (!session || !viewContext) {\n    return undefined\n  }\n  return {\n    application: {\n      id: applicationId,\n    },\n    session: {\n      id: session.id,\n    },\n    view: {\n      id: viewContext.id,\n    },\n  }\n}\n\nexport function setSegmentBytesLimit(newSegmentBytesLimit = 60_000) {\n  SEGMENT_BYTES_LIMIT = newSegmentBytesLimit\n}\n","import { addTelemetryError, display, includes, monitor } from '@datadog/browser-core'\nimport type { DeflateWorker } from './deflateWorker'\nimport { createDeflateWorker } from './deflateWorker'\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 */\nconst 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      callbacks: Array<(worker?: DeflateWorker) => void>\n    }\n  | {\n      status: DeflateWorkerStatus.Error\n    }\n  | {\n      status: DeflateWorkerStatus.Initialized\n      worker: DeflateWorker\n    }\n\nlet state: DeflateWorkerState = { status: DeflateWorkerStatus.Nil }\n\nexport function startDeflateWorker(\n  callback: (worker?: DeflateWorker) => void,\n  createDeflateWorkerImpl = createDeflateWorker\n) {\n  switch (state.status) {\n    case DeflateWorkerStatus.Nil:\n      state = { status: DeflateWorkerStatus.Loading, callbacks: [callback] }\n      doStartDeflateWorker(createDeflateWorkerImpl)\n      break\n    case DeflateWorkerStatus.Loading:\n      state.callbacks.push(callback)\n      break\n    case DeflateWorkerStatus.Error:\n      callback()\n      break\n    case DeflateWorkerStatus.Initialized:\n      callback(state.worker)\n      break\n  }\n}\n\nexport function resetDeflateWorkerState() {\n  state = { status: DeflateWorkerStatus.Nil }\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(createDeflateWorkerImpl = createDeflateWorker) {\n  try {\n    const worker = createDeflateWorkerImpl()\n    worker.addEventListener('error', monitor(onError))\n    worker.addEventListener(\n      'message',\n      monitor(({ data }) => {\n        if (data.type === 'errored') {\n          onError(data.error)\n        } else if (data.type === 'initialized') {\n          onInitialized(worker)\n        }\n      })\n    )\n    worker.postMessage({ action: 'init' })\n    return worker\n  } catch (error) {\n    onError(error)\n  }\n}\n\nfunction onInitialized(worker: DeflateWorker) {\n  if (state.status === DeflateWorkerStatus.Loading) {\n    state.callbacks.forEach((callback) => callback(worker))\n    state = { status: DeflateWorkerStatus.Initialized, worker }\n  }\n}\n\nfunction onError(error: unknown) {\n  if (state.status === DeflateWorkerStatus.Loading) {\n    display.error('Session Replay recording failed to start: an error occurred while creating the Worker:', error)\n    if (error instanceof Event || (error instanceof Error && includes(error.message, 'Content Security Policy'))) {\n      display.error(\n        'Please make sure CSP is correctly configured ' +\n          'https://docs.datadoghq.com/real_user_monitoring/faq/content_security_policy'\n      )\n    } else {\n      addTelemetryError(error)\n    }\n    state.callbacks.forEach((callback) => callback())\n    state = { status: DeflateWorkerStatus.Error }\n  } else {\n    addTelemetryError(error)\n  }\n}\n","import type { EndpointBuilder } from '@datadog/browser-core'\nimport { HttpRequest, objectEntries } from '@datadog/browser-core'\nimport { SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection'\nimport type { BrowserSegmentMetadata } from '../types'\n\nexport function send(\n  endpointBuilder: EndpointBuilder,\n  data: Uint8Array,\n  metadata: BrowserSegmentMetadata,\n  rawSegmentBytesCount: number\n): void {\n  const formData = new FormData()\n\n  formData.append(\n    'segment',\n    new Blob([data], {\n      type: 'application/octet-stream',\n    }),\n    `${metadata.session.id}-${metadata.start}`\n  )\n\n  toFormEntries(metadata, (key, value) => formData.append(key, value))\n  formData.append('raw_segment_size', rawSegmentBytesCount.toString())\n\n  const request = new HttpRequest(endpointBuilder, SEGMENT_BYTES_LIMIT)\n  request.send(formData, data.byteLength)\n}\n\nexport function toFormEntries(input: object, onEntry: (key: string, value: string) => void, prefix = '') {\n  objectEntries(input as { [key: string]: unknown }).forEach(([key, value]) => {\n    if (typeof value === 'object' && value !== null) {\n      toFormEntries(value, onEntry, `${prefix}${key}.`)\n    } else {\n      onEntry(`${prefix}${key}`, String(value))\n    }\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'\n\nimport { startRecording } from '../boot/startRecording'\nimport { makeRecorderApi } from '../boot/recorderApi'\n\nexport {\n  CommonProperties,\n  RumPublicApi as RumGlobal,\n  RumInitConfiguration,\n  // Events\n  RumEvent,\n  RumActionEvent,\n  RumErrorEvent,\n  RumLongTaskEvent,\n  RumResourceEvent,\n  RumViewEvent,\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(startRecording)\nexport const datadogRum = makeRumPublicApi(startRum, recorderApi)\n\ninterface BrowserWindow extends Window {\n  DD_RUM?: RumPublicApi\n}\ndefineGlobal(getGlobalObject<BrowserWindow>(), 'DD_RUM', datadogRum)\n","import { catchUserErrors } from '../tools/catchUserErrors'\nimport { setDebugMode } from '../tools/monitor'\nimport { assign } from '../tools/utils'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\n\nexport function makePublicApi<T>(stub: T): T & { onReady(callback: () => void): void; version: string } {\n  const publicApi = assign(\n    {\n      version: __BUILD_ENV__SDK_VERSION__,\n\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    },\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\n}\n\nexport function defineGlobal<Global, Name extends keyof Global>(global: Global, name: Name, api: Global[Name]) {\n  const existingGlobalVariable: { q?: Array<() => void> } | undefined = global[name]\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 { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core'\nimport type {\n  LifeCycle,\n  ViewContexts,\n  RumSessionManager,\n  RecorderApi,\n  RumConfiguration,\n} from '@datadog/browser-rum-core'\nimport { LifeCycleEventType } from '@datadog/browser-rum-core'\nimport { getReplayStats } from '../domain/replayStats'\nimport { startDeflateWorker } from '../domain/segmentCollection'\n\nimport type { startRecording } from './startRecording'\n\nexport type StartRecording = typeof startRecording\n\nconst 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}\ntype RecorderState =\n  | {\n      status: RecorderStatus.Stopped\n    }\n  | {\n      status: RecorderStatus.IntentToStart\n    }\n  | {\n      status: RecorderStatus.Starting\n    }\n  | {\n      status: RecorderStatus.Started\n      stopRecording: () => void\n    }\n\nexport function makeRecorderApi(\n  startRecordingImpl: StartRecording,\n  startDeflateWorkerImpl = startDeflateWorker\n): RecorderApi {\n  if (canUseEventBridge()) {\n    return {\n      start: noop,\n      stop: noop,\n      getReplayStats: () => undefined,\n      onRumStart: noop,\n      isRecording: () => false,\n    }\n  }\n\n  let state: RecorderState = {\n    status: RecorderStatus.Stopped,\n  }\n\n  let startStrategy = () => {\n    state = { status: RecorderStatus.IntentToStart }\n  }\n  let stopStrategy = () => {\n    state = { status: RecorderStatus.Stopped }\n  }\n  return {\n    start: () => startStrategy(),\n    stop: () => stopStrategy(),\n    getReplayStats,\n\n    onRumStart: (\n      lifeCycle: LifeCycle,\n      configuration: RumConfiguration,\n      sessionManager: RumSessionManager,\n      viewContexts: ViewContexts\n    ) => {\n      lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {\n        if (state.status === RecorderStatus.Starting || state.status === RecorderStatus.Started) {\n          stopStrategy()\n          state = { status: RecorderStatus.IntentToStart }\n        }\n      })\n\n      lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {\n        if (state.status === RecorderStatus.IntentToStart) {\n          startStrategy()\n        }\n      })\n\n      startStrategy = () => {\n        const session = sessionManager.findTrackedSession()\n        if (!session || !session.hasPremiumPlan) {\n          state = { status: RecorderStatus.IntentToStart }\n          return\n        }\n\n        if (state.status === RecorderStatus.Starting || state.status === RecorderStatus.Started) {\n          return\n        }\n\n        state = { status: RecorderStatus.Starting }\n\n        runOnReadyState('interactive', () => {\n          if (state.status !== RecorderStatus.Starting) {\n            return\n          }\n\n          startDeflateWorkerImpl((worker) => {\n            if (state.status !== RecorderStatus.Starting) {\n              return\n            }\n\n            if (!worker) {\n              state = {\n                status: RecorderStatus.Stopped,\n              }\n              return\n            }\n\n            const { stop: stopRecording } = startRecordingImpl(\n              lifeCycle,\n              configuration,\n              sessionManager,\n              viewContexts,\n              worker\n            )\n            state = {\n              status: RecorderStatus.Started,\n              stopRecording,\n            }\n          })\n        })\n      }\n\n      stopStrategy = () => {\n        if (state.status === RecorderStatus.Stopped) {\n          return\n        }\n\n        if (state.status === RecorderStatus.Started) {\n          state.stopRecording()\n        }\n\n        state = {\n          status: RecorderStatus.Stopped,\n        }\n      }\n\n      if (state.status === RecorderStatus.IntentToStart) {\n        startStrategy()\n      }\n    },\n\n    isRecording: () => state.status === RecorderStatus.Started,\n  }\n}\n","import { timeStampNow } from '@datadog/browser-core'\nimport type {\n  LifeCycle,\n  ViewContexts,\n  RumConfiguration,\n  RumSessionManager,\n  ViewCreatedEvent,\n} from '@datadog/browser-rum-core'\nimport { LifeCycleEventType } from '@datadog/browser-rum-core'\n\nimport { record } from '../domain/record'\nimport type { DeflateWorker } from '../domain/segmentCollection'\nimport { startSegmentCollection } from '../domain/segmentCollection'\nimport { send } from '../transport/send'\nimport { RecordType } from '../types'\n\nexport function startRecording(\n  lifeCycle: LifeCycle,\n  configuration: RumConfiguration,\n  sessionManager: RumSessionManager,\n  viewContexts: ViewContexts,\n  worker: DeflateWorker\n) {\n  const { addRecord, stop: stopSegmentCollection } = startSegmentCollection(\n    lifeCycle,\n    configuration.applicationId,\n    sessionManager,\n    viewContexts,\n    (data, metadata, rawSegmentBytesCount) =>\n      send(configuration.sessionReplayEndpointBuilder, data, metadata, rawSegmentBytesCount),\n    worker\n  )\n\n  const {\n    stop: stopRecording,\n    takeFullSnapshot,\n    flushMutations,\n  } = record({\n    emit: addRecord,\n    defaultPrivacyLevel: configuration.defaultPrivacyLevel,\n    lifeCycle,\n  })\n\n  const { unsubscribe: unsubscribeViewEnded } = lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, () => {\n    flushMutations()\n    addRecord({\n      timestamp: timeStampNow(),\n      type: RecordType.ViewEnd,\n    })\n  })\n  const { unsubscribe: unsubscribeViewCreated } = lifeCycle.subscribe(\n    LifeCycleEventType.VIEW_CREATED,\n    (view: ViewCreatedEvent) => {\n      takeFullSnapshot(view.startClocks.timeStamp)\n    }\n  )\n\n  return {\n    stop: () => {\n      unsubscribeViewEnded()\n      unsubscribeViewCreated()\n      stopRecording()\n      stopSegmentCollection()\n    },\n  }\n}\n","import { timeStampNow } from '@datadog/browser-core'\nimport type { DefaultPrivacyLevel, TimeStamp } from '@datadog/browser-core'\nimport type { LifeCycle } from '@datadog/browser-rum-core'\nimport { getViewportDimension } from '@datadog/browser-rum-core'\nimport type {\n  BrowserMutationData,\n  BrowserRecord,\n  InputData,\n  MediaInteractionData,\n  MousemoveData,\n  ScrollData,\n  StyleSheetRuleData,\n  ViewportResizeData,\n} from '../../types'\nimport { RecordType, IncrementalSource } from '../../types'\nimport { serializeDocument } from './serialize'\nimport { initObservers } from './observer'\n\nimport { MutationController } from './mutationObserver'\nimport { getVisualViewport, getScrollX, getScrollY } from './viewports'\nimport { assembleIncrementalSnapshot } from './utils'\n\nexport interface RecordOptions {\n  emit?: (record: BrowserRecord) => void\n  defaultPrivacyLevel: DefaultPrivacyLevel\n  lifeCycle: LifeCycle\n}\n\nexport interface RecordAPI {\n  stop: () => void\n  takeFullSnapshot: (timestamp?: TimeStamp) => void\n  flushMutations: () => void\n}\n\nexport function record(options: RecordOptions): RecordAPI {\n  const { emit } = options\n  // runtime checks for user options\n  if (!emit) {\n    throw new Error('emit function is required')\n  }\n\n  const mutationController = new MutationController()\n\n  const takeFullSnapshot = (timestamp = timeStampNow()) => {\n    mutationController.flush() // process any pending mutation before taking a full snapshot\n    const { width, height } = getViewportDimension()\n    emit({\n      data: {\n        height,\n        href: window.location.href,\n        width,\n      },\n      type: RecordType.Meta,\n      timestamp,\n    })\n\n    emit({\n      data: {\n        has_focus: document.hasFocus(),\n      },\n      type: RecordType.Focus,\n      timestamp,\n    })\n\n    emit({\n      data: {\n        node: serializeDocument(document, options.defaultPrivacyLevel),\n        initialOffset: {\n          left: getScrollX(),\n          top: getScrollY(),\n        },\n      },\n      type: RecordType.FullSnapshot,\n      timestamp,\n    })\n\n    if (window.visualViewport) {\n      emit({\n        data: getVisualViewport(),\n        type: RecordType.VisualViewport,\n        timestamp,\n      })\n    }\n  }\n\n  takeFullSnapshot()\n\n  const stopObservers = initObservers({\n    lifeCycle: options.lifeCycle,\n    mutationController,\n    defaultPrivacyLevel: options.defaultPrivacyLevel,\n    inputCb: (v) => emit(assembleIncrementalSnapshot<InputData>(IncrementalSource.Input, v)),\n    mediaInteractionCb: (p) =>\n      emit(assembleIncrementalSnapshot<MediaInteractionData>(IncrementalSource.MediaInteraction, p)),\n    mouseInteractionCb: (mouseInteractionRecord) => emit(mouseInteractionRecord),\n    mousemoveCb: (positions, source) => emit(assembleIncrementalSnapshot<MousemoveData>(source, { positions })),\n    mutationCb: (m) => emit(assembleIncrementalSnapshot<BrowserMutationData>(IncrementalSource.Mutation, m)),\n    scrollCb: (p) => emit(assembleIncrementalSnapshot<ScrollData>(IncrementalSource.Scroll, p)),\n    styleSheetRuleCb: (r) => emit(assembleIncrementalSnapshot<StyleSheetRuleData>(IncrementalSource.StyleSheetRule, r)),\n    viewportResizeCb: (d) => emit(assembleIncrementalSnapshot<ViewportResizeData>(IncrementalSource.ViewportResize, d)),\n\n    frustrationCb: (frustrationRecord) => emit(frustrationRecord),\n    focusCb: (data) =>\n      emit({\n        data,\n        type: RecordType.Focus,\n        timestamp: timeStampNow(),\n      }),\n    visualViewportResizeCb: (data) => {\n      emit({\n        data,\n        type: RecordType.VisualViewport,\n        timestamp: timeStampNow(),\n      })\n    },\n  })\n\n  return {\n    stop: stopObservers,\n    takeFullSnapshot,\n    flushMutations: () => mutationController.flush(),\n  }\n}\n","import type { Context, InitConfiguration, TimeStamp, RelativeTime } from '@datadog/browser-core'\nimport {\n  willSyntheticsInjectRum,\n  assign,\n  BoundedBuffer,\n  buildCookieOptions,\n  createContextManager,\n  deepClone,\n  makePublicApi,\n  monitor,\n  clocksNow,\n  timeStampNow,\n  display,\n  callMonitored,\n  createHandlingStack,\n  canUseEventBridge,\n  areCookiesAuthorized,\n} from '@datadog/browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport type { ViewContexts } from '../domain/contexts/viewContexts'\nimport type { RumSessionManager } from '../domain/rumSessionManager'\nimport type { CommonContext, User, ReplayStats } from '../rawRumEvent.types'\nimport { ActionType } from '../rawRumEvent.types'\nimport type { RumConfiguration, RumInitConfiguration } from '../domain/configuration'\nimport { validateAndBuildRumConfiguration } from '../domain/configuration'\nimport type { ViewOptions } from '../domain/rumEventsCollection/view/trackViews'\nimport type { startRum } from './startRum'\n\nexport type RumPublicApi = ReturnType<typeof makeRumPublicApi>\n\nexport type StartRum = typeof startRum\n\ntype StartRumResult = ReturnType<typeof startRum>\n\nexport interface RecorderApi {\n  start: () => void\n  stop: () => void\n  onRumStart: (\n    lifeCycle: LifeCycle,\n    configuration: RumConfiguration,\n    sessionManager: RumSessionManager,\n    viewContexts: ViewContexts\n  ) => void\n  isRecording: () => boolean\n  getReplayStats: (viewId: string) => ReplayStats | undefined\n}\ninterface RumPublicApiOptions {\n  ignoreInitIfSyntheticsWillInjectRum?: boolean\n}\n\nexport function makeRumPublicApi(\n  startRumImpl: StartRum,\n  recorderApi: RecorderApi,\n  { ignoreInitIfSyntheticsWillInjectRum = true }: RumPublicApiOptions = {}\n) {\n  let isAlreadyInitialized = false\n\n  const globalContextManager = createContextManager()\n  let user: User = {}\n\n  let getInternalContextStrategy: StartRumResult['getInternalContext'] = () => undefined\n  let getInitConfigurationStrategy = (): InitConfiguration | undefined => undefined\n\n  let bufferApiCalls = new BoundedBuffer()\n  let addTimingStrategy: StartRumResult['addTiming'] = (name, time = timeStampNow()) => {\n    bufferApiCalls.add(() => addTimingStrategy(name, time))\n  }\n  let startViewStrategy: StartRumResult['startView'] = (options, startClocks = clocksNow()) => {\n    bufferApiCalls.add(() => startViewStrategy(options, startClocks))\n  }\n  let addActionStrategy: StartRumResult['addAction'] = (action, commonContext = clonedCommonContext()) => {\n    bufferApiCalls.add(() => addActionStrategy(action, commonContext))\n  }\n  let addErrorStrategy: StartRumResult['addError'] = (providedError, commonContext = clonedCommonContext()) => {\n    bufferApiCalls.add(() => addErrorStrategy(providedError, commonContext))\n  }\n\n  function clonedCommonContext(): CommonContext {\n    return deepClone({\n      context: globalContextManager.get(),\n      user: user as Context,\n    })\n  }\n\n  function initRum(initConfiguration: RumInitConfiguration) {\n    // If we are in a Synthetics test configured to automatically inject a RUM instance, we want to\n    // completely discard the customer application RUM instance by ignoring their init() call.  But,\n    // we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n    // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n    if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n      return\n    }\n\n    if (canUseEventBridge()) {\n      initConfiguration = overrideInitConfigurationForBridge(initConfiguration)\n    } else if (!canHandleSession(initConfiguration)) {\n      return\n    }\n\n    if (!canInitRum(initConfiguration)) {\n      return\n    }\n\n    const configuration = validateAndBuildRumConfiguration(initConfiguration)\n    if (!configuration) {\n      return\n    }\n\n    if (!configuration.trackViewsManually) {\n      doStartRum(configuration)\n    } else {\n      // drain beforeInitCalls by buffering them until we start RUM\n      // if we get a startView, drain re-buffered calls before continuing to drain beforeInitCalls\n      // in order to ensure that calls are processed in order\n      const beforeInitCalls = bufferApiCalls\n      bufferApiCalls = new BoundedBuffer()\n\n      startViewStrategy = (options) => {\n        doStartRum(configuration, options)\n      }\n      beforeInitCalls.drain()\n    }\n    getInitConfigurationStrategy = () => deepClone<InitConfiguration>(initConfiguration)\n\n    isAlreadyInitialized = true\n  }\n\n  function doStartRum(configuration: RumConfiguration, initialViewOptions?: ViewOptions) {\n    const startRumResults = startRumImpl(\n      configuration,\n      () => ({\n        user,\n        context: globalContextManager.get(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n      }),\n      recorderApi,\n      initialViewOptions\n    )\n\n    ;({\n      startView: startViewStrategy,\n      addAction: addActionStrategy,\n      addError: addErrorStrategy,\n      addTiming: addTimingStrategy,\n      getInternalContext: getInternalContextStrategy,\n    } = startRumResults)\n    bufferApiCalls.drain()\n\n    recorderApi.onRumStart(\n      startRumResults.lifeCycle,\n      configuration,\n      startRumResults.session,\n      startRumResults.viewContexts\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    startViewStrategy(sanitizedOptions)\n  })\n\n  const rumPublicApi = makePublicApi({\n    init: monitor(initRum),\n\n    addRumGlobalContext: monitor(globalContextManager.add),\n\n    removeRumGlobalContext: monitor(globalContextManager.remove),\n\n    getRumGlobalContext: monitor(globalContextManager.get),\n    setRumGlobalContext: monitor(globalContextManager.set),\n\n    getInternalContext: monitor((startTime?: number) => getInternalContextStrategy(startTime)),\n    getInitConfiguration: monitor(() => getInitConfigurationStrategy()),\n\n    addAction: monitor((name: string, context?: object) => {\n      addActionStrategy({\n        name,\n        context: deepClone(context as Context),\n        startClocks: clocksNow(),\n        type: ActionType.CUSTOM,\n      })\n    }),\n\n    addError: (error: unknown, context?: object) => {\n      const handlingStack = createHandlingStack()\n      callMonitored(() => {\n        addErrorStrategy({\n          error,\n          handlingStack,\n          context: deepClone(context as Context),\n          startClocks: clocksNow(),\n        })\n      })\n    },\n\n    addTiming: monitor((name: string, time?: number) => {\n      addTimingStrategy(name, time as RelativeTime | TimeStamp | undefined)\n    }),\n\n    setUser: monitor((newUser: User) => {\n      const sanitizedUser = sanitizeUser(newUser)\n      if (sanitizedUser) {\n        user = sanitizedUser\n      } else {\n        display.error('Unsupported user:', newUser)\n      }\n    }),\n\n    removeUser: monitor(() => {\n      user = {}\n    }),\n\n    startView,\n\n    startSessionReplayRecording: monitor(recorderApi.start),\n    stopSessionReplayRecording: monitor(recorderApi.stop),\n  })\n  return rumPublicApi\n\n  function sanitizeUser(newUser: unknown) {\n    if (typeof newUser !== 'object' || !newUser) {\n      return\n    }\n    const result = deepClone(newUser as Context)\n    if ('id' in result) {\n      result.id = String(result.id)\n    }\n    if ('name' in result) {\n      result.name = String(result.name)\n    }\n    if ('email' in result) {\n      result.email = String(result.email)\n    }\n    return result\n  }\n\n  function canHandleSession(initConfiguration: RumInitConfiguration): boolean {\n    if (!areCookiesAuthorized(buildCookieOptions(initConfiguration))) {\n      display.warn('Cookies are not authorized, we will not send any data.')\n      return false\n    }\n\n    if (isLocalFile()) {\n      display.error('Execution is not allowed in the current context.')\n      return false\n    }\n    return true\n  }\n\n  function canInitRum(initConfiguration: RumInitConfiguration) {\n    if (isAlreadyInitialized) {\n      if (!initConfiguration.silentMultipleInit) {\n        display.error('DD_RUM is already initialized.')\n      }\n      return false\n    }\n    return true\n  }\n\n  function overrideInitConfigurationForBridge<C extends InitConfiguration>(initConfiguration: C): C {\n    return assign({}, initConfiguration, {\n      applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n      clientToken: 'empty',\n      sampleRate: 100,\n    })\n  }\n\n  function isLocalFile() {\n    return window.location.protocol === 'file:'\n  }\n}\n","import type { Context, ContextValue } from './context'\n\nexport function createContextManager() {\n  let context: Context = {}\n\n  return {\n    get: () => context,\n\n    add: (key: string, value: any) => {\n      context[key] = value as ContextValue\n    },\n\n    remove: (key: string) => {\n      delete context[key]\n    },\n\n    set: (newContext: object) => {\n      context = newContext as Context\n    },\n  }\n}\n","import type { Observable, TelemetryEvent } from '@datadog/browser-core'\nimport { startTelemetry, canUseEventBridge, getEventBridge } from '@datadog/browser-core'\nimport { createDOMMutationObservable } from '../browser/domMutationObservable'\nimport { startPerformanceCollection } from '../browser/performanceCollection'\nimport { startRumAssembly } from '../domain/assembly'\nimport { startForegroundContexts } from '../domain/contexts/foregroundContexts'\nimport { startInternalContext } from '../domain/contexts/internalContext'\nimport { LifeCycle } from '../domain/lifeCycle'\nimport { startViewContexts } from '../domain/contexts/viewContexts'\nimport { startRequestCollection } from '../domain/requestCollection'\nimport { startActionCollection } from '../domain/rumEventsCollection/action/actionCollection'\nimport { startErrorCollection } from '../domain/rumEventsCollection/error/errorCollection'\nimport { startLongTaskCollection } from '../domain/rumEventsCollection/longTask/longTaskCollection'\nimport { startResourceCollection } from '../domain/rumEventsCollection/resource/resourceCollection'\nimport { startViewCollection } from '../domain/rumEventsCollection/view/viewCollection'\nimport type { RumSessionManager } from '../domain/rumSessionManager'\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager'\nimport type { CommonContext } from '../rawRumEvent.types'\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/rumEventsCollection/view/trackViews'\nimport type { RecorderApi } from './rumPublicApi'\n\nexport function startRum(\n  configuration: RumConfiguration,\n  getCommonContext: () => CommonContext,\n  recorderApi: RecorderApi,\n  initialViewOptions?: ViewOptions\n) {\n  const lifeCycle = new LifeCycle()\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: viewContexts.findView()?.id,\n    },\n    action: {\n      id: actionContexts.findActionId(),\n    },\n  }))\n\n  if (!canUseEventBridge()) {\n    startRumBatch(configuration, lifeCycle, telemetry.observable)\n  } else {\n    startRumEventBridge(lifeCycle)\n  }\n\n  const session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub()\n  const domMutationObservable = createDOMMutationObservable()\n  const locationChangeObservable = createLocationChangeObservable(location)\n\n  const { viewContexts, foregroundContexts, urlContexts, actionContexts, addAction } = startRumEventCollection(\n    lifeCycle,\n    configuration,\n    location,\n    session,\n    locationChangeObservable,\n    domMutationObservable,\n    getCommonContext\n  )\n\n  startLongTaskCollection(lifeCycle, session)\n  startResourceCollection(lifeCycle)\n  const { addTiming, startView } = startViewCollection(\n    lifeCycle,\n    configuration,\n    location,\n    domMutationObservable,\n    locationChangeObservable,\n    foregroundContexts,\n    recorderApi,\n    initialViewOptions\n  )\n  const { addError } = startErrorCollection(lifeCycle, foregroundContexts)\n\n  startRequestCollection(lifeCycle, configuration, session)\n  startPerformanceCollection(lifeCycle, configuration)\n\n  const internalContext = startInternalContext(\n    configuration.applicationId,\n    session,\n    viewContexts,\n    actionContexts,\n    urlContexts\n  )\n\n  return {\n    addAction,\n    addError,\n    addTiming,\n    startView,\n    lifeCycle,\n    viewContexts,\n    session,\n    getInternalContext: internalContext.get,\n  }\n}\n\nfunction startRumTelemetry(configuration: RumConfiguration) {\n  const telemetry = startTelemetry(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  locationChangeObservable: Observable<LocationChange>,\n  domMutationObservable: Observable<void>,\n  getCommonContext: () => CommonContext\n) {\n  const viewContexts = startViewContexts(lifeCycle)\n  const urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location)\n  const foregroundContexts = startForegroundContexts()\n  const { addAction, actionContexts } = startActionCollection(\n    lifeCycle,\n    domMutationObservable,\n    configuration,\n    foregroundContexts\n  )\n\n  startRumAssembly(\n    configuration,\n    lifeCycle,\n    sessionManager,\n    viewContexts,\n    urlContexts,\n    actionContexts,\n    getCommonContext\n  )\n\n  return {\n    viewContexts,\n    foregroundContexts,\n    urlContexts,\n    addAction,\n    actionContexts,\n    stop: () => {\n      viewContexts.stop()\n      foregroundContexts.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 type { Context, EndpointBuilder, TelemetryEvent, Observable } from '@datadog/browser-core'\nimport { Batch, combine, HttpRequest, isTelemetryReplicationAllowed } 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) {\n  const batch = makeRumBatch(configuration, lifeCycle)\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\ninterface RumBatch {\n  add: (message: Context, replicated?: boolean) => void\n  upsert: (message: Context, key: string) => void\n}\n\nfunction makeRumBatch(configuration: RumConfiguration, lifeCycle: LifeCycle): RumBatch {\n  const primaryBatch = createRumBatch(configuration.rumEndpointBuilder, () =>\n    lifeCycle.notify(LifeCycleEventType.BEFORE_UNLOAD)\n  )\n\n  let replicaBatch: Batch | undefined\n  const replica = configuration.replica\n  if (replica !== undefined) {\n    replicaBatch = createRumBatch(replica.rumEndpointBuilder)\n  }\n\n  function createRumBatch(endpointBuilder: EndpointBuilder, unloadCallback?: () => void) {\n    return new Batch(\n      new HttpRequest(endpointBuilder, configuration.batchBytesLimit),\n      configuration.batchMessagesLimit,\n      configuration.batchBytesLimit,\n      configuration.messageBytesLimit,\n      configuration.flushTimeout,\n      unloadCallback\n    )\n  }\n\n  function withReplicaApplicationId(message: Context) {\n    return combine(message, { application: { id: replica!.applicationId } })\n  }\n\n  return {\n    add: (message: Context, replicated = true) => {\n      primaryBatch.add(message)\n      if (replicaBatch && replicated) {\n        replicaBatch.add(withReplicaApplicationId(message))\n      }\n    },\n    upsert: (message: Context, key: string) => {\n      primaryBatch.upsert(message, key)\n      if (replicaBatch) {\n        replicaBatch.upsert(withReplicaApplicationId(message), key)\n      }\n    },\n  }\n}\n","import {\n  addEventListener,\n  DOM_EVENT,\n  instrumentMethodAndCallOriginal,\n  Observable,\n  shallowClone,\n} from '@datadog/browser-core'\n\nexport interface LocationChange {\n  oldLocation: Readonly<Location>\n  newLocation: Readonly<Location>\n}\n\nexport function createLocationChangeObservable(location: Location) {\n  let currentLocation = shallowClone(location)\n  const observable = new Observable<LocationChange>(() => {\n    const { stop: stopHistoryTracking } = trackHistory(onLocationChange)\n    const { stop: stopHashTracking } = trackHash(onLocationChange)\n    return () => {\n      stopHistoryTracking()\n      stopHashTracking()\n    }\n  })\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 observable\n}\n\nfunction trackHistory(onHistoryChange: () => void) {\n  const { stop: stopInstrumentingPushState } = instrumentMethodAndCallOriginal(history, 'pushState', {\n    after: onHistoryChange,\n  })\n  const { stop: stopInstrumentingReplaceState } = instrumentMethodAndCallOriginal(history, 'replaceState', {\n    after: onHistoryChange,\n  })\n  const { stop: removeListener } = addEventListener(window, DOM_EVENT.POP_STATE, onHistoryChange)\n\n  return {\n    stop: () => {\n      stopInstrumentingPushState()\n      stopInstrumentingReplaceState()\n      removeListener()\n    },\n  }\n}\n\nfunction trackHash(onHashChange: () => void) {\n  return addEventListener(window, DOM_EVENT.HASH_CHANGE, onHashChange)\n}\n","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core'\nimport type { RawRumLongTaskEvent } from '../../../rawRumEvent.types'\nimport { RumEventType } from '../../../rawRumEvent.types'\nimport type { LifeCycle } from '../../lifeCycle'\nimport { LifeCycleEventType } from '../../lifeCycle'\nimport type { RumSessionManager } from '../../rumSessionManager'\n\nexport function startLongTaskCollection(lifeCycle: LifeCycle, sessionManager: RumSessionManager) {\n  lifeCycle.subscribe(LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED, (entries) => {\n    for (const entry of entries) {\n      if (entry.entryType !== 'longtask') {\n        break\n      }\n      const session = sessionManager.findTrackedSession(entry.startTime)\n      if (!session || session.hasLitePlan) {\n        break\n      }\n      const startClocks = relativeToClocks(entry.startTime)\n      const rawRumEvent: RawRumLongTaskEvent = {\n        date: startClocks.timeStamp,\n        long_task: {\n          id: generateUUID(),\n          duration: toServerDuration(entry.duration),\n        },\n        type: RumEventType.LONG_TASK,\n      }\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        rawRumEvent,\n        startTime: startClocks.relative,\n        domainContext: { performanceEntry: entry.toJSON() },\n      })\n    }\n  })\n}\n","import type { RelativeTime } from '@datadog/browser-core'\nimport type { ActionContexts } from '../rumEventsCollection/action/actionCollection'\nimport type { RumSessionManager } from '../rumSessionManager'\nimport type { ViewContexts } from './viewContexts'\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  viewContexts: ViewContexts,\n  actionContexts: ActionContexts,\n  urlContexts: UrlContexts\n) {\n  return {\n    get: (startTime?: number): InternalContext | undefined => {\n      const viewContext = viewContexts.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 type { Configuration, InitConfiguration } from '@datadog/browser-core'\nimport {\n  assign,\n  DefaultPrivacyLevel,\n  display,\n  isPercentage,\n  objectHasValue,\n  validateAndBuildConfiguration,\n} from '@datadog/browser-core'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type { RumEvent } from '../rumEvent.types'\n\nexport interface RumInitConfiguration extends InitConfiguration {\n  // global options\n  applicationId: string\n  beforeSend?: ((event: RumEvent, context: RumEventDomainContext) => void | boolean) | undefined\n  premiumSampleRate?: number | undefined\n  excludedActivityUrls?: ReadonlyArray<string | RegExp> | undefined\n\n  // tracing options\n  allowedTracingOrigins?: ReadonlyArray<string | RegExp> | undefined\n  tracingSampleRate?: number | undefined\n\n  // replay options\n  defaultPrivacyLevel?: DefaultPrivacyLevel | undefined\n  /**\n   * @deprecated use premiumSampleRate instead\n   */\n  replaySampleRate?: number | undefined\n\n  // action options\n  trackInteractions?: boolean | undefined\n  trackFrustrations?: boolean | undefined\n  actionNameAttribute?: string | undefined\n\n  // view options\n  trackViewsManually?: boolean | undefined\n}\n\nexport type HybridInitConfiguration = Omit<RumInitConfiguration, 'applicationId' | 'clientToken'>\n\nexport interface RumConfiguration extends Configuration {\n  // Built from init configuration\n  actionNameAttribute: string | undefined\n  allowedTracingOrigins: Array<string | RegExp>\n  tracingSampleRate: number\n  excludedActivityUrls: Array<string | RegExp>\n  applicationId: string\n  defaultPrivacyLevel: DefaultPrivacyLevel\n  premiumSampleRate: number\n  trackInteractions: boolean\n  trackFrustrations: boolean\n  trackViewsManually: boolean\n  version?: string\n}\n\nexport function validateAndBuildRumConfiguration(\n  initConfiguration: RumInitConfiguration\n): RumConfiguration | undefined {\n  if (!initConfiguration.applicationId) {\n    display.error('Application ID is not configured, no RUM data will be collected.')\n    return\n  }\n\n  // TODO remove fallback in next major\n  const premiumSampleRate = initConfiguration.premiumSampleRate ?? initConfiguration.replaySampleRate\n  if (premiumSampleRate !== undefined && !isPercentage(premiumSampleRate)) {\n    display.error('Premium Sample Rate should be a number between 0 and 100')\n    return\n  }\n\n  if (initConfiguration.tracingSampleRate !== undefined && !isPercentage(initConfiguration.tracingSampleRate)) {\n    display.error('Tracing Sample Rate should be a number between 0 and 100')\n    return\n  }\n\n  if (initConfiguration.allowedTracingOrigins !== undefined) {\n    if (!Array.isArray(initConfiguration.allowedTracingOrigins)) {\n      display.error('Allowed Tracing Origins should be an array')\n      return\n    }\n    if (initConfiguration.allowedTracingOrigins.length !== 0 && initConfiguration.service === undefined) {\n      display.error('Service need to be configured when tracing is enabled')\n      return\n    }\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 baseConfiguration = validateAndBuildConfiguration(initConfiguration)\n  if (!baseConfiguration) {\n    return\n  }\n\n  const trackFrustrations = !!initConfiguration.trackFrustrations\n\n  return assign(\n    {\n      applicationId: initConfiguration.applicationId,\n      version: initConfiguration.version,\n      actionNameAttribute: initConfiguration.actionNameAttribute,\n      premiumSampleRate: premiumSampleRate ?? 100,\n      allowedTracingOrigins: initConfiguration.allowedTracingOrigins ?? [],\n      tracingSampleRate: initConfiguration.tracingSampleRate ?? 100,\n      excludedActivityUrls: initConfiguration.excludedActivityUrls ?? [],\n      trackInteractions: !!initConfiguration.trackInteractions || trackFrustrations,\n      trackFrustrations,\n      trackViewsManually: !!initConfiguration.trackViewsManually,\n      defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n        ? initConfiguration.defaultPrivacyLevel\n        : DefaultPrivacyLevel.MASK_USER_INPUT,\n    },\n    baseConfiguration\n  )\n}\n"],"names":["ConsoleApiName","log","debug","info","warn","error","display","api","Object","prototype","hasOwnProperty","call","args","catchUserErrors","fn","errorMsg","err","console","bind","onMonitorErrorCollected","debugMode","setDebugMode","newDebugMode","monitor","callMonitored","this","arguments","context","apply","e","displayIfDebugEnabled","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","throttle","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","undefined","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","setTimeout","cancel","clearTimeout","target","toAssign","forEach","source","key","shallowClone","object","generateUUID","placeholder","parseInt","Math","random","toString","replace","performDraw","threshold","round","num","decimals","toFixed","noop","jsonStringify","value","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","Array","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","toJSON","includes","candidate","search","indexOf","arrayFrom","arrayLike","from","array","Set","item","push","i","length","find","predicate","isPercentage","isNumber","objectValues","keys","map","objectEntries","isEmptyObject","getGlobalObject","globalThis","defineProperty","get","configurable","globalObject","_dd_temp_","self","window","getLinkElementOrigin","element","origin","sanitizedHost","host","protocol","findCommaSeparatedValue","rawString","name","matches","RegExp","exec","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","slice","addEventListener","emitter","event","listener","addEventListeners","events","once","capture","passive","wrappedListener","stop","removeEventListener","runOnReadyState","expectedReadyState","callback","document","readyState","getType","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","hasAlreadyBeenSeen","has","add","createCircularReferenceChecker","Date","getTime","flags","global","ignoreCase","multiline","sticky","unicode","join","merged","deepClone","combine","sources","matchList","list","some","test","cssEscape","str","CSS","escape","ch","asCodePoint","navigationStart","buffer","splice","drain","relativeToClocks","relative","timeStamp","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","getRelativeTime","timestamp","timing","getCurrentSiteCache","COOKIE_ACCESS_DELAY","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","cookie","getCookie","deleteCookie","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","canUseEventBridge","currentHost","location","hostname","bridge","allowedHost","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","split","line","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","url","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","message","fileUrl","filePosition","property","enabledExperimentalFeatures","isURLSupported","ErrorSource","AGENT","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","formatUnknownError","stackTrace","errorObject","nonErrorPrefix","handlingStack","Error","toStackTraceString","type","result","formatErrorMessage","frame","createHandlingStack","formattedStack","isExperimentalFeatureEnabled","featureName","normalizeUrl","buildUrl","href","base","URL","checkURLSupported","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","INTAKE_SITE_US1","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","initConfiguration","endpointType","tags","site","clientToken","domainParts","extension","pop","baseUrl","proxyUrl","build","encodeURIComponent","endpointUrl","buildIntakeUrl","TAG_SIZE_LIMIT","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","sampleRate","enabledFeatures","telemetrySampleRate","enableExperimentalFeatures","filter","flag","beforeSend","cookieOptions","buildCookieOptions","service","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","configuration","env","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeEndpoints","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","computeTransportConfiguration","useSecureSessionCookie","useCrossSiteSessionCookie","mustUseSecureCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","onFirstSubscribe","observers","subscribe","f","onLastUnsubscribe","unsubscribe","other","notify","data","observer","mergeObservables","globalObservable","Observable","subscriptions","observables","observable","subscription","onRawTelemetryEventCollected","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","addTelemetryDebug","addTelemetry","status","addTelemetryError","kind","scrubCustomerFrames","formatError","allowedFrameUrl","getMutationObserverConstructor","constructor","browserWindow","Zone","zoneSymbol","__symbol__","MutationObserver","originalInstance","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","path","areInOrder","numbers","computePerformanceResourceDetails","entry","validEntry","toValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","first_byte","connect","ssl","dns","hasRedirection","redirect","responseEnd","computeSize","decodedBodySize","isAllowedRequestUrl","viewportObservable","viewport","INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","node","isTextNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","traceId","rawTraceTime","Number","nodeName","isCommentNode","match","supportPerformanceObject","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","startPerformanceCollection","lifeCycle","handleRumPerformanceEntries","forcedAttributes","getEntriesByType","relativePerformanceTiming","computeRelativePerformanceTiming","getEntries","entries","mainEntries","experimentalEntries","observe","buffered","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","sendTiming","sendTimingIfPointerIsNotCancelled","delay","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","startClocks","current","field","isValidObjectContaining","set","fields","initViewportObservable","updateDimension","getViewportDimension","visual","visualViewport","width","scale","height","innerWidth","innerHeight","getDisplayContext","viewportDimension","VIEW_EVENTS_MODIFIABLE_FIELD_PATHS","OTHER_EVENTS_MODIFIABLE_FIELD_PATHS","concat","startRumAssembly","sessionManager","viewContexts","urlContexts","actionContexts","getCommonContext","reportError","eventRateLimiters","syntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","getSyntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","findTrackedSession","commonContext","actionId","findActionId","serverRumEvent","_dd","format_version","drift","plan","hasPremiumPlan","browser_sdk_version","application","id","view","referrer","action","synthetics","ci_test","has_replay","hasReplay","user","usr","modifiableFieldPaths","modifier","clone","originalValue","newValue","originalType","newType","limitModification","shouldSend","MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS","MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS","foregroundPeriods","addNewForegroundPeriod","currentForegroundPeriod","closeForegroundPeriod","isInForegroundAt","foregroundPeriod","selectInForegroundPeriodsFor","eventStartTime","eventEndTime","filteredForegroundPeriods","earliestIndex","max","startDuration","endDuration","unshift","xhrObservable","callbacks","eventCallbacks","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","END_OF_TIMES","Infinity","CLEAR_OLD_CONTEXTS_INTERVAL","clearOldContextsInterval","setInterval","clearOldContexts","endTime","remove","index","close","closeActive","latestEntry","findAll","reset","clearInterval","oldTimeThreshold","VIEW_CONTEXT_TIME_OUT_DELAY","instrumentMethod","method","instrumentationFactory","original","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","after","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","state","startContext","isAborted","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","completeContext","input","init","afterSend","responsePromise","reportFetch","response","DOMException","code","ABORT_ERR","responseType","then","clearTracingIfNeeded","spanId","traceSampled","injectHeadersIfTracingAllowed","inject","getCrypto","requestUrl","allowedTracingOrigins","isAllowedUrl","TraceIdentifier","tracingSampleRate","toDecimalString","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","mod","floor","offset","nextRequestIndex","startRequestCollection","tracer","traceFetch","tracingHeaders","Request","headers","append","Headers","header","traceXhr","setRequestHeader","startTracer","rawContext","requestIndex","getNextRequestIndex","trackXhr","fetch","originalFetch","trackFetch","trackEventCounts","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","PAGE_ACTIVITY_VALIDATION_DELAY","PAGE_ACTIVITY_END_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","excludedActivityUrls","MAX_DURATION_BETWEEN_CLICKS","MAX_DISTANCE_BETWEEN_CLICKS","DEFAULT_PROGRAMMATIC_ATTRIBUTE","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","priorityStrategies","userProgrammaticAttribute","HTMLInputElement","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","labelledByAttribute","refElement","getElementById","fallbackStrategies","MAX_PARENTS_TO_CONSIDER","getActionNameFromElementForStrategies","strategies","recursionCounter","strategy","trimmedName","isContentEditable","innerText","removeTextFromElements","query","textToReplace","documentMode","textContent","getSelectorFromElement","targetElementSelector","idSelector","getIDSelector","getClassSelector","getPositionSelector","escapedId","orderedClassList","classList","sort","classUniqueAmongSiblings","children","sibling","tagName","sameClasses","className","a","b","every","contains","previousElementSibling","nextElementSibling","prevSibling","isSelectionEmpty","selection","getSelection","isCollapsed","MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE","DEAD_CLICK_EXCLUDE_SELECTOR","isDead","click","hasPageActivity","getUserActivity","selector","msMatchesSelector","CLICK_ACTION_MAX_DURATION","ACTION_CONTEXT_TIME_OUT_DELAY","trackClickActions","currentClickChain","history","ContextHistory","stopObservable","trackFrustrations","stopClickChain","stopActionEventsListener","selectionEmptyAtMouseDown","onClick","hasSelectionChanged","hasInputChanged","listeners","clickEvent","Element","listenActionEvents","actionNameAttribute","newClick","tryAppend","firstClick","onFinalize","maxDurationBetweenClicksTimeout","bufferedClicks","appendClick","tryFinalize","dontAcceptMoreClick","isStopped","first","second","sqrt","pow","clientX","clientY","createClickChain","clicks","rageClick","isRage","addFrustration","hasError","computeFrustration","discard","validate","finalizeClicks","stopWaitPageActivityEnd","pageActivityEndEvent","viewEndedSubscription","endClocks","stopSubscription","position","rect","getBoundingClientRect","x","left","y","top","activityEndTime","historyEntry","eventCountsSubscription","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","processAction","foregroundContexts","autoActionProperties","isAutoAction","loading_time","count","long_task","resource","actionEvent","inForeground","in_foreground","ERROR_TYPES_RE","consoleObservablesByApi","trackFirstHiddenSingleton","RawReportType","intervention","deprecation","cspViolation","buildStack","sourceFile","lineNumber","columnNumber","startErrorCollection","errorObservable","apis","consoleObservables","originalConsoleApi","params","param","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","consoleError","handling","trackConsoleError","originalError","lineNo","columnNo","errorObj","msg","groups","instrumentOnError","reason","instrumentUnhandledRejection","trackRuntimeError","handleCspViolation","blockedURI","effectiveDirective","subtype","originalPolicy","buildRawReportFromCspViolation","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","initReportObservable","trackReportError","handling_stack","source_type","processError","addError","rawError","computeRawError","doStartErrorCollection","startResourceCollection","matchingTiming","sameNameEntries","getEntriesByName","correspondingEntries","candidates","matchRequestTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","span_id","trace_id","computeRequestTracingInfo","resourceEvent","status_code","performanceEntry","toPerformanceEntryRepresentation","requestInput","requestInit","processRequest","processResourceEntry","isValidUrl","pathname","getPathName","isType","computeResourceKind","entryMetrics","computeEntryTracingInfo","size","PerformanceEntry","trackFirstHidden","visibilityState","TIMING_MAXIMUM_DELAY","trackInitialViewTimings","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","firstContentfulPaint","trackFirstContentfulPaintTiming","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","largestContentfulPaint","trackLargestContentfulPaintTiming","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","trackViewMetrics","scheduleViewUpdate","loadingType","viewStart","stopCLSTracking","viewMetrics","stopEventCountsTracking","newEventCounts","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","newLoadingTime","loadingTime","setLoadEvent","trackLoadingTime","stopLoadingTimeTracking","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","THROTTLE_VIEW_UPDATE_PERIOD","SESSION_KEEP_ALIVE_INTERVAL","newView","initialLocation","viewOptions","customTimings","documentVersion","triggerViewUpdate","cancelScheduleViewUpdate","stopViewMetricsTracking","currentEnd","isActive","scheduleUpdate","clocks","triggerUpdate","updateTimings","addTiming","time","looksLikeRelativeTime","sanitized","sanitizeTiming","getPathFromHash","hash","startViewCollection","locationChangeObservable","recorderApi","initialViewOptions","replayStats","getReplayStats","viewEvent","document_version","replay_stats","cumulative_layout_shift","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","is_active","largest_contentful_paint","load_event","loading_type","time_spent","in_foreground_periods","custom_timings","newObject","mapValues","processViewUpdate","areViewsTrackedAutomatically","locationChangeSubscription","initialView","stopInitialViewTracking","currentView","stopViewLifeCycle","trackViewChange","keepAliveInterval","startViewLifeCycle","currentLocation","otherLocation","correspondingId","oldLocation","substr","renewViewOnLocationChange","startView","trackViews","trackViewsManually","ongoingOperations","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","SESSION_COOKIE_NAME","LOCK_RETRY_DELAY","MAX_NUMBER_OF_LOCK_RETRIES","bufferedOperations","withCookieLockAccess","operations","numberOfRetries","next","currentLock","currentSession","retrieveSession","isCookieLockEnabled","lock","retryLater","setSession","processedSession","process","persistSession","isExpiredState","chrome","navigator","userAgent","currentNumberOfRetries","nextOperations","shift","clearSession","expire","String","toSessionString","sessionString","isValidSessionString","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","productKey","computeSessionState","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","sessionStore","renewObservable","expireObservable","watchSessionTimeoutId","cookieSession","isActiveSession","synchronizeSession","sessionCache","hasSessionInCache","isSessionInCacheOutdated","created","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewCookie","renewSession","expandSession","getSession","startSessionStore","sessionContextHistory","buildSessionContext","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","isTypeTracked","rumSessionType","HAS_MULTI_BYTES_CHARACTERS","beforeUnloadCallback","pushOnlyBuffer","upsertBuffer","bufferBytesCount","bufferMessagesCount","flushOnVisibilityHidden","flushPeriodically","addOrUpdate","upsert","flush","messages","bytesCount","computeBytesCount","TextEncoder","encode","Blob","processedMessage","messageBytesCount","hasMessageFor","willReachedBytesLimitWith","isFull","removedMessage","sendBeacon","endpointBuilder","bytesLimit","hasReportedBeaconError","reportBeaconError","open","URL_CONTEXT_TIME_OUT_DELAY","RecordType","FullSnapshot","IncrementalSnapshot","Meta","Focus","ViewEnd","VisualViewport","FrustrationRecord","NodeType","Document","DocumentType","Text","CDATA","IncrementalSource","MediaInteractionType","NodePrivacyLevel","IGNORE","HIDDEN","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_ALLOW","PRIVACY_ATTR_VALUE_MASK","PRIVACY_ATTR_VALUE_MASK_USER_INPUT","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_ALLOW","PRIVACY_CLASS_MASK","PRIVACY_CLASS_MASK_USER_INPUT","PRIVACY_CLASS_HIDDEN","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","getNodePrivacyLevel","defaultPrivacyLevel","parentNodePrivacyLevel","parentNode","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","nodeType","ELEMENT_NODE","isElement","privAttr","inputElement","autocomplete","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","TEXT_NODE","isFormElement","censorText","text","getTextContent","textNode","ignoreWhiteSpace","parentTagName","nodePrivacyLevel","isStyle","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","isTouchEvent","changedTouches","assembleIncrementalSnapshot","serializeDocument","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","serializeDocumentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","el","getValidTagName","isSVG","SVGElement","attributes","rr_width","rr_height","safeAttrs","attributeName","attributeValue","serializeAttribute","formValue","optionElement","selected","stylesheet","styleSheets","cssText","getCssRulesString","rel","_cssText","sheet","checked","mediaElement","rr_mediaState","paused","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getAttributesForPrivacyLevel","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","TAG_NAME_REGEX","processedTagName","rules","cssRules","getCssRuleString","rule","isCSSImportRule","styleSheet","MUTATION_PROCESS_MAX_DELAY","startMutationObserver","controller","mutationCallback","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","opts","requestIdleCallback","cancelIdleCallback","requestAnimationFrame","cancelAnimationFrame","timeout","createMutationBatch","filteredMutations","mutation","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","removedNodes","Map","addedNodes","delete","sortedAddedAndMovedNodes","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","parent","adds","removes","nextSibling","processChildListMutations","texts","textMutations","handledNodes","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","onFlush","flushListener","convertMouseEventToLayoutCoordinates","normalised","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","getScrollX","pageXOffset","getScrollY","pageYOffset","recordIds","getRecordIdForEvent","initObservers","o","focusCb","frustrationCb","mutationHandler","mutationController","mutationCb","mousemoveHandler","cb","updatePosition","timeOffset","initMoveObserver","mousemoveCb","mouseInteractionHandler","eventTypeToMouseInteraction","record","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","initScrollObserver","scrollCb","viewportResizeHandler","initViewportResizeObserver","viewportResizeCb","inputHandler","lastInputStateMap","onElementChange","inputState","isChecked","cbWithDedup","lastInputState","stopEventListeners","HTMLTextAreaElement","HTMLSelectElement","instrumentationStoppers","stopper","initInputObserver","inputCb","mediaInteractionHandler","mediaInteractionCb","initMediaInteractionObserver","styleSheetObserver","restoreInsertRule","CSSStyleSheet","ownerNode","restoreDeleteRule","initStyleSheetObserver","styleSheetRuleCb","focusHandler","has_focus","hasFocus","visualViewportResizeHandler","cancelThrottle","removeListener","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","statsPerView","MAX_STATS_HISTORY","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","_value","deleteOldestStats","workerURL","worker","creationReason","initialRecord","onWrote","onFlushed","isFlushed","metadata","creation_reason","has_full_snapshot","index_in_view","additionalBytesCount","rawBytesCount","compressedBytesCount","postMessage","min","SEGMENT_DURATION_LIMIT","startSegmentCollection","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribeBeforeUnload","unsubscribeVisibilityChange","segment","expirationTimeoutId","createNewSegment","computeSegmentContext","Segment","compressedSegmentBytesCount","rawSegmentBytesCount","doStartSegmentCollection","createDeflateWorker","createObjectURL","workerCodeFn","Worker","zero","buf","len","LITERALS","L_CODES","D_CODES","MAX_BITS","extra_lbits","extra_dbits","extra_blbits","bl_order","static_ltree","static_dtree","_dist_code","_length_code","MAX_MATCH","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","dist","put_short","w","pending_buf","pending","send_bits","bi_valid","bi_buf","send_code","c","tree","bi_reverse","res","gen_codes","bl_count","bits","n","next_code","init_block","dyn_ltree","dyn_dtree","bl_tree","END_BLOCK","opt_len","static_len","last_lit","bi_windup","smaller","m","depth","_n2","_m2","pqdownheap","k","v","heap","j","heap_len","compress_block","ltree","dtree","lc","extra","lx","d_buf","l_buf","build_tree","desc","stree","heap_max","h","xbits","overflow","gen_bitlen","scan_tree","curlen","prevlen","nextlen","max_count","min_count","REP_3_6","REPZ_3_10","REPZ_11_138","send_tree","static_init_done","_tr_stored_block","stored_len","last","subarray","copy_block","trees","LENGTH_CODES","tr_static_init","l_desc","d_desc","bl_desc","opt_lenb","static_lenb","max_blindex","level","strm","data_type","black_mask","detect_data_type","BL_CODES","build_bl_tree","lcodes","dcodes","blcodes","rank","send_all_trees","lit_bufsize","STATIC_TREES","bi_flush","adler32_1","adler","pos","s1","s2","crcTable","Uint32Array","table","makeTable","crc32_1","crc","t","constants","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_TREES","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_ERRNO","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_BINARY","Z_TEXT","Z_UNKNOWN","Z_DEFLATED","_tr_init$1","_tr_stored_block$1","_tr_flush_block$1","_tr_tally$1","_tr_align$1","Z_FIXED$1","Z_UNKNOWN$1","MAX_MATCH$1","MIN_LOOKAHEAD","HCRC_STATE","BUSY_STATE","FINISH_STATE","errorCode","zero$1","HASH","prev","hash_shift","hash_mask","flush_pending","avail_out","output","pending_out","next_out","total_out","flush_block_only","block_start","strstart","put_byte","putShortMSB","longest_match","cur_match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","w_size","_win","wmask","w_mask","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","p","more","_w_size","window_size","hash_size","avail_in","next_in","wrap","total_in","insert","ins_h","deflate_fast","hash_head","bflush","match_length","max_lazy_match","MIN_MATCH$1","deflate_slow","max_insert","prev_match","match_available","Config","good_length","max_lazy","nice_length","max_chain","configuration_table","max_block_size","pending_buf_size","max_start","DeflateState","gzhead","gzindex","last_flush","w_bits","hash_bits","Uint16Array","HEAP_SIZE$1","MAX_BITS$1","deflateResetKeep","deflateReset","ret","deflateInit2","windowBits","memLevel","deflate_1","deflateInit","deflateSetHeader","deflate","beg","val","old_flush","hcrc","os","bstate","deflate_huff","deflate_rle","deflateEnd","deflateSetDictionary","dictionary","dictLength","tmpDict","avail","deflateInfo","_utf8len","q","zstream","Z_NO_FLUSH$1","Z_FULL_FLUSH$1","Z_FINISH$1","Z_OK$1","Z_STREAM_END$1","Z_DEFAULT_COMPRESSION$1","Z_DEFAULT_STRATEGY$1","Z_DEFLATED$1","Deflate","chunkSize","opt","raw","gzip","ended","chunks","dict","_dict_set","flush_mode","_flush_mode","onData","chunk","l","_i","_l","flattenChunks","string2buf","c2","m_pos","str_len","buf_len","makePakoDeflate","pushData","binaryData","reduce","total","startDeflateWorker","createDeflateWorkerImpl","onError","doStartDeflateWorker","Event","formData","FormData","toFormEntries","HttpRequest","byteLength","onEntry","prefix","existingGlobalVariable","startRecordingImpl","startDeflateWorkerImpl","onRumStart","isRecording","startStrategy","stopStrategy","stopRecording","stopSegmentCollection","emit","MutationController","takeFullSnapshot","initialOffset","mouseInteractionRecord","positions","r","d","frustrationRecord","flushMutations","unsubscribeViewEnded","makeRecorderApi","datadogRum","startRumImpl","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","globalContextManager","newContext","getInternalContextStrategy","getInitConfigurationStrategy","bufferApiCalls","BoundedBuffer","addTimingStrategy","startViewStrategy","addActionStrategy","clonedCommonContext","addErrorStrategy","providedError","doStartRum","startRumResults","LifeCycle","telemetry","contextProvider","experimental_features","toTelemetryEvent","setContextProvider","provider","startTelemetry","startRumTelemetry","startRumEventBridge","telemetryEventObservable","batch","replicaBatch","primaryBatch","createRumBatch","unloadCallback","Batch","withReplicaApplicationId","replicated","makeRumBatch","isTelemetryReplicationAllowed","startRumBatch","hasLitePlan","startRumSessionManagerStub","rawTrackingType","hasValidRumSession","premiumSampleRate","startRumSessionManager","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","onHashChange","stopHistoryTracking","onLocationChange","stopHashTracking","newLocation","createLocationChangeObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","onFocusChange","onBlurChange","stopForegroundTracking","isTrusted","stopBlurTracking","startForegroundContexts","trackInteractions","addAction","startActionCollection","startRumEventCollection","startLongTaskCollection","internalContext","application_id","session_id","user_action","startInternalContext","getInternalContext","stub","publicApi","rumPublicApi","overrideInitConfigurationForBridge","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","canHandleSession","canInitRum","replaySampleRate","baseConfiguration","validateAndBuildRumConfiguration","beforeInitCalls","addRumGlobalContext","removeRumGlobalContext","getRumGlobalContext","setRumGlobalContext","getInitConfiguration","setUser","newUser","sanitizedUser","email","sanitizeUser","removeUser","startSessionReplayRecording","stopSessionReplayRecording","onReady","enumerable","makeRumPublicApi"],"sourceRoot":""}