infront-logger 1.1.5 → 1.1.6

package/dist/browser.es.js

@@ -0,0 +1,4176 @@
+var ConsoleApiName = {
+  log: "log",
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var globalConsole = console;
+var originalConsoleMethods = {};
+Object.keys(ConsoleApiName).forEach(function(name) {
+  originalConsoleMethods[name] = globalConsole[name];
+});
+var PREFIX = "Datadog Browser SDK:";
+var display = {
+  debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
+  log: originalConsoleMethods.log.bind(globalConsole, PREFIX),
+  info: originalConsoleMethods.info.bind(globalConsole, PREFIX),
+  warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),
+  error: originalConsoleMethods.error.bind(globalConsole, PREFIX)
+};
+var DOCS_ORIGIN = "https://docs.datadoghq.com";
+var DOCS_TROUBLESHOOTING = "".concat(DOCS_ORIGIN, "/real_user_monitoring/browser/troubleshooting");
+var MORE_DETAILS = "More details:";
+function catchUserErrors(fn, errorMsg) {
+  return function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    try {
+      return fn.apply(void 0, args);
+    } catch (err) {
+      display.error(errorMsg, err);
+    }
+  };
+}
+function performDraw(threshold) {
+  return threshold !== 0 && Math.random() * 100 <= threshold;
+}
+function isPercentage(value) {
+  return isNumber(value) && value >= 0 && value <= 100;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+var ONE_SECOND = 1e3;
+var ONE_MINUTE = 60 * ONE_SECOND;
+var ONE_HOUR = 60 * ONE_MINUTE;
+function dateNow() {
+  return (/* @__PURE__ */ new Date()).getTime();
+}
+function timeStampNow() {
+  return dateNow();
+}
+function relativeNow() {
+  return performance.now();
+}
+function clocksNow() {
+  return { relative: relativeNow(), timeStamp: timeStampNow() };
+}
+function clocksOrigin() {
+  return { relative: 0, timeStamp: getNavigationStart() };
+}
+function elapsed(start, end) {
+  return end - start;
+}
+function addDuration(a, b) {
+  return a + b;
+}
+function getRelativeTime(timestamp) {
+  return timestamp - getNavigationStart();
+}
+var navigationStart;
+function getNavigationStart() {
+  if (navigationStart === void 0) {
+    navigationStart = performance.timing.navigationStart;
+  }
+  return navigationStart;
+}
+var ONE_KIBI_BYTE = 1024;
+var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
+function computeBytesCount(candidate) {
+  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
+    return candidate.length;
+  }
+  if (window.TextEncoder !== void 0) {
+    return new TextEncoder().encode(candidate).length;
+  }
+  return new Blob([candidate]).size;
+}
+function includes(candidate, search) {
+  return candidate.indexOf(search) !== -1;
+}
+function arrayFrom(arrayLike) {
+  if (Array.from) {
+    return Array.from(arrayLike);
+  }
+  var array = [];
+  if (arrayLike instanceof Set) {
+    arrayLike.forEach(function(item) {
+      return array.push(item);
+    });
+  } else {
+    for (var i = 0; i < arrayLike.length; i++) {
+      array.push(arrayLike[i]);
+    }
+  }
+  return array;
+}
+function find(array, predicate) {
+  for (var i = 0; i < array.length; i += 1) {
+    var item = array[i];
+    if (predicate(item, i)) {
+      return item;
+    }
+  }
+  return void 0;
+}
+function objectValues(object) {
+  return Object.keys(object).map(function(key) {
+    return object[key];
+  });
+}
+function objectEntries(object) {
+  return Object.keys(object).map(function(key) {
+    return [key, object[key]];
+  });
+}
+function startsWith(candidate, search) {
+  return candidate.slice(0, search.length) === search;
+}
+function endsWith(candidate, search) {
+  return candidate.slice(-search.length) === search;
+}
+function assign(target) {
+  var toAssign = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    toAssign[_i - 1] = arguments[_i];
+  }
+  toAssign.forEach(function(source) {
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  });
+  return target;
+}
+function shallowClone(object) {
+  return assign({}, object);
+}
+function objectHasValue(object, value) {
+  return Object.keys(object).some(function(key) {
+    return object[key] === value;
+  });
+}
+function isEmptyObject(object) {
+  return Object.keys(object).length === 0;
+}
+function getGlobalObject() {
+  if (typeof globalThis === "object") {
+    return globalThis;
+  }
+  Object.defineProperty(Object.prototype, "_dd_temp_", {
+    get: function() {
+      return this;
+    },
+    configurable: true
+  });
+  var globalObject = _dd_temp_;
+  delete Object.prototype._dd_temp_;
+  if (typeof globalObject !== "object") {
+    if (typeof self === "object") {
+      globalObject = self;
+    } else if (typeof window === "object") {
+      globalObject = window;
+    } else {
+      globalObject = {};
+    }
+  }
+  return globalObject;
+}
+function getZoneJsOriginalValue(target, name) {
+  var browserWindow = getGlobalObject();
+  var original;
+  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === "function") {
+    original = target[browserWindow.Zone.__symbol__(name)];
+  }
+  if (!original) {
+    original = target[name];
+  }
+  return original;
+}
+var __spreadArray = function(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar)
+          ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var onMonitorErrorCollected;
+var debugMode = false;
+function startMonitorErrorCollection(newOnMonitorErrorCollected) {
+  onMonitorErrorCollected = newOnMonitorErrorCollected;
+}
+function setDebugMode(newDebugMode) {
+  debugMode = newDebugMode;
+}
+function monitored(_, __, descriptor) {
+  var originalMethod = descriptor.value;
+  descriptor.value = function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    var decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;
+    return decorated.apply(this, args);
+  };
+}
+function monitor(fn) {
+  return function() {
+    return callMonitored(fn, this, arguments);
+  };
+}
+function callMonitored(fn, context, args) {
+  try {
+    return fn.apply(context, args);
+  } catch (e) {
+    displayIfDebugEnabled(e);
+    if (onMonitorErrorCollected) {
+      try {
+        onMonitorErrorCollected(e);
+      } catch (e2) {
+        displayIfDebugEnabled(e2);
+      }
+    }
+  }
+}
+function displayIfDebugEnabled() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (debugMode) {
+    display.error.apply(display, __spreadArray(["[MONITOR]"], args, false));
+  }
+}
+function setTimeout(callback, delay) {
+  return getZoneJsOriginalValue(getGlobalObject(), "setTimeout")(monitor(callback), delay);
+}
+function clearTimeout(timeoutId) {
+  getZoneJsOriginalValue(getGlobalObject(), "clearTimeout")(timeoutId);
+}
+function setInterval(callback, delay) {
+  return getZoneJsOriginalValue(getGlobalObject(), "setInterval")(monitor(callback), delay);
+}
+function clearInterval(timeoutId) {
+  getZoneJsOriginalValue(getGlobalObject(), "clearInterval")(timeoutId);
+}
+var Observable = (
+  /** @class */
+  function() {
+    function Observable2(onFirstSubscribe) {
+      this.onFirstSubscribe = onFirstSubscribe;
+      this.observers = [];
+    }
+    Observable2.prototype.subscribe = function(f) {
+      var _this = this;
+      this.observers.push(f);
+      if (this.observers.length === 1 && this.onFirstSubscribe) {
+        this.onLastUnsubscribe = this.onFirstSubscribe(this) || void 0;
+      }
+      return {
+        unsubscribe: function() {
+          _this.observers = _this.observers.filter(function(other) {
+            return f !== other;
+          });
+          if (!_this.observers.length && _this.onLastUnsubscribe) {
+            _this.onLastUnsubscribe();
+          }
+        }
+      };
+    };
+    Observable2.prototype.notify = function(data) {
+      this.observers.forEach(function(observer) {
+        return observer(data);
+      });
+    };
+    return Observable2;
+  }()
+);
+function mergeObservables() {
+  var observables = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    observables[_i] = arguments[_i];
+  }
+  return new Observable(function(globalObservable) {
+    var subscriptions = observables.map(function(observable) {
+      return observable.subscribe(function(data) {
+        return globalObservable.notify(data);
+      });
+    });
+    return function() {
+      return subscriptions.forEach(function(subscription) {
+        return subscription.unsubscribe();
+      });
+    };
+  });
+}
+function throttle(fn, wait, options) {
+  var needLeadingExecution = options && options.leading !== void 0 ? options.leading : true;
+  var needTrailingExecution = options && options.trailing !== void 0 ? options.trailing : true;
+  var inWaitPeriod = false;
+  var pendingExecutionWithParameters;
+  var pendingTimeoutId;
+  return {
+    throttled: function() {
+      var parameters = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        parameters[_i] = arguments[_i];
+      }
+      if (inWaitPeriod) {
+        pendingExecutionWithParameters = parameters;
+        return;
+      }
+      if (needLeadingExecution) {
+        fn.apply(void 0, parameters);
+      } else {
+        pendingExecutionWithParameters = parameters;
+      }
+      inWaitPeriod = true;
+      pendingTimeoutId = setTimeout(function() {
+        if (needTrailingExecution && pendingExecutionWithParameters) {
+          fn.apply(void 0, pendingExecutionWithParameters);
+        }
+        inWaitPeriod = false;
+        pendingExecutionWithParameters = void 0;
+      }, wait);
+    },
+    cancel: function() {
+      clearTimeout(pendingTimeoutId);
+      inWaitPeriod = false;
+      pendingExecutionWithParameters = void 0;
+    }
+  };
+}
+function noop() {
+}
+function generateUUID(placeholder) {
+  return placeholder ? (
+    // eslint-disable-next-line  no-bitwise
+    (parseInt(placeholder, 10) ^ Math.random() * 16 >> parseInt(placeholder, 10) / 4).toString(16)
+  ) : "".concat(1e7, "-").concat(1e3, "-").concat(4e3, "-").concat(8e3, "-").concat(1e11).replace(/[018]/g, generateUUID);
+}
+var COMMA_SEPARATED_KEY_VALUE = /([\w-]+)\s*=\s*([^;]+)/g;
+function findCommaSeparatedValue(rawString, name) {
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;
+  while (true) {
+    var match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);
+    if (match) {
+      if (match[1] === name) {
+        return match[2];
+      }
+    } else {
+      break;
+    }
+  }
+}
+function findCommaSeparatedValues(rawString) {
+  var result = /* @__PURE__ */ new Map();
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0;
+  while (true) {
+    var match = COMMA_SEPARATED_KEY_VALUE.exec(rawString);
+    if (match) {
+      result.set(match[1], match[2]);
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function safeTruncate(candidate, length, suffix) {
+  if (suffix === void 0) {
+    suffix = "";
+  }
+  var lastChar = candidate.charCodeAt(length - 1);
+  var isLastCharSurrogatePair = lastChar >= 55296 && lastChar <= 56319;
+  var correctedLength = isLastCharSurrogatePair ? length + 1 : length;
+  if (candidate.length <= correctedLength) {
+    return candidate;
+  }
+  return "".concat(candidate.slice(0, correctedLength)).concat(suffix);
+}
+function isChromium() {
+  return detectBrowserCached() === 1;
+}
+var browserCache;
+function detectBrowserCached() {
+  return browserCache !== null && browserCache !== void 0 ? browserCache : browserCache = detectBrowser();
+}
+function detectBrowser(browserWindow) {
+  var _a2;
+  if (browserWindow === void 0) {
+    browserWindow = window;
+  }
+  var userAgent = browserWindow.navigator.userAgent;
+  if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) {
+    return 1;
+  }
+  if (
+    // navigator.vendor is deprecated, but it is the most resilient way we found to detect
+    // "Apple maintained browsers" (AKA Safari). If one day it gets removed, we still have the
+    // useragent test as a semi-working fallback.
+    ((_a2 = browserWindow.navigator.vendor) === null || _a2 === void 0 ? void 0 : _a2.indexOf("Apple")) === 0 || /safari/i.test(userAgent) && !/chrome|android/i.test(userAgent)
+  ) {
+    return 2;
+  }
+  if (browserWindow.document.documentMode) {
+    return 0;
+  }
+  return 3;
+}
+function setCookie(name, value, expireDelay, options) {
+  var date = /* @__PURE__ */ new Date();
+  date.setTime(date.getTime() + expireDelay);
+  var expires = "expires=".concat(date.toUTCString());
+  var sameSite = options && options.crossSite ? "none" : "strict";
+  var domain = options && options.domain ? ";domain=".concat(options.domain) : "";
+  var secure = options && options.secure ? ";secure" : "";
+  var partitioned = options && options.partitioned ? ";partitioned" : "";
+  document.cookie = "".concat(name, "=").concat(value, ";").concat(expires, ";path=/;samesite=").concat(sameSite).concat(domain).concat(secure).concat(partitioned);
+}
+function getCookie(name) {
+  return findCommaSeparatedValue(document.cookie, name);
+}
+var initCookieParsed;
+function getInitCookie(name) {
+  if (!initCookieParsed) {
+    initCookieParsed = findCommaSeparatedValues(document.cookie);
+  }
+  return initCookieParsed.get(name);
+}
+function deleteCookie(name, options) {
+  setCookie(name, "", 0, options);
+}
+function areCookiesAuthorized(options) {
+  if (document.cookie === void 0 || document.cookie === null) {
+    return false;
+  }
+  try {
+    var testCookieName = "dd_cookie_test_".concat(generateUUID());
+    var testCookieValue = "test";
+    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);
+    var isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;
+    deleteCookie(testCookieName, options);
+    return isCookieCorrectlySet;
+  } catch (error) {
+    display.error(error);
+    return false;
+  }
+}
+var getCurrentSiteCache;
+function getCurrentSite() {
+  if (getCurrentSiteCache === void 0) {
+    var testCookieName = "dd_site_test_".concat(generateUUID());
+    var testCookieValue = "test";
+    var domainLevels = window.location.hostname.split(".");
+    var candidateDomain = domainLevels.pop();
+    while (domainLevels.length && !getCookie(testCookieName)) {
+      candidateDomain = "".concat(domainLevels.pop(), ".").concat(candidateDomain);
+      setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain });
+    }
+    deleteCookie(testCookieName, { domain: candidateDomain });
+    getCurrentSiteCache = candidateDomain;
+  }
+  return getCurrentSiteCache;
+}
+var SESSION_STORE_KEY = "_dd_s";
+var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;
+var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;
+var SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;
+var SESSION_ENTRY_SEPARATOR = "&";
+var EXPIRED = "1";
+function getExpiredSessionState() {
+  return {
+    isExpired: EXPIRED
+  };
+}
+function isSessionInNotStartedState(session) {
+  return isEmptyObject(session);
+}
+function isSessionStarted(session) {
+  return !isSessionInNotStartedState(session);
+}
+function isSessionInExpiredState(session) {
+  return session.isExpired !== void 0 || !isActiveSession(session);
+}
+function isActiveSession(sessionState) {
+  return (sessionState.created === void 0 || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) && (sessionState.expire === void 0 || dateNow() < Number(sessionState.expire));
+}
+function expandSessionState(session) {
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);
+}
+function toSessionString(session) {
+  return objectEntries(session).map(function(_a2) {
+    var key = _a2[0], value = _a2[1];
+    return "".concat(key, "=").concat(value);
+  }).join(SESSION_ENTRY_SEPARATOR);
+}
+function toSessionState(sessionString) {
+  var session = {};
+  if (isValidSessionString(sessionString)) {
+    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function(entry) {
+      var matches = SESSION_ENTRY_REGEXP.exec(entry);
+      if (matches !== null) {
+        var key = matches[1], value = matches[2];
+        session[key] = value;
+      }
+    });
+  }
+  return session;
+}
+function isValidSessionString(sessionString) {
+  return !!sessionString && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));
+}
+var OLD_SESSION_COOKIE_NAME = "_dd";
+var OLD_RUM_COOKIE_NAME = "_dd_r";
+var OLD_LOGS_COOKIE_NAME = "_dd_l";
+var RUM_SESSION_KEY = "rum";
+var LOGS_SESSION_KEY$1 = "logs";
+function tryOldCookiesMigration(cookieStoreStrategy) {
+  var sessionString = getInitCookie(SESSION_STORE_KEY);
+  if (!sessionString) {
+    var oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME);
+    var oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME);
+    var oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME);
+    var session = {};
+    if (oldSessionId) {
+      session.id = oldSessionId;
+    }
+    if (oldLogsType && /^[01]$/.test(oldLogsType)) {
+      session[LOGS_SESSION_KEY$1] = oldLogsType;
+    }
+    if (oldRumType && /^[012]$/.test(oldRumType)) {
+      session[RUM_SESSION_KEY] = oldRumType;
+    }
+    if (isSessionStarted(session)) {
+      expandSessionState(session);
+      cookieStoreStrategy.persistSession(session);
+    }
+  }
+}
+function selectCookieStrategy(initConfiguration) {
+  var cookieOptions = buildCookieOptions(initConfiguration);
+  return areCookiesAuthorized(cookieOptions) ? { type: "Cookie", cookieOptions } : void 0;
+}
+function initCookieStrategy(cookieOptions) {
+  var cookieStore = {
+    /**
+     * Lock strategy allows mitigating issues due to concurrent access to cookie.
+     * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.
+     */
+    isLockEnabled: isChromium(),
+    persistSession: persistSessionCookie(cookieOptions),
+    retrieveSession: retrieveSessionCookie,
+    expireSession: function() {
+      return expireSessionCookie(cookieOptions);
+    }
+  };
+  tryOldCookiesMigration(cookieStore);
+  return cookieStore;
+}
+function persistSessionCookie(options) {
+  return function(session) {
+    setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);
+  };
+}
+function expireSessionCookie(options) {
+  setCookie(SESSION_STORE_KEY, toSessionString(getExpiredSessionState()), SESSION_TIME_OUT_DELAY, options);
+}
+function retrieveSessionCookie() {
+  var sessionString = getCookie(SESSION_STORE_KEY);
+  return toSessionState(sessionString);
+}
+function buildCookieOptions(initConfiguration) {
+  var cookieOptions = {};
+  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;
+  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;
+  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie;
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite();
+  }
+  return cookieOptions;
+}
+var LOCAL_STORAGE_TEST_KEY = "_dd_test_";
+function selectLocalStorageStrategy() {
+  try {
+    var id = generateUUID();
+    var testKey = "".concat(LOCAL_STORAGE_TEST_KEY).concat(id);
+    localStorage.setItem(testKey, id);
+    var retrievedId = localStorage.getItem(testKey);
+    localStorage.removeItem(testKey);
+    return id === retrievedId ? { type: "LocalStorage" } : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function initLocalStorageStrategy() {
+  return {
+    isLockEnabled: false,
+    persistSession: persistInLocalStorage,
+    retrieveSession: retrieveSessionFromLocalStorage,
+    expireSession: expireSessionFromLocalStorage
+  };
+}
+function persistInLocalStorage(sessionState) {
+  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));
+}
+function retrieveSessionFromLocalStorage() {
+  var sessionString = localStorage.getItem(SESSION_STORE_KEY);
+  return toSessionState(sessionString);
+}
+function expireSessionFromLocalStorage() {
+  persistInLocalStorage(getExpiredSessionState());
+}
+var LOCK_RETRY_DELAY = 10;
+var LOCK_MAX_TRIES = 100;
+var bufferedOperations = [];
+var ongoingOperations;
+function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries) {
+  var _a2;
+  if (numberOfRetries === void 0) {
+    numberOfRetries = 0;
+  }
+  var isLockEnabled = sessionStoreStrategy.isLockEnabled, persistSession = sessionStoreStrategy.persistSession, expireSession = sessionStoreStrategy.expireSession;
+  var persistWithLock = function(session) {
+    return persistSession(assign({}, session, { lock: currentLock }));
+  };
+  var retrieveStore = function() {
+    var session = sessionStoreStrategy.retrieveSession();
+    var lock = session.lock;
+    if (session.lock) {
+      delete session.lock;
+    }
+    return {
+      session,
+      lock
+    };
+  };
+  if (!ongoingOperations) {
+    ongoingOperations = operations;
+  }
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations);
+    return;
+  }
+  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    next(sessionStoreStrategy);
+    return;
+  }
+  var currentLock;
+  var currentStore = retrieveStore();
+  if (isLockEnabled) {
+    if (currentStore.lock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries);
+      return;
+    }
+    currentLock = generateUUID();
+    persistWithLock(currentStore.session);
+    currentStore = retrieveStore();
+    if (currentStore.lock !== currentLock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries);
+      return;
+    }
+  }
+  var processedSession = operations.process(currentStore.session);
+  if (isLockEnabled) {
+    currentStore = retrieveStore();
+    if (currentStore.lock !== currentLock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries);
+      return;
+    }
+  }
+  if (processedSession) {
+    if (isSessionInExpiredState(processedSession)) {
+      expireSession();
+    } else {
+      expandSessionState(processedSession);
+      isLockEnabled ? persistWithLock(processedSession) : persistSession(processedSession);
+    }
+  }
+  if (isLockEnabled) {
+    if (!(processedSession && isSessionInExpiredState(processedSession))) {
+      currentStore = retrieveStore();
+      if (currentStore.lock !== currentLock) {
+        retryLater(operations, sessionStoreStrategy, numberOfRetries);
+        return;
+      }
+      persistSession(currentStore.session);
+      processedSession = currentStore.session;
+    }
+  }
+  (_a2 = operations.after) === null || _a2 === void 0 ? void 0 : _a2.call(operations, processedSession || currentStore.session);
+  next(sessionStoreStrategy);
+}
+function retryLater(operations, sessionStore, currentNumberOfRetries) {
+  setTimeout(function() {
+    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);
+  }, LOCK_RETRY_DELAY);
+}
+function next(sessionStore) {
+  ongoingOperations = void 0;
+  var nextOperations = bufferedOperations.shift();
+  if (nextOperations) {
+    processSessionStoreOperations(nextOperations, sessionStore);
+  }
+}
+var STORAGE_POLL_DELAY = ONE_SECOND;
+function selectSessionStoreStrategyType(initConfiguration) {
+  var sessionStoreStrategyType = selectCookieStrategy(initConfiguration);
+  if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
+    sessionStoreStrategyType = selectLocalStorageStrategy();
+  }
+  return sessionStoreStrategyType;
+}
+function startSessionStore(sessionStoreStrategyType, productKey, computeSessionState2) {
+  var renewObservable = new Observable();
+  var expireObservable = new Observable();
+  var sessionStateUpdateObservable = new Observable();
+  var sessionStoreStrategy = sessionStoreStrategyType.type === "Cookie" ? initCookieStrategy(sessionStoreStrategyType.cookieOptions) : initLocalStorageStrategy();
+  var expireSession = sessionStoreStrategy.expireSession;
+  var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);
+  var sessionCache;
+  startSession();
+  var _a2 = throttle(function() {
+    processSessionStoreOperations({
+      process: function(sessionState) {
+        if (isSessionInNotStartedState(sessionState)) {
+          return;
+        }
+        var synchronizedSession = synchronizeSession(sessionState);
+        expandOrRenewSessionState(synchronizedSession);
+        return synchronizedSession;
+      },
+      after: function(sessionState) {
+        if (isSessionStarted(sessionState) && !hasSessionInCache()) {
+          renewSessionInCache(sessionState);
+        }
+        sessionCache = sessionState;
+      }
+    }, sessionStoreStrategy);
+  }, STORAGE_POLL_DELAY), throttledExpandOrRenewSession = _a2.throttled, cancelExpandOrRenewSession = _a2.cancel;
+  function expandSession() {
+    processSessionStoreOperations({
+      process: function(sessionState) {
+        return hasSessionInCache() ? synchronizeSession(sessionState) : void 0;
+      }
+    }, sessionStoreStrategy);
+  }
+  function watchSession() {
+    processSessionStoreOperations({
+      process: function(sessionState) {
+        return isSessionInExpiredState(sessionState) ? getExpiredSessionState() : void 0;
+      },
+      after: synchronizeSession
+    }, sessionStoreStrategy);
+  }
+  function synchronizeSession(sessionState) {
+    if (isSessionInExpiredState(sessionState)) {
+      sessionState = getExpiredSessionState();
+    }
+    if (hasSessionInCache()) {
+      if (isSessionInCacheOutdated(sessionState)) {
+        expireSessionInCache();
+      } else {
+        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState });
+        sessionCache = sessionState;
+      }
+    }
+    return sessionState;
+  }
+  function startSession() {
+    processSessionStoreOperations({
+      process: function(sessionState) {
+        if (isSessionInNotStartedState(sessionState)) {
+          return getExpiredSessionState();
+        }
+      },
+      after: function(sessionState) {
+        sessionCache = sessionState;
+      }
+    }, sessionStoreStrategy);
+  }
+  function expandOrRenewSessionState(sessionState) {
+    if (isSessionInNotStartedState(sessionState)) {
+      return false;
+    }
+    var _a3 = computeSessionState2(sessionState[productKey]), trackingType = _a3.trackingType, isTracked = _a3.isTracked;
+    sessionState[productKey] = trackingType;
+    delete sessionState.isExpired;
+    if (isTracked && !sessionState.id) {
+      sessionState.id = generateUUID();
+      sessionState.created = String(dateNow());
+    }
+  }
+  function hasSessionInCache() {
+    return sessionCache[productKey] !== void 0;
+  }
+  function isSessionInCacheOutdated(sessionState) {
+    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];
+  }
+  function expireSessionInCache() {
+    sessionCache = getExpiredSessionState();
+    expireObservable.notify();
+  }
+  function renewSessionInCache(sessionState) {
+    sessionCache = sessionState;
+    renewObservable.notify();
+  }
+  function updateSessionState(partialSessionState) {
+    processSessionStoreOperations({
+      process: function(sessionState) {
+        return assign({}, sessionState, partialSessionState);
+      },
+      after: synchronizeSession
+    }, sessionStoreStrategy);
+  }
+  return {
+    expandOrRenewSession: throttledExpandOrRenewSession,
+    expandSession,
+    getSession: function() {
+      return sessionCache;
+    },
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable,
+    restartSession: startSession,
+    expire: function() {
+      cancelExpandOrRenewSession();
+      expireSession();
+      synchronizeSession(getExpiredSessionState());
+    },
+    stop: function() {
+      clearInterval(watchSessionTimeoutId);
+    },
+    updateSessionState
+  };
+}
+var TrackingConsent = {
+  GRANTED: "granted",
+  NOT_GRANTED: "not-granted"
+};
+function createTrackingConsentState(currentConsent) {
+  var observable = new Observable();
+  return {
+    tryToInit: function(trackingConsent) {
+      if (!currentConsent) {
+        currentConsent = trackingConsent;
+      }
+    },
+    update: function(trackingConsent) {
+      currentConsent = trackingConsent;
+      observable.notify();
+    },
+    isGranted: function() {
+      return currentConsent === TrackingConsent.GRANTED;
+    },
+    observable
+  };
+}
+function jsonStringify(value, replacer, space) {
+  if (typeof value !== "object" || value === null) {
+    return JSON.stringify(value);
+  }
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+  var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));
+  var restoreValueToJson = detachToJsonMethod(value);
+  try {
+    return JSON.stringify(value, replacer, space);
+  } catch (_a2) {
+    return "<error: unable to serialize object>";
+  } finally {
+    restoreObjectPrototypeToJson();
+    restoreArrayPrototypeToJson();
+    restoreValuePrototypeToJson();
+    restoreValueToJson();
+  }
+}
+function detachToJsonMethod(value) {
+  var object = value;
+  var objectToJson = object.toJSON;
+  if (objectToJson) {
+    delete object.toJSON;
+    return function() {
+      object.toJSON = objectToJson;
+    };
+  }
+  return noop;
+}
+function normalizeUrl(url) {
+  return buildUrl(url, location.href).href;
+}
+function buildUrl(url, base) {
+  var supportedURL = getSupportedUrl();
+  if (supportedURL) {
+    try {
+      return base !== void 0 ? new supportedURL(url, base) : new supportedURL(url);
+    } catch (error) {
+      throw new Error("Failed to construct URL: ".concat(String(error), " ").concat(jsonStringify({ url, base })));
+    }
+  }
+  if (base === void 0 && !/:/.test(url)) {
+    throw new Error("Invalid URL: '".concat(url, "'"));
+  }
+  var doc = document;
+  var anchorElement = doc.createElement("a");
+  if (base !== void 0) {
+    doc = document.implementation.createHTMLDocument("");
+    var baseElement = doc.createElement("base");
+    baseElement.href = base;
+    doc.head.appendChild(baseElement);
+    doc.body.appendChild(anchorElement);
+  }
+  anchorElement.href = url;
+  return anchorElement;
+}
+var originalURL = URL;
+var isURLSupported;
+function getSupportedUrl() {
+  if (isURLSupported === void 0) {
+    try {
+      var url = new originalURL("http://test/path");
+      isURLSupported = url.href === "http://test/path";
+    } catch (_a2) {
+      isURLSupported = false;
+    }
+  }
+  return isURLSupported ? originalURL : void 0;
+}
+var INTAKE_SITE_STAGING = "datad0g.com";
+var INTAKE_SITE_FED_STAGING = "dd0g-gov.com";
+var INTAKE_SITE_US1 = "datadoghq.com";
+var INTAKE_SITE_US1_FED = "ddog-gov.com";
+var PCI_INTAKE_HOST_US1 = "pci.browser-intake-datadoghq.com";
+function createEndpointBuilder(initConfiguration, trackType, configurationTags) {
+  var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType);
+  return {
+    build: function(api, payload) {
+      var parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload);
+      return buildUrlWithParameters(parameters);
+    },
+    urlPrefix: buildUrlWithParameters(""),
+    trackType
+  };
+}
+function createEndpointUrlWithParametersBuilder(initConfiguration, trackType) {
+  var path = "/api/v2/".concat(trackType);
+  var proxy = initConfiguration.proxy;
+  if (typeof proxy === "string") {
+    var normalizedProxyUrl_1 = normalizeUrl(proxy);
+    return function(parameters) {
+      return "".concat(normalizedProxyUrl_1, "?ddforward=").concat(encodeURIComponent("".concat(path, "?").concat(parameters)));
+    };
+  }
+  if (typeof proxy === "function") {
+    return function(parameters) {
+      return proxy({ path, parameters });
+    };
+  }
+  var host = buildEndpointHost(trackType, initConfiguration);
+  return function(parameters) {
+    return "https://".concat(host).concat(path, "?").concat(parameters);
+  };
+}
+function buildEndpointHost(trackType, initConfiguration) {
+  var _a2 = initConfiguration.site, site = _a2 === void 0 ? INTAKE_SITE_US1 : _a2, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;
+  if (trackType === "logs" && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {
+    return PCI_INTAKE_HOST_US1;
+  }
+  if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {
+    return "".concat(internalAnalyticsSubdomain, ".").concat(INTAKE_SITE_US1);
+  }
+  if (site === INTAKE_SITE_FED_STAGING) {
+    return "http-intake.logs.".concat(site);
+  }
+  var domainParts = site.split(".");
+  var extension = domainParts.pop();
+  return "browser-intake-".concat(domainParts.join("-"), ".").concat(extension);
+}
+function buildEndpointParameters(_a2, trackType, configurationTags, api, _b) {
+  var clientToken = _a2.clientToken, internalAnalyticsSubdomain = _a2.internalAnalyticsSubdomain;
+  var retry = _b.retry, encoding = _b.encoding;
+  var tags = ["sdk_version:".concat("5.23.3"), "api:".concat(api)].concat(configurationTags);
+  if (retry) {
+    tags.push("retry_count:".concat(retry.count), "retry_after:".concat(retry.lastFailureStatus));
+  }
+  var parameters = [
+    "ddsource=browser",
+    "ddtags=".concat(encodeURIComponent(tags.join(","))),
+    "dd-api-key=".concat(clientToken),
+    "dd-evp-origin-version=".concat(encodeURIComponent("5.23.3")),
+    "dd-evp-origin=browser",
+    "dd-request-id=".concat(generateUUID())
+  ];
+  if (encoding) {
+    parameters.push("dd-evp-encoding=".concat(encoding));
+  }
+  if (trackType === "rum") {
+    parameters.push("batch_time=".concat(timeStampNow()));
+  }
+  if (internalAnalyticsSubdomain) {
+    parameters.reverse();
+  }
+  return parameters.join("&");
+}
+var TAG_SIZE_LIMIT = 200;
+function buildTags(configuration) {
+  var env = configuration.env, service = configuration.service, version = configuration.version, datacenter = configuration.datacenter;
+  var tags = [];
+  if (env) {
+    tags.push(buildTag("env", env));
+  }
+  if (service) {
+    tags.push(buildTag("service", service));
+  }
+  if (version) {
+    tags.push(buildTag("version", version));
+  }
+  if (datacenter) {
+    tags.push(buildTag("datacenter", datacenter));
+  }
+  return tags;
+}
+var FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/;
+function buildTag(key, rawValue) {
+  var valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;
+  if (rawValue.length > valueSizeLimit || FORBIDDEN_CHARACTERS.test(rawValue)) {
+    display.warn("".concat(key, " value doesn't meet tag requirements and will be sanitized. ").concat(MORE_DETAILS, " ").concat(DOCS_ORIGIN, "/getting_started/tagging/#defining-tags"));
+  }
+  var sanitizedValue = rawValue.replace(/,/g, "_");
+  return "".concat(key, ":").concat(sanitizedValue);
+}
+function computeTransportConfiguration(initConfiguration) {
+  var site = initConfiguration.site || INTAKE_SITE_US1;
+  var tags = buildTags(initConfiguration);
+  var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);
+  var intakeUrlPrefixes = computeIntakeUrlPrefixes(endpointBuilders, site);
+  var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);
+  return assign({
+    isIntakeUrl: function(url) {
+      return intakeUrlPrefixes.some(function(intakeEndpoint) {
+        return url.indexOf(intakeEndpoint) === 0;
+      });
+    },
+    replica: replicaConfiguration,
+    site
+  }, endpointBuilders);
+}
+function computeEndpointBuilders(initConfiguration, tags) {
+  return {
+    logsEndpointBuilder: createEndpointBuilder(initConfiguration, "logs", tags),
+    rumEndpointBuilder: createEndpointBuilder(initConfiguration, "rum", tags),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, "replay", tags)
+  };
+}
+function computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags) {
+  if (!initConfiguration.replica) {
+    return;
+  }
+  var replicaConfiguration = assign({}, initConfiguration, {
+    site: INTAKE_SITE_US1,
+    clientToken: initConfiguration.replica.clientToken
+  });
+  var replicaEndpointBuilders = {
+    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, "logs", tags),
+    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, "rum", tags)
+  };
+  intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function(builder) {
+    return builder.urlPrefix;
+  }));
+  return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);
+}
+function computeIntakeUrlPrefixes(endpointBuilders, site) {
+  var intakeUrlPrefixes = objectValues(endpointBuilders).map(function(builder) {
+    return builder.urlPrefix;
+  });
+  if (site === INTAKE_SITE_US1) {
+    intakeUrlPrefixes.push("https://".concat(PCI_INTAKE_HOST_US1, "/"));
+  }
+  return intakeUrlPrefixes;
+}
+function isString(tag, tagName) {
+  if (tag !== void 0 && tag !== null && typeof tag !== "string") {
+    display.error("".concat(tagName, " must be defined as a string"));
+    return false;
+  }
+  return true;
+}
+function isDatadogSite(site) {
+  if (site && typeof site === "string" && !/(datadog|ddog|datad0g|dd0g)/.test(site)) {
+    display.error("Site should be a valid Datadog site. ".concat(MORE_DETAILS, " ").concat(DOCS_ORIGIN, "/getting_started/site/."));
+    return false;
+  }
+  return true;
+}
+function isSampleRate(sampleRate, name) {
+  if (sampleRate !== void 0 && !isPercentage(sampleRate)) {
+    display.error("".concat(name, " Sample Rate should be a number between 0 and 100"));
+    return false;
+  }
+  return true;
+}
+function validateAndBuildConfiguration(initConfiguration) {
+  var _a2, _b, _c, _d, _e;
+  if (!initConfiguration || !initConfiguration.clientToken) {
+    display.error("Client Token is not configured, we will not send any data.");
+    return;
+  }
+  if (!isDatadogSite(initConfiguration.site) || !isSampleRate(initConfiguration.sessionSampleRate, "Session") || !isSampleRate(initConfiguration.telemetrySampleRate, "Telemetry") || !isSampleRate(initConfiguration.telemetryConfigurationSampleRate, "Telemetry Configuration") || !isSampleRate(initConfiguration.telemetryUsageSampleRate, "Telemetry Usage") || !isString(initConfiguration.version, "Version") || !isString(initConfiguration.env, "Env") || !isString(initConfiguration.service, "Service")) {
+    return;
+  }
+  if (initConfiguration.trackingConsent !== void 0 && !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)) {
+    display.error('Tracking Consent should be either "granted" or "not-granted"');
+    return;
+  }
+  return assign({
+    beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, "beforeSend threw an error:"),
+    sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),
+    sessionSampleRate: (_a2 = initConfiguration.sessionSampleRate) !== null && _a2 !== void 0 ? _a2 : 100,
+    telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,
+    telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,
+    telemetryUsageSampleRate: (_d = initConfiguration.telemetryUsageSampleRate) !== null && _d !== void 0 ? _d : 5,
+    service: initConfiguration.service || void 0,
+    silentMultipleInit: !!initConfiguration.silentMultipleInit,
+    allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,
+    trackingConsent: (_e = initConfiguration.trackingConsent) !== null && _e !== void 0 ? _e : TrackingConsent.GRANTED,
+    storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,
+    /**
+     * beacon payload max queue size implementation is 64kb
+     * ensure that we leave room for logs, rum and potential other users
+     */
+    batchBytesLimit: 16 * ONE_KIBI_BYTE,
+    eventRateLimiterThreshold: 3e3,
+    maxTelemetryEventsPerPage: 15,
+    /**
+     * flush automatically, aim to be lower than ALB connection timeout
+     * to maximize connection reuse.
+     */
+    flushTimeout: 30 * ONE_SECOND,
+    /**
+     * Logs intake limit
+     */
+    batchMessagesLimit: 50,
+    messageBytesLimit: 256 * ONE_KIBI_BYTE
+  }, computeTransportConfiguration(initConfiguration));
+}
+function serializeConfiguration(initConfiguration) {
+  return {
+    session_sample_rate: initConfiguration.sessionSampleRate,
+    telemetry_sample_rate: initConfiguration.telemetrySampleRate,
+    telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,
+    telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,
+    use_before_send: !!initConfiguration.beforeSend,
+    use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,
+    use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,
+    use_secure_session_cookie: initConfiguration.useSecureSessionCookie,
+    use_proxy: !!initConfiguration.proxy,
+    silent_multiple_init: initConfiguration.silentMultipleInit,
+    track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
+    allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,
+    store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
+    allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
+    tracking_consent: initConfiguration.trackingConsent
+  };
+}
+var ExperimentalFeature;
+(function(ExperimentalFeature2) {
+  ExperimentalFeature2["WRITABLE_RESOURCE_GRAPHQL"] = "writable_resource_graphql";
+  ExperimentalFeature2["CUSTOM_VITALS"] = "custom_vitals";
+  ExperimentalFeature2["TOLERANT_RESOURCE_TIMINGS"] = "tolerant_resource_timings";
+  ExperimentalFeature2["REMOTE_CONFIGURATION"] = "remote_configuration";
+  ExperimentalFeature2["UPDATE_VIEW_NAME"] = "update_view_name";
+})(ExperimentalFeature || (ExperimentalFeature = {}));
+var enabledExperimentalFeatures = /* @__PURE__ */ new Set();
+function initFeatureFlags(enableExperimentalFeatures) {
+  if (Array.isArray(enableExperimentalFeatures)) {
+    addExperimentalFeatures(enableExperimentalFeatures.filter(function(flag) {
+      return objectHasValue(ExperimentalFeature, flag);
+    }));
+  }
+}
+function addExperimentalFeatures(enabledFeatures) {
+  enabledFeatures.forEach(function(flag) {
+    enabledExperimentalFeatures.add(flag);
+  });
+}
+function getExperimentalFeatures() {
+  return enabledExperimentalFeatures;
+}
+var UNKNOWN_FUNCTION = "?";
+function computeStackTrace(ex) {
+  var stack = [];
+  var stackProperty = tryToGetString(ex, "stack");
+  var exString = String(ex);
+  if (stackProperty && startsWith(stackProperty, exString)) {
+    stackProperty = stackProperty.slice(exString.length);
+  }
+  if (stackProperty) {
+    stackProperty.split("\n").forEach(function(line) {
+      var stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);
+      if (stackFrame) {
+        if (!stackFrame.func && stackFrame.line) {
+          stackFrame.func = UNKNOWN_FUNCTION;
+        }
+        stack.push(stackFrame);
+      }
+    });
+  }
+  return {
+    message: tryToGetString(ex, "message"),
+    name: tryToGetString(ex, "name"),
+    stack
+  };
+}
+var fileUrl = "((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)";
+var filePosition = "(?::(\\d+))";
+var CHROME_LINE_RE = new RegExp("^\\s*at (.*?) ?\\(".concat(fileUrl).concat(filePosition, "?").concat(filePosition, "?\\)?\\s*$"), "i");
+var CHROME_EVAL_RE = new RegExp("\\((\\S*)".concat(filePosition).concat(filePosition, "\\)"));
+function parseChromeLine(line) {
+  var parts = CHROME_LINE_RE.exec(line);
+  if (!parts) {
+    return;
+  }
+  var isNative = parts[2] && parts[2].indexOf("native") === 0;
+  var isEval = parts[2] && parts[2].indexOf("eval") === 0;
+  var submatch = CHROME_EVAL_RE.exec(parts[2]);
+  if (isEval && submatch) {
+    parts[2] = submatch[1];
+    parts[3] = submatch[2];
+    parts[4] = submatch[3];
+  }
+  return {
+    args: isNative ? [parts[2]] : [],
+    column: parts[4] ? +parts[4] : void 0,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: parts[3] ? +parts[3] : void 0,
+    url: !isNative ? parts[2] : void 0
+  };
+}
+var CHROME_ANONYMOUS_FUNCTION_RE = new RegExp("^\\s*at ?".concat(fileUrl).concat(filePosition, "?").concat(filePosition, "??\\s*$"), "i");
+function parseChromeAnonymousLine(line) {
+  var parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);
+  if (!parts) {
+    return;
+  }
+  return {
+    args: [],
+    column: parts[3] ? +parts[3] : void 0,
+    func: UNKNOWN_FUNCTION,
+    line: parts[2] ? +parts[2] : void 0,
+    url: parts[1]
+  };
+}
+var WINJS_LINE_RE = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+function parseWinLine(line) {
+  var parts = WINJS_LINE_RE.exec(line);
+  if (!parts) {
+    return;
+  }
+  return {
+    args: [],
+    column: parts[4] ? +parts[4] : void 0,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: +parts[3],
+    url: parts[2]
+  };
+}
+var GECKO_LINE_RE = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+var GECKO_EVAL_RE = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+function parseGeckoLine(line) {
+  var parts = GECKO_LINE_RE.exec(line);
+  if (!parts) {
+    return;
+  }
+  var isEval = parts[3] && parts[3].indexOf(" > eval") > -1;
+  var submatch = GECKO_EVAL_RE.exec(parts[3]);
+  if (isEval && submatch) {
+    parts[3] = submatch[1];
+    parts[4] = submatch[2];
+    parts[5] = void 0;
+  }
+  return {
+    args: parts[2] ? parts[2].split(",") : [],
+    column: parts[5] ? +parts[5] : void 0,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: parts[4] ? +parts[4] : void 0,
+    url: parts[3]
+  };
+}
+function tryToGetString(candidate, property) {
+  if (typeof candidate !== "object" || !candidate || !(property in candidate)) {
+    return void 0;
+  }
+  var value = candidate[property];
+  return typeof value === "string" ? value : void 0;
+}
+function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {
+  var stack = [{ url, column, line }];
+  var _a2 = tryToParseMessage(messageObj), name = _a2.name, message = _a2.message;
+  return {
+    name,
+    message,
+    stack
+  };
+}
+var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\s\S]*)$/;
+function tryToParseMessage(messageObj) {
+  var _a2;
+  var name;
+  var message;
+  if ({}.toString.call(messageObj) === "[object String]") {
+    _a2 = ERROR_TYPES_RE.exec(messageObj), name = _a2[1], message = _a2[2];
+  }
+  return { name, message };
+}
+function createHandlingStack() {
+  var internalFramesToSkip = 2;
+  var error = new Error();
+  var formattedStack;
+  if (!error.stack) {
+    try {
+      throw error;
+    } catch (e) {
+    }
+  }
+  callMonitored(function() {
+    var stackTrace = computeStackTrace(error);
+    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);
+    formattedStack = toStackTraceString(stackTrace);
+  });
+  return formattedStack;
+}
+function toStackTraceString(stack) {
+  var result = formatErrorMessage(stack);
+  stack.stack.forEach(function(frame) {
+    var func = frame.func === "?" ? "<anonymous>" : frame.func;
+    var args = frame.args && frame.args.length > 0 ? "(".concat(frame.args.join(", "), ")") : "";
+    var line = frame.line ? ":".concat(frame.line) : "";
+    var column = frame.line && frame.column ? ":".concat(frame.column) : "";
+    result += "\n  at ".concat(func).concat(args, " @ ").concat(frame.url).concat(line).concat(column);
+  });
+  return result;
+}
+function formatErrorMessage(stack) {
+  return "".concat(stack.name || "Error", ": ").concat(stack.message);
+}
+function instrumentMethod(targetPrototype, method, onPreCall, _a2) {
+  var _b = _a2 === void 0 ? {} : _a2, computeHandlingStack = _b.computeHandlingStack;
+  var original = targetPrototype[method];
+  if (typeof original !== "function") {
+    if (startsWith(method, "on")) {
+      original = noop;
+    } else {
+      return { stop: noop };
+    }
+  }
+  var stopped = false;
+  var instrumentation = function() {
+    if (stopped) {
+      return original.apply(this, arguments);
+    }
+    var parameters = arrayFrom(arguments);
+    var postCallCallback;
+    callMonitored(onPreCall, null, [
+      {
+        target: this,
+        parameters,
+        onPostCall: function(callback) {
+          postCallCallback = callback;
+        },
+        handlingStack: computeHandlingStack ? createHandlingStack() : void 0
+      }
+    ]);
+    var result = original.apply(this, parameters);
+    if (postCallCallback) {
+      callMonitored(postCallCallback, null, [result]);
+    }
+    return result;
+  };
+  targetPrototype[method] = instrumentation;
+  return {
+    stop: function() {
+      stopped = true;
+      if (targetPrototype[method] === instrumentation) {
+        targetPrototype[method] = original;
+      }
+    }
+  };
+}
+var SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;
+var JSON_PATH_ROOT_ELEMENT = "$";
+var KEY_DECORATION_LENGTH = 3;
+function sanitize(source, maxCharacterCount) {
+  if (maxCharacterCount === void 0) {
+    maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT;
+  }
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+  var containerQueue = [];
+  var visitedObjectsWithPath = /* @__PURE__ */ new WeakMap();
+  var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, void 0, containerQueue, visitedObjectsWithPath);
+  var serializedSanitizedData = JSON.stringify(sanitizedData);
+  var accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0;
+  if (accumulatedCharacterCount > maxCharacterCount) {
+    warnOverCharacterLimit(maxCharacterCount, "discarded", source);
+    return void 0;
+  }
+  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+    var containerToProcess = containerQueue.shift();
+    var separatorLength = 0;
+    if (Array.isArray(containerToProcess.source)) {
+      for (var key = 0; key < containerToProcess.source.length; key++) {
+        var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);
+        if (targetData !== void 0) {
+          accumulatedCharacterCount += JSON.stringify(targetData).length;
+        } else {
+          accumulatedCharacterCount += 4;
+        }
+        accumulatedCharacterCount += separatorLength;
+        separatorLength = 1;
+        if (accumulatedCharacterCount > maxCharacterCount) {
+          warnOverCharacterLimit(maxCharacterCount, "truncated", source);
+          break;
+        }
+        containerToProcess.target[key] = targetData;
+      }
+    } else {
+      for (var key in containerToProcess.source) {
+        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+          var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);
+          if (targetData !== void 0) {
+            accumulatedCharacterCount += JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;
+            separatorLength = 1;
+          }
+          if (accumulatedCharacterCount > maxCharacterCount) {
+            warnOverCharacterLimit(maxCharacterCount, "truncated", source);
+            break;
+          }
+          containerToProcess.target[key] = targetData;
+        }
+      }
+    }
+  }
+  restoreObjectPrototypeToJson();
+  restoreArrayPrototypeToJson();
+  return sanitizedData;
+}
+function sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {
+  var sourceToSanitize = tryToApplyToJSON(source);
+  if (!sourceToSanitize || typeof sourceToSanitize !== "object") {
+    return sanitizePrimitivesAndFunctions(sourceToSanitize);
+  }
+  var sanitizedSource = sanitizeObjects(sourceToSanitize);
+  if (sanitizedSource !== "[Object]" && sanitizedSource !== "[Array]" && sanitizedSource !== "[Error]") {
+    return sanitizedSource;
+  }
+  var sourceAsObject = source;
+  if (visitedObjectsWithPath.has(sourceAsObject)) {
+    return "[Reference seen at ".concat(visitedObjectsWithPath.get(sourceAsObject), "]");
+  }
+  var currentPath = key !== void 0 ? "".concat(parentPath, ".").concat(key) : parentPath;
+  var target = Array.isArray(sourceToSanitize) ? [] : {};
+  visitedObjectsWithPath.set(sourceAsObject, currentPath);
+  queue.push({ source: sourceToSanitize, target, path: currentPath });
+  return target;
+}
+function sanitizePrimitivesAndFunctions(value) {
+  if (typeof value === "bigint") {
+    return "[BigInt] ".concat(value.toString());
+  }
+  if (typeof value === "function") {
+    return "[Function] ".concat(value.name || "unknown");
+  }
+  if (typeof value === "symbol") {
+    return "[Symbol] ".concat(value.description || value.toString());
+  }
+  return value;
+}
+function sanitizeObjects(value) {
+  try {
+    if (value instanceof Event) {
+      return {
+        isTrusted: value.isTrusted
+      };
+    }
+    var result = Object.prototype.toString.call(value);
+    var match = result.match(/\[object (.*)\]/);
+    if (match && match[1]) {
+      return "[".concat(match[1], "]");
+    }
+  } catch (_a2) {
+  }
+  return "[Unserializable]";
+}
+function tryToApplyToJSON(value) {
+  var object = value;
+  if (object && typeof object.toJSON === "function") {
+    try {
+      return object.toJSON();
+    } catch (_a2) {
+    }
+  }
+  return value;
+}
+function warnOverCharacterLimit(maxCharacterCount, changeType, source) {
+  display.warn("The data provided has been ".concat(changeType, " as it is over the limit of ").concat(maxCharacterCount, " characters:"), source);
+}
+var NO_ERROR_STACK_PRESENT_MESSAGE = "No stack, consider using an instance of Error";
+function computeRawError(_a2) {
+  var stackTrace = _a2.stackTrace, originalError = _a2.originalError, handlingStack = _a2.handlingStack, startClocks = _a2.startClocks, nonErrorPrefix = _a2.nonErrorPrefix, source = _a2.source, handling = _a2.handling;
+  var isErrorInstance = originalError instanceof Error;
+  var message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);
+  var stack = hasUsableStack(isErrorInstance, stackTrace) ? toStackTraceString(stackTrace) : NO_ERROR_STACK_PRESENT_MESSAGE;
+  var causes = isErrorInstance ? flattenErrorCauses(originalError, source) : void 0;
+  var type = stackTrace ? stackTrace.name : void 0;
+  var fingerprint = tryToGetFingerprint(originalError);
+  return {
+    startClocks,
+    source,
+    handling,
+    handlingStack,
+    originalError,
+    type,
+    message,
+    stack,
+    causes,
+    fingerprint
+  };
+}
+function computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {
+  return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name) ? stackTrace.message : !isErrorInstance ? "".concat(nonErrorPrefix, " ").concat(jsonStringify(sanitize(originalError))) : "Empty message";
+}
+function hasUsableStack(isErrorInstance, stackTrace) {
+  if (stackTrace === void 0) {
+    return false;
+  }
+  if (isErrorInstance) {
+    return true;
+  }
+  return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== void 0);
+}
+function tryToGetFingerprint(originalError) {
+  return originalError instanceof Error && "dd_fingerprint" in originalError ? String(originalError.dd_fingerprint) : void 0;
+}
+function getFileFromStackTraceString(stack) {
+  var _a2;
+  return (_a2 = /@ (.+)/.exec(stack)) === null || _a2 === void 0 ? void 0 : _a2[1];
+}
+function flattenErrorCauses(error, parentSource) {
+  var currentError = error;
+  var causes = [];
+  while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && causes.length < 10) {
+    var stackTrace = computeStackTrace(currentError.cause);
+    causes.push({
+      message: currentError.cause.message,
+      source: parentSource,
+      type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,
+      stack: stackTrace && toStackTraceString(stackTrace)
+    });
+    currentError = currentError.cause;
+  }
+  return causes.length ? causes : void 0;
+}
+var ErrorSource = {
+  AGENT: "agent",
+  CONSOLE: "console",
+  CUSTOM: "custom",
+  LOGGER: "logger",
+  NETWORK: "network",
+  SOURCE: "source",
+  REPORT: "report"
+};
+function trackRuntimeError(errorObservable) {
+  var handleRuntimeError = function(stackTrace, originalError) {
+    var rawError = computeRawError({
+      stackTrace,
+      originalError,
+      startClocks: clocksNow(),
+      nonErrorPrefix: "Uncaught",
+      source: ErrorSource.SOURCE,
+      handling: "unhandled"
+    });
+    errorObservable.notify(rawError);
+  };
+  var stopInstrumentingOnError = instrumentOnError(handleRuntimeError).stop;
+  var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(handleRuntimeError).stop;
+  return {
+    stop: function() {
+      stopInstrumentingOnError();
+      stopInstrumentingOnUnhandledRejection();
+    }
+  };
+}
+function instrumentOnError(callback) {
+  return instrumentMethod(window, "onerror", function(_a2) {
+    var _b = _a2.parameters, messageObj = _b[0], url = _b[1], line = _b[2], column = _b[3], errorObj = _b[4];
+    var stackTrace;
+    if (errorObj instanceof Error) {
+      stackTrace = computeStackTrace(errorObj);
+    } else {
+      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column);
+    }
+    callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);
+  });
+}
+function instrumentUnhandledRejection(callback) {
+  return instrumentMethod(window, "onunhandledrejection", function(_a2) {
+    var e = _a2.parameters[0];
+    var reason = e.reason || "Empty reason";
+    var stack = computeStackTrace(reason);
+    callback(stack, reason);
+  });
+}
+function makePublicApi(stub) {
+  var publicApi = assign({
+    version: "5.23.3",
+    // This API method is intentionally not monitored, since the only thing executed is the
+    // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and
+    // we don't want to interfere with the user uncaught exceptions.
+    onReady: function(callback) {
+      callback();
+    }
+  }, stub);
+  Object.defineProperty(publicApi, "_setDebug", {
+    get: function() {
+      return setDebugMode;
+    },
+    enumerable: false
+  });
+  return publicApi;
+}
+function defineGlobal(global, name, api) {
+  var existingGlobalVariable = global[name];
+  if (existingGlobalVariable && !existingGlobalVariable.q && existingGlobalVariable.version) {
+    display.warn("SDK is loaded more than once. This is unsupported and might have unexpected behavior.");
+  }
+  global[name] = api;
+  if (existingGlobalVariable && existingGlobalVariable.q) {
+    existingGlobalVariable.q.forEach(function(fn) {
+      return catchUserErrors(fn, "onReady callback threw an error:")();
+    });
+  }
+}
+function displayAlreadyInitializedError(sdkName, initConfiguration) {
+  if (!initConfiguration.silentMultipleInit) {
+    display.error("".concat(sdkName, " is already initialized."));
+  }
+}
+function addEventListener(configuration, eventTarget, eventName, listener, options) {
+  return addEventListeners(configuration, eventTarget, [eventName], listener, options);
+}
+function addEventListeners(configuration, eventTarget, eventNames, listener, _a2) {
+  var _b = _a2 === void 0 ? {} : _a2, once = _b.once, capture = _b.capture, passive = _b.passive;
+  var listenerWithMonitor = monitor(function(event) {
+    if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {
+      return;
+    }
+    if (once) {
+      stop();
+    }
+    listener(event);
+  });
+  var options = passive ? { capture, passive } : capture;
+  var add = getZoneJsOriginalValue(eventTarget, "addEventListener");
+  eventNames.forEach(function(eventName) {
+    return add.call(eventTarget, eventName, listenerWithMonitor, options);
+  });
+  function stop() {
+    var remove = getZoneJsOriginalValue(eventTarget, "removeEventListener");
+    eventNames.forEach(function(eventName) {
+      return remove.call(eventTarget, eventName, listenerWithMonitor, options);
+    });
+  }
+  return {
+    stop
+  };
+}
+var RawReportType = {
+  intervention: "intervention",
+  deprecation: "deprecation",
+  cspViolation: "csp_violation"
+};
+function initReportObservable(configuration, apis) {
+  var observables = [];
+  if (includes(apis, RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable(configuration));
+  }
+  var reportTypes = apis.filter(function(api) {
+    return api !== RawReportType.cspViolation;
+  });
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes));
+  }
+  return mergeObservables.apply(void 0, observables);
+}
+function createReportObservable(reportTypes) {
+  return new Observable(function(observable) {
+    if (!window.ReportingObserver) {
+      return;
+    }
+    var handleReports = monitor(function(reports, _) {
+      return reports.forEach(function(report) {
+        observable.notify(buildRawReportFromReport(report));
+      });
+    });
+    var observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true
+    });
+    observer.observe();
+    return function() {
+      observer.disconnect();
+    };
+  });
+}
+function createCspViolationReportObservable(configuration) {
+  return new Observable(function(observable) {
+    var stop = addEventListener(configuration, document, "securitypolicyviolation", function(event) {
+      observable.notify(buildRawReportFromCspViolation(event));
+    }).stop;
+    return stop;
+  });
+}
+function buildRawReportFromReport(report) {
+  var type = report.type, body = report.body;
+  return {
+    type,
+    subtype: body.id,
+    message: "".concat(type, ": ").concat(body.message),
+    originalReport: report,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber)
+  };
+}
+function buildRawReportFromCspViolation(event) {
+  var type = RawReportType.cspViolation;
+  var message = "'".concat(event.blockedURI, "' blocked by '").concat(event.effectiveDirective, "' directive");
+  return {
+    type: RawReportType.cspViolation,
+    subtype: event.effectiveDirective,
+    message: "".concat(type, ": ").concat(message),
+    stack: buildStack(event.effectiveDirective, event.originalPolicy ? "".concat(message, ' of the policy "').concat(safeTruncate(event.originalPolicy, 100, "..."), '"') : "no policy", event.sourceFile, event.lineNumber, event.columnNumber),
+    originalReport: event
+  };
+}
+function buildStack(name, message, sourceFile, lineNumber, columnNumber) {
+  return sourceFile ? toStackTraceString({
+    name,
+    message,
+    stack: [
+      {
+        func: "?",
+        url: sourceFile,
+        line: lineNumber !== null && lineNumber !== void 0 ? lineNumber : void 0,
+        column: columnNumber !== null && columnNumber !== void 0 ? columnNumber : void 0
+      }
+    ]
+  }) : void 0;
+}
+function sendToExtension(type, payload) {
+  var callback = window.__ddBrowserSdkExtensionCallback;
+  if (callback) {
+    callback({ type, payload });
+  }
+}
+function getType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+function mergeInto(destination, source, circularReferenceChecker) {
+  if (circularReferenceChecker === void 0) {
+    circularReferenceChecker = createCircularReferenceChecker();
+  }
+  if (source === void 0) {
+    return destination;
+  }
+  if (typeof source !== "object" || source === null) {
+    return source;
+  } else if (source instanceof Date) {
+    return new Date(source.getTime());
+  } else if (source instanceof RegExp) {
+    var flags = source.flags || // old browsers compatibility
+    [
+      source.global ? "g" : "",
+      source.ignoreCase ? "i" : "",
+      source.multiline ? "m" : "",
+      source.sticky ? "y" : "",
+      source.unicode ? "u" : ""
+    ].join("");
+    return new RegExp(source.source, flags);
+  }
+  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
+    return void 0;
+  } else if (Array.isArray(source)) {
+    var merged_1 = Array.isArray(destination) ? destination : [];
+    for (var i = 0; i < source.length; ++i) {
+      merged_1[i] = mergeInto(merged_1[i], source[i], circularReferenceChecker);
+    }
+    return merged_1;
+  }
+  var merged = getType(destination) === "object" ? destination : {};
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);
+    }
+  }
+  return merged;
+}
+function deepClone(value) {
+  return mergeInto(void 0, value);
+}
+function combine() {
+  var sources = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    sources[_i] = arguments[_i];
+  }
+  var destination;
+  for (var _a2 = 0, sources_1 = sources; _a2 < sources_1.length; _a2++) {
+    var source = sources_1[_a2];
+    if (source === void 0 || source === null) {
+      continue;
+    }
+    destination = mergeInto(destination, source);
+  }
+  return destination;
+}
+function createCircularReferenceChecker() {
+  if (typeof WeakSet !== "undefined") {
+    var set_1 = /* @__PURE__ */ new WeakSet();
+    return {
+      hasAlreadyBeenSeen: function(value) {
+        var has = set_1.has(value);
+        if (!has) {
+          set_1.add(value);
+        }
+        return has;
+      }
+    };
+  }
+  var array = [];
+  return {
+    hasAlreadyBeenSeen: function(value) {
+      var has = array.indexOf(value) >= 0;
+      if (!has) {
+        array.push(value);
+      }
+      return has;
+    }
+  };
+}
+function getConnectivity() {
+  var _a2;
+  var navigator2 = window.navigator;
+  return {
+    status: navigator2.onLine ? "connected" : "not_connected",
+    interfaces: navigator2.connection && navigator2.connection.type ? [navigator2.connection.type] : void 0,
+    effective_type: (_a2 = navigator2.connection) === null || _a2 === void 0 ? void 0 : _a2.effectiveType
+  };
+}
+function removeDuplicates(array) {
+  var set = /* @__PURE__ */ new Set();
+  array.forEach(function(item) {
+    return set.add(item);
+  });
+  return arrayFrom(set);
+}
+function removeItem(array, item) {
+  var index = array.indexOf(item);
+  if (index >= 0) {
+    array.splice(index, 1);
+  }
+}
+var BUFFER_LIMIT = 500;
+function createBoundedBuffer() {
+  var buffer = [];
+  var add = function(callback) {
+    var length = buffer.push(callback);
+    if (length > BUFFER_LIMIT) {
+      buffer.splice(0, 1);
+    }
+  };
+  var remove = function(callback) {
+    removeItem(buffer, callback);
+  };
+  var drain = function(arg) {
+    buffer.forEach(function(callback) {
+      return callback(arg);
+    });
+    buffer.length = 0;
+  };
+  return {
+    add,
+    remove,
+    drain
+  };
+}
+var TelemetryType = {
+  log: "log",
+  configuration: "configuration",
+  usage: "usage"
+};
+var ALLOWED_FRAME_URLS = [
+  "https://www.datadoghq-browser-agent.com",
+  "https://www.datad0g-browser-agent.com",
+  "https://d3uc069fcn7uxw.cloudfront.net",
+  "https://d20xtzwzcl0ceb.cloudfront.net",
+  "http://localhost",
+  "<anonymous>"
+];
+var TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];
+var preStartTelemetryBuffer = createBoundedBuffer();
+var onRawTelemetryEventCollected = function(event) {
+  preStartTelemetryBuffer.add(function() {
+    return onRawTelemetryEventCollected(event);
+  });
+};
+function startTelemetry(telemetryService, configuration) {
+  var _a2;
+  var contextProvider;
+  var observable = new Observable();
+  var alreadySentEvents = /* @__PURE__ */ new Set();
+  var telemetryEnabled = !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);
+  var telemetryEnabledPerType = (_a2 = {}, _a2[TelemetryType.log] = telemetryEnabled, _a2[TelemetryType.configuration] = telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate), _a2[TelemetryType.usage] = telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate), _a2);
+  var runtimeEnvInfo = getRuntimeEnvInfo();
+  onRawTelemetryEventCollected = function(rawEvent) {
+    var stringifiedEvent = jsonStringify(rawEvent);
+    if (telemetryEnabledPerType[rawEvent.type] && alreadySentEvents.size < configuration.maxTelemetryEventsPerPage && !alreadySentEvents.has(stringifiedEvent)) {
+      var event_1 = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo);
+      observable.notify(event_1);
+      sendToExtension("telemetry", event_1);
+      alreadySentEvents.add(stringifiedEvent);
+    }
+  };
+  startMonitorErrorCollection(addTelemetryError);
+  function toTelemetryEvent(telemetryService2, event, runtimeEnvInfo2) {
+    return combine({
+      type: "telemetry",
+      date: timeStampNow(),
+      service: telemetryService2,
+      version: "5.23.3",
+      source: "browser",
+      _dd: {
+        format_version: 2
+      },
+      telemetry: combine(event, {
+        runtime_env: runtimeEnvInfo2,
+        connectivity: getConnectivity()
+      }),
+      experimental_features: arrayFrom(getExperimentalFeatures())
+    }, contextProvider !== void 0 ? contextProvider() : {});
+  }
+  return {
+    setContextProvider: function(provider) {
+      contextProvider = provider;
+    },
+    observable,
+    enabled: telemetryEnabled
+  };
+}
+function getRuntimeEnvInfo() {
+  return {
+    is_local_file: window.location.protocol === "file:",
+    is_worker: "WorkerGlobalScope" in self
+  };
+}
+function drainPreStartTelemetry() {
+  preStartTelemetryBuffer.drain();
+}
+function isTelemetryReplicationAllowed(configuration) {
+  return configuration.site === INTAKE_SITE_STAGING;
+}
+function addTelemetryDebug(message, context) {
+  displayIfDebugEnabled(ConsoleApiName.debug, message, context);
+  onRawTelemetryEventCollected(assign({
+    type: TelemetryType.log,
+    message,
+    status: "debug"
+  }, context));
+}
+function addTelemetryError(e, context) {
+  onRawTelemetryEventCollected(assign({
+    type: TelemetryType.log,
+    status: "error"
+  }, formatError(e), context));
+}
+function addTelemetryConfiguration(configuration) {
+  onRawTelemetryEventCollected({
+    type: TelemetryType.configuration,
+    configuration
+  });
+}
+function addTelemetryUsage(usage) {
+  onRawTelemetryEventCollected({
+    type: TelemetryType.usage,
+    usage
+  });
+}
+function formatError(e) {
+  if (e instanceof Error) {
+    var stackTrace = computeStackTrace(e);
+    return {
+      error: {
+        kind: stackTrace.name,
+        stack: toStackTraceString(scrubCustomerFrames(stackTrace))
+      },
+      message: stackTrace.message
+    };
+  }
+  return {
+    error: {
+      stack: NO_ERROR_STACK_PRESENT_MESSAGE
+    },
+    message: "".concat("Uncaught", " ").concat(jsonStringify(e))
+  };
+}
+function scrubCustomerFrames(stackTrace) {
+  stackTrace.stack = stackTrace.stack.filter(function(frame) {
+    return !frame.url || ALLOWED_FRAME_URLS.some(function(allowedFrameUrl) {
+      return startsWith(frame.url, allowedFrameUrl);
+    });
+  });
+  return stackTrace;
+}
+var END_OF_TIMES = Infinity;
+var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;
+function createValueHistory(_a2) {
+  var expireDelay = _a2.expireDelay, maxEntries = _a2.maxEntries;
+  var entries = [];
+  var clearOldValuesInterval = setInterval(function() {
+    return clearOldValues();
+  }, CLEAR_OLD_VALUES_INTERVAL);
+  function clearOldValues() {
+    var oldTimeThreshold = relativeNow() - expireDelay;
+    while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {
+      entries.pop();
+    }
+  }
+  function add(value, startTime) {
+    var entry = {
+      value,
+      startTime,
+      endTime: END_OF_TIMES,
+      remove: function() {
+        removeItem(entries, entry);
+      },
+      close: function(endTime) {
+        entry.endTime = endTime;
+      }
+    };
+    if (maxEntries && entries.length >= maxEntries) {
+      entries.pop();
+    }
+    entries.unshift(entry);
+    return entry;
+  }
+  function find2(startTime, options) {
+    if (startTime === void 0) {
+      startTime = END_OF_TIMES;
+    }
+    if (options === void 0) {
+      options = { returnInactive: false };
+    }
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+      var entry = entries_1[_i];
+      if (entry.startTime <= startTime) {
+        if (options.returnInactive || startTime <= entry.endTime) {
+          return entry.value;
+        }
+        break;
+      }
+    }
+  }
+  function closeActive(endTime) {
+    var latestEntry = entries[0];
+    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+      latestEntry.close(endTime);
+    }
+  }
+  function findAll(startTime, duration) {
+    if (startTime === void 0) {
+      startTime = END_OF_TIMES;
+    }
+    if (duration === void 0) {
+      duration = 0;
+    }
+    var endTime = addDuration(startTime, duration);
+    return entries.filter(function(entry) {
+      return entry.startTime <= endTime && startTime <= entry.endTime;
+    }).map(function(entry) {
+      return entry.value;
+    });
+  }
+  function reset() {
+    entries = [];
+  }
+  function stop() {
+    clearInterval(clearOldValuesInterval);
+  }
+  return { add, find: find2, closeActive, findAll, reset, stop };
+}
+var VISIBILITY_CHECK_DELAY = ONE_MINUTE;
+var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;
+function startSessionManager(configuration, productKey, computeSessionState2, trackingConsentState) {
+  var renewObservable = new Observable();
+  var expireObservable = new Observable();
+  var sessionStore = startSessionStore(configuration.sessionStoreStrategyType, productKey, computeSessionState2);
+  var sessionContextHistory = createValueHistory({
+    expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY
+  });
+  sessionStore.renewObservable.subscribe(function() {
+    sessionContextHistory.add(buildSessionContext(), relativeNow());
+    renewObservable.notify();
+  });
+  sessionStore.expireObservable.subscribe(function() {
+    expireObservable.notify();
+    sessionContextHistory.closeActive(relativeNow());
+  });
+  sessionStore.expandOrRenewSession();
+  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);
+  trackingConsentState.observable.subscribe(function() {
+    if (trackingConsentState.isGranted()) {
+      sessionStore.expandOrRenewSession();
+    } else {
+      sessionStore.expire();
+    }
+  });
+  trackActivity(configuration, function() {
+    if (trackingConsentState.isGranted()) {
+      sessionStore.expandOrRenewSession();
+    }
+  });
+  trackVisibility(configuration, function() {
+    return sessionStore.expandSession();
+  });
+  trackResume(configuration, function() {
+    return sessionStore.restartSession();
+  });
+  function buildSessionContext() {
+    return {
+      id: sessionStore.getSession().id,
+      trackingType: sessionStore.getSession()[productKey],
+      isReplayForced: !!sessionStore.getSession().forcedReplay
+    };
+  }
+  return {
+    findSession: function(startTime, options) {
+      return sessionContextHistory.find(startTime, options);
+    },
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,
+    expire: sessionStore.expire,
+    updateSessionState: sessionStore.updateSessionState
+  };
+}
+function trackActivity(configuration, expandOrRenewSession) {
+  addEventListeners(configuration, window, [
+    "click",
+    "touchstart",
+    "keydown",
+    "scroll"
+    /* DOM_EVENT.SCROLL */
+  ], expandOrRenewSession, { capture: true, passive: true }).stop;
+}
+function trackVisibility(configuration, expandSession) {
+  var expandSessionWhenVisible = function() {
+    if (document.visibilityState === "visible") {
+      expandSession();
+    }
+  };
+  addEventListener(configuration, document, "visibilitychange", expandSessionWhenVisible).stop;
+  setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
+}
+function trackResume(configuration, cb) {
+  addEventListener(configuration, window, "resume", cb, { capture: true }).stop;
+}
+function isServerError(status) {
+  return status >= 500;
+}
+function tryToClone(response) {
+  try {
+    return response.clone();
+  } catch (e) {
+    return;
+  }
+}
+var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;
+var MAX_ONGOING_REQUESTS = 32;
+var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;
+var MAX_BACKOFF_TIME = ONE_MINUTE;
+var INITIAL_BACKOFF_TIME = ONE_SECOND;
+function sendWithRetryStrategy(payload, state, sendStrategy, trackType, reportError) {
+  if (state.transportStatus === 0 && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) {
+    send(payload, state, sendStrategy, {
+      onSuccess: function() {
+        return retryQueuedPayloads(0, state, sendStrategy, trackType, reportError);
+      },
+      onFailure: function() {
+        state.queuedPayloads.enqueue(payload);
+        scheduleRetry(state, sendStrategy, trackType, reportError);
+      }
+    });
+  } else {
+    state.queuedPayloads.enqueue(payload);
+  }
+}
+function scheduleRetry(state, sendStrategy, trackType, reportError) {
+  if (state.transportStatus !== 2) {
+    return;
+  }
+  setTimeout(function() {
+    var payload = state.queuedPayloads.first();
+    send(payload, state, sendStrategy, {
+      onSuccess: function() {
+        state.queuedPayloads.dequeue();
+        state.currentBackoffTime = INITIAL_BACKOFF_TIME;
+        retryQueuedPayloads(1, state, sendStrategy, trackType, reportError);
+      },
+      onFailure: function() {
+        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);
+        scheduleRetry(state, sendStrategy, trackType, reportError);
+      }
+    });
+  }, state.currentBackoffTime);
+}
+function send(payload, state, sendStrategy, _a2) {
+  var onSuccess = _a2.onSuccess, onFailure = _a2.onFailure;
+  state.bandwidthMonitor.add(payload);
+  sendStrategy(payload, function(response) {
+    state.bandwidthMonitor.remove(payload);
+    if (!shouldRetryRequest(response)) {
+      state.transportStatus = 0;
+      onSuccess();
+    } else {
+      state.transportStatus = state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 : 2;
+      payload.retry = {
+        count: payload.retry ? payload.retry.count + 1 : 1,
+        lastFailureStatus: response.status
+      };
+      onFailure();
+    }
+  });
+}
+function retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError) {
+  if (reason === 0 && state.queuedPayloads.isFull() && !state.queueFullReported) {
+    reportError({
+      message: "Reached max ".concat(trackType, " events size queued for upload: ").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, "MiB"),
+      source: ErrorSource.AGENT,
+      startClocks: clocksNow()
+    });
+    state.queueFullReported = true;
+  }
+  var previousQueue = state.queuedPayloads;
+  state.queuedPayloads = newPayloadQueue();
+  while (previousQueue.size() > 0) {
+    sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, trackType, reportError);
+  }
+}
+function shouldRetryRequest(response) {
+  return response.type !== "opaque" && (response.status === 0 && !navigator.onLine || response.status === 408 || response.status === 429 || isServerError(response.status));
+}
+function newRetryState() {
+  return {
+    transportStatus: 0,
+    currentBackoffTime: INITIAL_BACKOFF_TIME,
+    bandwidthMonitor: newBandwidthMonitor(),
+    queuedPayloads: newPayloadQueue(),
+    queueFullReported: false
+  };
+}
+function newPayloadQueue() {
+  var queue = [];
+  return {
+    bytesCount: 0,
+    enqueue: function(payload) {
+      if (this.isFull()) {
+        return;
+      }
+      queue.push(payload);
+      this.bytesCount += payload.bytesCount;
+    },
+    first: function() {
+      return queue[0];
+    },
+    dequeue: function() {
+      var payload = queue.shift();
+      if (payload) {
+        this.bytesCount -= payload.bytesCount;
+      }
+      return payload;
+    },
+    size: function() {
+      return queue.length;
+    },
+    isFull: function() {
+      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;
+    }
+  };
+}
+function newBandwidthMonitor() {
+  return {
+    ongoingRequestCount: 0,
+    ongoingByteCount: 0,
+    canHandle: function(payload) {
+      return this.ongoingRequestCount === 0 || this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT && this.ongoingRequestCount < MAX_ONGOING_REQUESTS;
+    },
+    add: function(payload) {
+      this.ongoingRequestCount += 1;
+      this.ongoingByteCount += payload.bytesCount;
+    },
+    remove: function(payload) {
+      this.ongoingRequestCount -= 1;
+      this.ongoingByteCount -= payload.bytesCount;
+    }
+  };
+}
+function createHttpRequest(configuration, endpointBuilder, bytesLimit, reportError) {
+  var retryState = newRetryState();
+  var sendStrategyForRetry = function(payload, onResponse) {
+    return fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse);
+  };
+  return {
+    send: function(payload) {
+      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.trackType, reportError);
+    },
+    /**
+     * Since fetch keepalive behaves like regular fetch on Firefox,
+     * keep using sendBeaconStrategy on exit
+     */
+    sendOnExit: function(payload) {
+      sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload);
+    }
+  };
+}
+function sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload) {
+  var canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;
+  if (canUseBeacon) {
+    try {
+      var beaconUrl = endpointBuilder.build("beacon", payload);
+      var isQueued = navigator.sendBeacon(beaconUrl, payload.data);
+      if (isQueued) {
+        return;
+      }
+    } catch (e) {
+      reportBeaconError(e);
+    }
+  }
+  var xhrUrl = endpointBuilder.build("xhr", payload);
+  sendXHR(configuration, xhrUrl, payload.data);
+}
+var hasReportedBeaconError = false;
+function reportBeaconError(e) {
+  if (!hasReportedBeaconError) {
+    hasReportedBeaconError = true;
+    addTelemetryError(e);
+  }
+}
+function fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse) {
+  var canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;
+  if (canUseKeepAlive) {
+    var fetchUrl = endpointBuilder.build("fetch", payload);
+    fetch(fetchUrl, { method: "POST", body: payload.data, keepalive: true, mode: "cors" }).then(monitor(function(response) {
+      return onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type });
+    }), monitor(function() {
+      var xhrUrl2 = endpointBuilder.build("xhr", payload);
+      sendXHR(configuration, xhrUrl2, payload.data, onResponse);
+    }));
+  } else {
+    var xhrUrl = endpointBuilder.build("xhr", payload);
+    sendXHR(configuration, xhrUrl, payload.data, onResponse);
+  }
+}
+function isKeepAliveSupported() {
+  try {
+    return window.Request && "keepalive" in new Request("http://a");
+  } catch (_a2) {
+    return false;
+  }
+}
+function sendXHR(configuration, url, data, onResponse) {
+  var request = new XMLHttpRequest();
+  request.open("POST", url, true);
+  if (data instanceof Blob) {
+    request.setRequestHeader("Content-Type", data.type);
+  }
+  addEventListener(configuration, request, "loadend", function() {
+    onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: request.status });
+  }, {
+    // prevent multiple onResponse callbacks
+    // if the xhr instance is reused by a third party
+    once: true
+  });
+  request.send(data);
+}
+function getEventBridge() {
+  var eventBridgeGlobal = getEventBridgeGlobal();
+  if (!eventBridgeGlobal) {
+    return;
+  }
+  return {
+    getCapabilities: function() {
+      var _a2;
+      return JSON.parse(((_a2 = eventBridgeGlobal.getCapabilities) === null || _a2 === void 0 ? void 0 : _a2.call(eventBridgeGlobal)) || "[]");
+    },
+    getPrivacyLevel: function() {
+      var _a2;
+      return (_a2 = eventBridgeGlobal.getPrivacyLevel) === null || _a2 === void 0 ? void 0 : _a2.call(eventBridgeGlobal);
+    },
+    getAllowedWebViewHosts: function() {
+      return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());
+    },
+    send: function(eventType, event, viewId) {
+      var view = viewId ? { id: viewId } : void 0;
+      eventBridgeGlobal.send(JSON.stringify({ eventType, event, view }));
+    }
+  };
+}
+function canUseEventBridge(currentHost) {
+  var _a2;
+  if (currentHost === void 0) {
+    currentHost = (_a2 = getGlobalObject().location) === null || _a2 === void 0 ? void 0 : _a2.hostname;
+  }
+  var bridge = getEventBridge();
+  return !!bridge && bridge.getAllowedWebViewHosts().some(function(allowedHost) {
+    return currentHost === allowedHost || endsWith(currentHost, ".".concat(allowedHost));
+  });
+}
+function getEventBridgeGlobal() {
+  return getGlobalObject().DatadogEventBridge;
+}
+var PageExitReason = {
+  HIDDEN: "visibility_hidden",
+  UNLOADING: "before_unload",
+  PAGEHIDE: "page_hide",
+  FROZEN: "page_frozen"
+};
+function createPageExitObservable(configuration) {
+  return new Observable(function(observable) {
+    var stopListeners = addEventListeners(configuration, window, [
+      "visibilitychange",
+      "freeze"
+      /* DOM_EVENT.FREEZE */
+    ], function(event) {
+      if (event.type === "visibilitychange" && document.visibilityState === "hidden") {
+        observable.notify({ reason: PageExitReason.HIDDEN });
+      } else if (event.type === "freeze") {
+        observable.notify({ reason: PageExitReason.FROZEN });
+      }
+    }, { capture: true }).stop;
+    var stopBeforeUnloadListener = addEventListener(configuration, window, "beforeunload", function() {
+      observable.notify({ reason: PageExitReason.UNLOADING });
+    }).stop;
+    return function() {
+      stopListeners();
+      stopBeforeUnloadListener();
+    };
+  });
+}
+function isPageExitReason(reason) {
+  return includes(objectValues(PageExitReason), reason);
+}
+function createBatch(_a2) {
+  var encoder = _a2.encoder, request = _a2.request, flushController = _a2.flushController, messageBytesLimit = _a2.messageBytesLimit;
+  var upsertBuffer = {};
+  var flushSubscription = flushController.flushObservable.subscribe(function(event) {
+    return flush(event);
+  });
+  function push(serializedMessage, estimatedMessageBytesCount, key) {
+    flushController.notifyBeforeAddMessage(estimatedMessageBytesCount);
+    if (key !== void 0) {
+      upsertBuffer[key] = serializedMessage;
+      flushController.notifyAfterAddMessage();
+    } else {
+      encoder.write(encoder.isEmpty ? serializedMessage : "\n".concat(serializedMessage), function(realMessageBytesCount) {
+        flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount);
+      });
+    }
+  }
+  function hasMessageFor(key) {
+    return key !== void 0 && upsertBuffer[key] !== void 0;
+  }
+  function remove(key) {
+    var removedMessage = upsertBuffer[key];
+    delete upsertBuffer[key];
+    var messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage);
+    flushController.notifyAfterRemoveMessage(messageBytesCount);
+  }
+  function addOrUpdate(message, key) {
+    var serializedMessage = jsonStringify(message);
+    var estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage);
+    if (estimatedMessageBytesCount >= messageBytesLimit) {
+      display.warn("Discarded a message whose size was bigger than the maximum allowed size ".concat(messageBytesLimit, "KB. ").concat(MORE_DETAILS, " ").concat(DOCS_TROUBLESHOOTING, "/#technical-limitations"));
+      return;
+    }
+    if (hasMessageFor(key)) {
+      remove(key);
+    }
+    push(serializedMessage, estimatedMessageBytesCount, key);
+  }
+  function flush(event) {
+    var upsertMessages = objectValues(upsertBuffer).join("\n");
+    upsertBuffer = {};
+    var isPageExit = isPageExitReason(event.reason);
+    var send2 = isPageExit ? request.sendOnExit : request.send;
+    if (isPageExit && // Note: checking that the encoder is async is not strictly needed, but it's an optimization:
+    // if the encoder is async we need to send two requests in some cases (one for encoded data
+    // and the other for non-encoded data). But if it's not async, we don't have to worry about
+    // it and always send a single request.
+    encoder.isAsync) {
+      var encoderResult = encoder.finishSync();
+      if (encoderResult.outputBytesCount) {
+        send2(formatPayloadFromEncoder(encoderResult));
+      }
+      var pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join("\n");
+      if (pendingMessages) {
+        send2({
+          data: pendingMessages,
+          bytesCount: computeBytesCount(pendingMessages)
+        });
+      }
+    } else {
+      if (upsertMessages) {
+        encoder.write(encoder.isEmpty ? upsertMessages : "\n".concat(upsertMessages));
+      }
+      encoder.finish(function(encoderResult2) {
+        send2(formatPayloadFromEncoder(encoderResult2));
+      });
+    }
+  }
+  return {
+    flushController,
+    add: addOrUpdate,
+    upsert: addOrUpdate,
+    stop: flushSubscription.unsubscribe
+  };
+}
+function formatPayloadFromEncoder(encoderResult) {
+  var data;
+  if (typeof encoderResult.output === "string") {
+    data = encoderResult.output;
+  } else {
+    data = new Blob([encoderResult.output], {
+      // This will set the 'Content-Type: text/plain' header. Reasoning:
+      // * The intake rejects the request if there is no content type.
+      // * The browser will issue CORS preflight requests if we set it to 'application/json', which
+      // could induce higher intake load (and maybe has other impacts).
+      // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by
+      // new lines.
+      type: "text/plain"
+    });
+  }
+  return {
+    data,
+    bytesCount: encoderResult.outputBytesCount,
+    encoding: encoderResult.encoding
+  };
+}
+function createFlushController(_a2) {
+  var messagesLimit = _a2.messagesLimit, bytesLimit = _a2.bytesLimit, durationLimit = _a2.durationLimit, pageExitObservable = _a2.pageExitObservable, sessionExpireObservable = _a2.sessionExpireObservable;
+  var pageExitSubscription = pageExitObservable.subscribe(function(event) {
+    return flush(event.reason);
+  });
+  var sessionExpireSubscription = sessionExpireObservable.subscribe(function() {
+    return flush("session_expire");
+  });
+  var flushObservable = new Observable(function() {
+    return function() {
+      pageExitSubscription.unsubscribe();
+      sessionExpireSubscription.unsubscribe();
+    };
+  });
+  var currentBytesCount = 0;
+  var currentMessagesCount = 0;
+  function flush(flushReason) {
+    if (currentMessagesCount === 0) {
+      return;
+    }
+    var messagesCount = currentMessagesCount;
+    var bytesCount = currentBytesCount;
+    currentMessagesCount = 0;
+    currentBytesCount = 0;
+    cancelDurationLimitTimeout();
+    flushObservable.notify({
+      reason: flushReason,
+      messagesCount,
+      bytesCount
+    });
+  }
+  var durationLimitTimeoutId;
+  function scheduleDurationLimitTimeout() {
+    if (durationLimitTimeoutId === void 0) {
+      durationLimitTimeoutId = setTimeout(function() {
+        flush("duration_limit");
+      }, durationLimit);
+    }
+  }
+  function cancelDurationLimitTimeout() {
+    clearTimeout(durationLimitTimeoutId);
+    durationLimitTimeoutId = void 0;
+  }
+  return {
+    flushObservable,
+    get messagesCount() {
+      return currentMessagesCount;
+    },
+    /**
+     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.
+     *
+     * This function needs to be called synchronously, right before adding the message, so no flush
+     * event can happen after `notifyBeforeAddMessage` and before adding the message.
+     *
+     * @param estimatedMessageBytesCount: an estimation of the message bytes count once it is
+     * actually added.
+     */
+    notifyBeforeAddMessage: function(estimatedMessageBytesCount) {
+      if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {
+        flush("bytes_limit");
+      }
+      currentMessagesCount += 1;
+      currentBytesCount += estimatedMessageBytesCount;
+      scheduleDurationLimitTimeout();
+    },
+    /**
+     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.
+     *
+     * This function can be called asynchronously after the message was added, but in this case it
+     * should not be called if a flush event occurred in between.
+     *
+     * @param messageBytesCountDiff: the difference between the estimated message bytes count and
+     * its actual bytes count once added to the pool.
+     */
+    notifyAfterAddMessage: function(messageBytesCountDiff) {
+      if (messageBytesCountDiff === void 0) {
+        messageBytesCountDiff = 0;
+      }
+      currentBytesCount += messageBytesCountDiff;
+      if (currentMessagesCount >= messagesLimit) {
+        flush("messages_limit");
+      } else if (currentBytesCount >= bytesLimit) {
+        flush("bytes_limit");
+      }
+    },
+    /**
+     * Notifies that a message was removed from a pool of pending messages waiting to be flushed.
+     *
+     * This function needs to be called synchronously, right after removing the message, so no flush
+     * event can happen after removing the message and before `notifyAfterRemoveMessage`.
+     *
+     * @param messageBytesCount: the message bytes count that was added to the pool. Should
+     * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and
+     * `notifyAfterAddMessage`.
+     */
+    notifyAfterRemoveMessage: function(messageBytesCount) {
+      currentBytesCount -= messageBytesCount;
+      currentMessagesCount -= 1;
+      if (currentMessagesCount === 0) {
+        cancelDurationLimitTimeout();
+      }
+    }
+  };
+}
+function startBatchWithReplica(configuration, primary, replica, reportError, pageExitObservable, sessionExpireObservable, batchFactoryImp) {
+  if (batchFactoryImp === void 0) {
+    batchFactoryImp = createBatch;
+  }
+  var primaryBatch = createBatchFromConfig(configuration, primary);
+  var replicaBatch = replica && createBatchFromConfig(configuration, replica);
+  function createBatchFromConfig(configuration2, _a2) {
+    var endpoint = _a2.endpoint, encoder = _a2.encoder;
+    return batchFactoryImp({
+      encoder,
+      request: createHttpRequest(configuration2, endpoint, configuration2.batchBytesLimit, reportError),
+      flushController: createFlushController({
+        messagesLimit: configuration2.batchMessagesLimit,
+        bytesLimit: configuration2.batchBytesLimit,
+        durationLimit: configuration2.flushTimeout,
+        pageExitObservable,
+        sessionExpireObservable
+      }),
+      messageBytesLimit: configuration2.messageBytesLimit
+    });
+  }
+  return {
+    flushObservable: primaryBatch.flushController.flushObservable,
+    add: function(message, replicated) {
+      if (replicated === void 0) {
+        replicated = true;
+      }
+      primaryBatch.add(message);
+      if (replicaBatch && replicated) {
+        replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message);
+      }
+    },
+    upsert: function(message, key) {
+      primaryBatch.upsert(message, key);
+      if (replicaBatch) {
+        replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key);
+      }
+    },
+    stop: function() {
+      primaryBatch.stop();
+      if (replicaBatch) {
+        replicaBatch.stop();
+      }
+    }
+  };
+}
+function createIdentityEncoder() {
+  var output = "";
+  var outputBytesCount = 0;
+  return {
+    isAsync: false,
+    get isEmpty() {
+      return !output;
+    },
+    write: function(data, callback) {
+      var additionalEncodedBytesCount = computeBytesCount(data);
+      outputBytesCount += additionalEncodedBytesCount;
+      output += data;
+      if (callback) {
+        callback(additionalEncodedBytesCount);
+      }
+    },
+    finish: function(callback) {
+      callback(this.finishSync());
+    },
+    finishSync: function() {
+      var result = {
+        output,
+        outputBytesCount,
+        rawBytesCount: outputBytesCount,
+        pendingData: ""
+      };
+      output = "";
+      outputBytesCount = 0;
+      return result;
+    },
+    estimateEncodedBytesCount: function(data) {
+      return data.length;
+    }
+  };
+}
+var AbstractLifeCycle = (
+  /** @class */
+  function() {
+    function AbstractLifeCycle2() {
+      this.callbacks = {};
+    }
+    AbstractLifeCycle2.prototype.notify = function(eventType, data) {
+      var eventCallbacks = this.callbacks[eventType];
+      if (eventCallbacks) {
+        eventCallbacks.forEach(function(callback) {
+          return callback(data);
+        });
+      }
+    };
+    AbstractLifeCycle2.prototype.subscribe = function(eventType, callback) {
+      var _this = this;
+      if (!this.callbacks[eventType]) {
+        this.callbacks[eventType] = [];
+      }
+      this.callbacks[eventType].push(callback);
+      return {
+        unsubscribe: function() {
+          _this.callbacks[eventType] = _this.callbacks[eventType].filter(function(other) {
+            return callback !== other;
+          });
+        }
+      };
+    };
+    return AbstractLifeCycle2;
+  }()
+);
+function createEventRateLimiter(eventType, limit, onLimitReached) {
+  var eventCount = 0;
+  var allowNextEvent = false;
+  return {
+    isLimitReached: function() {
+      if (eventCount === 0) {
+        setTimeout(function() {
+          eventCount = 0;
+        }, ONE_MINUTE);
+      }
+      eventCount += 1;
+      if (eventCount <= limit || allowNextEvent) {
+        allowNextEvent = false;
+        return false;
+      }
+      if (eventCount === limit + 1) {
+        allowNextEvent = true;
+        try {
+          onLimitReached({
+            message: "Reached max number of ".concat(eventType, "s by minute: ").concat(limit),
+            source: ErrorSource.AGENT,
+            startClocks: clocksNow()
+          });
+        } finally {
+          allowNextEvent = false;
+        }
+      }
+      return true;
+    }
+  };
+}
+var xhrObservable;
+var xhrContexts = /* @__PURE__ */ new WeakMap();
+function initXhrObservable(configuration) {
+  if (!xhrObservable) {
+    xhrObservable = createXhrObservable(configuration);
+  }
+  return xhrObservable;
+}
+function createXhrObservable(configuration) {
+  return new Observable(function(observable) {
+    var stopInstrumentingStart = instrumentMethod(XMLHttpRequest.prototype, "open", openXhr).stop;
+    var stopInstrumentingSend = instrumentMethod(XMLHttpRequest.prototype, "send", function(call) {
+      sendXhr(call, configuration, observable);
+    }, { computeHandlingStack: true }).stop;
+    var stopInstrumentingAbort = instrumentMethod(XMLHttpRequest.prototype, "abort", abortXhr).stop;
+    return function() {
+      stopInstrumentingStart();
+      stopInstrumentingSend();
+      stopInstrumentingAbort();
+    };
+  });
+}
+function openXhr(_a2) {
+  var xhr = _a2.target, _b = _a2.parameters, method = _b[0], url = _b[1];
+  xhrContexts.set(xhr, {
+    state: "open",
+    method: String(method).toUpperCase(),
+    url: normalizeUrl(String(url))
+  });
+}
+function sendXhr(_a2, configuration, observable) {
+  var xhr = _a2.target, handlingStack = _a2.handlingStack;
+  var context = xhrContexts.get(xhr);
+  if (!context) {
+    return;
+  }
+  var startContext = context;
+  startContext.state = "start";
+  startContext.startClocks = clocksNow();
+  startContext.isAborted = false;
+  startContext.xhr = xhr;
+  startContext.handlingStack = handlingStack;
+  var hasBeenReported = false;
+  var stopInstrumentingOnReadyStateChange = instrumentMethod(xhr, "onreadystatechange", function() {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      onEnd();
+    }
+  }).stop;
+  var onEnd = function() {
+    unsubscribeLoadEndListener();
+    stopInstrumentingOnReadyStateChange();
+    if (hasBeenReported) {
+      return;
+    }
+    hasBeenReported = true;
+    var completeContext = context;
+    completeContext.state = "complete";
+    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());
+    completeContext.status = xhr.status;
+    observable.notify(shallowClone(completeContext));
+  };
+  var unsubscribeLoadEndListener = addEventListener(configuration, xhr, "loadend", onEnd).stop;
+  observable.notify(startContext);
+}
+function abortXhr(_a2) {
+  var xhr = _a2.target;
+  var context = xhrContexts.get(xhr);
+  if (context) {
+    context.isAborted = true;
+  }
+}
+var fetchObservable;
+function initFetchObservable() {
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable();
+  }
+  return fetchObservable;
+}
+function createFetchObservable() {
+  return new Observable(function(observable) {
+    if (!window.fetch) {
+      return;
+    }
+    var stop = instrumentMethod(window, "fetch", function(call) {
+      return beforeSend(call, observable);
+    }, {
+      computeHandlingStack: true
+    }).stop;
+    return stop;
+  });
+}
+function beforeSend(_a2, observable) {
+  var parameters = _a2.parameters, onPostCall = _a2.onPostCall, handlingStack = _a2.handlingStack;
+  var input = parameters[0], init = parameters[1];
+  var methodFromParams = init && init.method;
+  if (methodFromParams === void 0 && input instanceof Request) {
+    methodFromParams = input.method;
+  }
+  var method = methodFromParams !== void 0 ? String(methodFromParams).toUpperCase() : "GET";
+  var url = input instanceof Request ? input.url : normalizeUrl(String(input));
+  var startClocks = clocksNow();
+  var context = {
+    state: "start",
+    init,
+    input,
+    method,
+    startClocks,
+    url,
+    handlingStack
+  };
+  observable.notify(context);
+  parameters[0] = context.input;
+  parameters[1] = context.init;
+  onPostCall(function(responsePromise) {
+    return afterSend(observable, responsePromise, context);
+  });
+}
+function afterSend(observable, responsePromise, startContext) {
+  var context = startContext;
+  function reportFetch(partialContext) {
+    context.state = "resolve";
+    assign(context, partialContext);
+    observable.notify(context);
+  }
+  responsePromise.then(monitor(function(response) {
+    reportFetch({
+      response,
+      responseType: response.type,
+      status: response.status,
+      isAborted: false
+    });
+  }), monitor(function(error) {
+    var _a2, _b;
+    reportFetch({
+      status: 0,
+      isAborted: ((_b = (_a2 = context.init) === null || _a2 === void 0 ? void 0 : _a2.signal) === null || _b === void 0 ? void 0 : _b.aborted) || error instanceof DOMException && error.code === DOMException.ABORT_ERR,
+      error
+    });
+  }));
+}
+var consoleObservablesByApi = {};
+function initConsoleObservable(apis) {
+  var consoleObservables = apis.map(function(api) {
+    if (!consoleObservablesByApi[api]) {
+      consoleObservablesByApi[api] = createConsoleObservable(api);
+    }
+    return consoleObservablesByApi[api];
+  });
+  return mergeObservables.apply(void 0, consoleObservables);
+}
+function createConsoleObservable(api) {
+  return new Observable(function(observable) {
+    var originalConsoleApi = globalConsole[api];
+    globalConsole[api] = function() {
+      var params = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        params[_i] = arguments[_i];
+      }
+      originalConsoleApi.apply(console, params);
+      var handlingStack = createHandlingStack();
+      callMonitored(function() {
+        observable.notify(buildConsoleLog(params, api, handlingStack));
+      });
+    };
+    return function() {
+      globalConsole[api] = originalConsoleApi;
+    };
+  });
+}
+function buildConsoleLog(params, api, handlingStack) {
+  var message = params.map(function(param) {
+    return formatConsoleParameters(param);
+  }).join(" ");
+  var stack;
+  var fingerprint;
+  var causes;
+  if (api === ConsoleApiName.error) {
+    var firstErrorParam = find(params, function(param) {
+      return param instanceof Error;
+    });
+    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : void 0;
+    fingerprint = tryToGetFingerprint(firstErrorParam);
+    causes = firstErrorParam ? flattenErrorCauses(firstErrorParam, "console") : void 0;
+  }
+  return {
+    api,
+    message,
+    stack,
+    handlingStack,
+    fingerprint,
+    causes
+  };
+}
+function formatConsoleParameters(param) {
+  if (typeof param === "string") {
+    return sanitize(param);
+  }
+  if (param instanceof Error) {
+    return formatErrorMessage(computeStackTrace(param));
+  }
+  return jsonStringify(sanitize(param), void 0, 2);
+}
+function createContextManager(customerDataTracker) {
+  var context = {};
+  var changeObservable = new Observable();
+  var contextManager = {
+    getContext: function() {
+      return deepClone(context);
+    },
+    setContext: function(newContext) {
+      if (getType(newContext) === "object") {
+        context = sanitize(newContext);
+        customerDataTracker.updateCustomerData(context);
+      } else {
+        contextManager.clearContext();
+      }
+      changeObservable.notify();
+    },
+    setContextProperty: function(key, property) {
+      context[key] = sanitize(property);
+      customerDataTracker.updateCustomerData(context);
+      changeObservable.notify();
+    },
+    removeContextProperty: function(key) {
+      delete context[key];
+      customerDataTracker.updateCustomerData(context);
+      changeObservable.notify();
+    },
+    clearContext: function() {
+      context = {};
+      customerDataTracker.resetCustomerData();
+      changeObservable.notify();
+    },
+    changeObservable
+  };
+  return contextManager;
+}
+var CONTEXT_STORE_KEY_PREFIX = "_dd_c";
+var storageListeners = [];
+function storeContextManager(configuration, contextManager, productKey, customerDataType) {
+  var storageKey = buildStorageKey(productKey, customerDataType);
+  storageListeners.push(addEventListener(configuration, window, "storage", function(_a2) {
+    var key = _a2.key;
+    if (storageKey === key) {
+      synchronizeWithStorage();
+    }
+  }));
+  contextManager.changeObservable.subscribe(dumpToStorage);
+  contextManager.setContext(combine(getFromStorage(), contextManager.getContext()));
+  function synchronizeWithStorage() {
+    contextManager.setContext(getFromStorage());
+  }
+  function dumpToStorage() {
+    localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()));
+  }
+  function getFromStorage() {
+    var rawContext = localStorage.getItem(storageKey);
+    return rawContext !== null ? JSON.parse(rawContext) : {};
+  }
+}
+function buildStorageKey(productKey, customerDataType) {
+  return "".concat(CONTEXT_STORE_KEY_PREFIX, "_").concat(productKey, "_").concat(customerDataType);
+}
+var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;
+var CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;
+var BYTES_COMPUTATION_THROTTLING_DELAY = 200;
+function createCustomerDataTrackerManager(compressionStatus) {
+  if (compressionStatus === void 0) {
+    compressionStatus = 2;
+  }
+  var customerDataTrackers = /* @__PURE__ */ new Map();
+  var alreadyWarned = false;
+  function checkCustomerDataLimit(initialBytesCount) {
+    if (initialBytesCount === void 0) {
+      initialBytesCount = 0;
+    }
+    if (alreadyWarned || compressionStatus === 0) {
+      return;
+    }
+    var bytesCountLimit = compressionStatus === 2 ? CUSTOMER_DATA_BYTES_LIMIT : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT;
+    var bytesCount = initialBytesCount;
+    customerDataTrackers.forEach(function(tracker) {
+      bytesCount += tracker.getBytesCount();
+    });
+    if (bytesCount > bytesCountLimit) {
+      displayCustomerDataLimitReachedWarning(bytesCountLimit);
+      alreadyWarned = true;
+    }
+  }
+  return {
+    /**
+     * Creates a detached tracker. The manager will not store a reference to that tracker, and the
+     * bytes count will be counted independently from other detached trackers.
+     *
+     * This is particularly useful when we don't know when the tracker will be unused, so we don't
+     * leak memory (ex: when used in Logger instances).
+     */
+    createDetachedTracker: function() {
+      var tracker = createCustomerDataTracker(function() {
+        return checkCustomerDataLimit(tracker.getBytesCount());
+      });
+      return tracker;
+    },
+    /**
+     * Creates a tracker if it doesn't exist, and returns it.
+     */
+    getOrCreateTracker: function(type) {
+      if (!customerDataTrackers.has(type)) {
+        customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit));
+      }
+      return customerDataTrackers.get(type);
+    },
+    setCompressionStatus: function(newCompressionStatus) {
+      if (compressionStatus === 0) {
+        compressionStatus = newCompressionStatus;
+        checkCustomerDataLimit();
+      }
+    },
+    getCompressionStatus: function() {
+      return compressionStatus;
+    },
+    stop: function() {
+      customerDataTrackers.forEach(function(tracker) {
+        return tracker.stop();
+      });
+      customerDataTrackers.clear();
+    }
+  };
+}
+function createCustomerDataTracker(checkCustomerDataLimit) {
+  var bytesCountCache = 0;
+  var _a2 = throttle(function(context) {
+    bytesCountCache = computeBytesCount(jsonStringify(context));
+    checkCustomerDataLimit();
+  }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a2.throttled, cancelComputeBytesCount = _a2.cancel;
+  var resetBytesCount = function() {
+    cancelComputeBytesCount();
+    bytesCountCache = 0;
+  };
+  return {
+    updateCustomerData: function(context) {
+      if (isEmptyObject(context)) {
+        resetBytesCount();
+      } else {
+        computeBytesCountThrottled(context);
+      }
+    },
+    resetCustomerData: resetBytesCount,
+    getBytesCount: function() {
+      return bytesCountCache;
+    },
+    stop: function() {
+      cancelComputeBytesCount();
+    }
+  };
+}
+function displayCustomerDataLimitReachedWarning(bytesCountLimit) {
+  display.warn("Customer data exceeds the recommended ".concat(bytesCountLimit / ONE_KIBI_BYTE, "KiB threshold. ").concat(MORE_DETAILS, " ").concat(DOCS_TROUBLESHOOTING, "/#customer-data-exceeds-the-recommended-threshold-warning"));
+}
+function readBytesFromStream(stream, callback, options) {
+  var reader = stream.getReader();
+  var chunks = [];
+  var readBytesCount = 0;
+  readMore();
+  function readMore() {
+    reader.read().then(monitor(function(result) {
+      if (result.done) {
+        onDone();
+        return;
+      }
+      if (options.collectStreamBody) {
+        chunks.push(result.value);
+      }
+      readBytesCount += result.value.length;
+      if (readBytesCount > options.bytesLimit) {
+        onDone();
+      } else {
+        readMore();
+      }
+    }), monitor(function(error) {
+      return callback(error);
+    }));
+  }
+  function onDone() {
+    reader.cancel().catch(
+      // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+      // as an unhandled rejection
+      noop
+    );
+    var bytes;
+    var limitExceeded;
+    if (options.collectStreamBody) {
+      var completeBuffer_1;
+      if (chunks.length === 1) {
+        completeBuffer_1 = chunks[0];
+      } else {
+        completeBuffer_1 = new Uint8Array(readBytesCount);
+        var offset_1 = 0;
+        chunks.forEach(function(chunk) {
+          completeBuffer_1.set(chunk, offset_1);
+          offset_1 += chunk.length;
+        });
+      }
+      bytes = completeBuffer_1.slice(0, options.bytesLimit);
+      limitExceeded = completeBuffer_1.length > options.bytesLimit;
+    }
+    callback(void 0, bytes, limitExceeded);
+  }
+}
+var SYNTHETICS_TEST_ID_COOKIE_NAME = "datadog-synthetics-public-id";
+var SYNTHETICS_RESULT_ID_COOKIE_NAME = "datadog-synthetics-result-id";
+var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = "datadog-synthetics-injects-rum";
+function willSyntheticsInjectRum() {
+  return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));
+}
+function getSyntheticsTestId() {
+  var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);
+  return typeof value === "string" ? value : void 0;
+}
+function getSyntheticsResultId() {
+  var value = window._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);
+  return typeof value === "string" ? value : void 0;
+}
+function sanitizeUser(newUser) {
+  var user = assign({}, newUser);
+  var keys = ["id", "name", "email"];
+  keys.forEach(function(key) {
+    if (key in user) {
+      user[key] = String(user[key]);
+    }
+  });
+  return user;
+}
+function checkUser(newUser) {
+  var isValid = getType(newUser) === "object";
+  if (!isValid) {
+    display.error("Unsupported user:", newUser);
+  }
+  return isValid;
+}
+var _a$3;
+function isAuthorized(status, handlerType, logger) {
+  var loggerHandler = logger.getHandler();
+  var sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler];
+  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && includes(sanitizedHandlerType, handlerType);
+}
+var StatusType = {
+  ok: "ok",
+  debug: "debug",
+  info: "info",
+  notice: "notice",
+  warn: "warn",
+  error: "error",
+  critical: "critical",
+  alert: "alert",
+  emerg: "emerg"
+};
+var STATUS_PRIORITIES = (_a$3 = {}, _a$3[StatusType.ok] = 0, _a$3[StatusType.debug] = 1, _a$3[StatusType.info] = 2, _a$3[StatusType.notice] = 4, _a$3[StatusType.warn] = 5, _a$3[StatusType.error] = 6, _a$3[StatusType.critical] = 7, _a$3[StatusType.alert] = 8, _a$3[StatusType.emerg] = 9, _a$3);
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var HandlerType = {
+  console: "console",
+  http: "http",
+  silent: "silent"
+};
+var STATUSES = Object.keys(StatusType);
+var Logger = (
+  /** @class */
+  function() {
+    function Logger2(handleLogStrategy, customerDataTracker, name, handlerType, level, loggerContext) {
+      if (handlerType === void 0) {
+        handlerType = HandlerType.http;
+      }
+      if (level === void 0) {
+        level = StatusType.debug;
+      }
+      if (loggerContext === void 0) {
+        loggerContext = {};
+      }
+      this.handleLogStrategy = handleLogStrategy;
+      this.handlerType = handlerType;
+      this.level = level;
+      this.contextManager = createContextManager(customerDataTracker);
+      this.contextManager.setContext(loggerContext);
+      if (name) {
+        this.contextManager.setContextProperty("logger", { name });
+      }
+    }
+    Logger2.prototype.logImplementation = function(message, messageContext, status, error, handlingStack) {
+      if (status === void 0) {
+        status = StatusType.info;
+      }
+      var errorContext;
+      if (error !== void 0 && error !== null) {
+        var stackTrace = error instanceof Error ? computeStackTrace(error) : void 0;
+        var rawError = computeRawError({
+          stackTrace,
+          originalError: error,
+          nonErrorPrefix: "Provided",
+          source: ErrorSource.LOGGER,
+          handling: "handled",
+          startClocks: clocksNow()
+        });
+        errorContext = {
+          stack: rawError.stack,
+          kind: rawError.type,
+          message: rawError.message,
+          causes: rawError.causes
+        };
+      }
+      var sanitizedMessageContext = sanitize(messageContext);
+      var context = errorContext ? combine({ error: errorContext }, sanitizedMessageContext) : sanitizedMessageContext;
+      this.handleLogStrategy({
+        message: sanitize(message),
+        context,
+        status
+      }, this, handlingStack);
+    };
+    Logger2.prototype.log = function(message, messageContext, status, error) {
+      if (status === void 0) {
+        status = StatusType.info;
+      }
+      var handlingStack;
+      if (isAuthorized(status, HandlerType.http, this)) {
+        handlingStack = createHandlingStack();
+      }
+      this.logImplementation(message, messageContext, status, error, handlingStack);
+    };
+    Logger2.prototype.setContext = function(context) {
+      this.contextManager.setContext(context);
+    };
+    Logger2.prototype.getContext = function() {
+      return this.contextManager.getContext();
+    };
+    Logger2.prototype.setContextProperty = function(key, value) {
+      this.contextManager.setContextProperty(key, value);
+    };
+    Logger2.prototype.removeContextProperty = function(key) {
+      this.contextManager.removeContextProperty(key);
+    };
+    Logger2.prototype.clearContext = function() {
+      this.contextManager.clearContext();
+    };
+    Logger2.prototype.setHandler = function(handler) {
+      this.handlerType = handler;
+    };
+    Logger2.prototype.getHandler = function() {
+      return this.handlerType;
+    };
+    Logger2.prototype.setLevel = function(level) {
+      this.level = level;
+    };
+    Logger2.prototype.getLevel = function() {
+      return this.level;
+    };
+    __decorate([
+      monitored
+    ], Logger2.prototype, "logImplementation", null);
+    return Logger2;
+  }()
+);
+Logger.prototype.ok = createLoggerMethod(StatusType.ok);
+Logger.prototype.debug = createLoggerMethod(StatusType.debug);
+Logger.prototype.info = createLoggerMethod(StatusType.info);
+Logger.prototype.notice = createLoggerMethod(StatusType.notice);
+Logger.prototype.warn = createLoggerMethod(StatusType.warn);
+Logger.prototype.error = createLoggerMethod(StatusType.error);
+Logger.prototype.critical = createLoggerMethod(StatusType.critical);
+Logger.prototype.alert = createLoggerMethod(StatusType.alert);
+Logger.prototype.emerg = createLoggerMethod(StatusType.emerg);
+function createLoggerMethod(status) {
+  return function(message, messageContext, error) {
+    var handlingStack;
+    if (isAuthorized(status, HandlerType.http, this)) {
+      handlingStack = createHandlingStack();
+    }
+    this.logImplementation(message, messageContext, status, error, handlingStack);
+  };
+}
+function buildCommonContext(globalContextManager, userContextManager) {
+  return {
+    view: {
+      referrer: document.referrer,
+      url: window.location.href
+    },
+    context: globalContextManager.getContext(),
+    user: userContextManager.getContext()
+  };
+}
+var DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE;
+function validateAndBuildLogsConfiguration(initConfiguration) {
+  if (initConfiguration.usePciIntake === true && initConfiguration.site && initConfiguration.site !== "datadoghq.com") {
+    display.warn("PCI compliance for Logs is only available for Datadog organizations in the US1 site. Default intake will be used.");
+  }
+  var baseConfiguration = validateAndBuildConfiguration(initConfiguration);
+  var forwardConsoleLogs = validateAndBuildForwardOption(initConfiguration.forwardConsoleLogs, objectValues(ConsoleApiName), "Forward Console Logs");
+  var forwardReports = validateAndBuildForwardOption(initConfiguration.forwardReports, objectValues(RawReportType), "Forward Reports");
+  if (!baseConfiguration || !forwardConsoleLogs || !forwardReports) {
+    return;
+  }
+  if (initConfiguration.forwardErrorsToLogs && !includes(forwardConsoleLogs, ConsoleApiName.error)) {
+    forwardConsoleLogs.push(ConsoleApiName.error);
+  }
+  return assign({
+    forwardErrorsToLogs: initConfiguration.forwardErrorsToLogs !== false,
+    forwardConsoleLogs,
+    forwardReports,
+    requestErrorResponseLengthLimit: DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT,
+    sendLogsAfterSessionExpiration: !!initConfiguration.sendLogsAfterSessionExpiration
+  }, baseConfiguration);
+}
+function validateAndBuildForwardOption(option, allowedValues, label) {
+  if (option === void 0) {
+    return [];
+  }
+  if (!(option === "all" || Array.isArray(option) && option.every(function(api) {
+    return includes(allowedValues, api);
+  }))) {
+    display.error("".concat(label, ' should be "all" or an array with allowed values "').concat(allowedValues.join('", "'), '"'));
+    return;
+  }
+  return option === "all" ? allowedValues : removeDuplicates(option);
+}
+function serializeLogsConfiguration(configuration) {
+  var baseSerializedInitConfiguration = serializeConfiguration(configuration);
+  return assign({
+    forward_errors_to_logs: configuration.forwardErrorsToLogs,
+    forward_console_logs: configuration.forwardConsoleLogs,
+    forward_reports: configuration.forwardReports,
+    use_pci_intake: configuration.usePciIntake,
+    send_logs_after_session_expiration: configuration.sendLogsAfterSessionExpiration
+  }, baseSerializedInitConfiguration);
+}
+function createPreStartStrategy(getCommonContext, trackingConsentState, doStartLogs) {
+  var bufferApiCalls = createBoundedBuffer();
+  var cachedInitConfiguration;
+  var cachedConfiguration;
+  var trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartLogs);
+  function tryStartLogs() {
+    if (!cachedConfiguration || !cachedInitConfiguration || !trackingConsentState.isGranted()) {
+      return;
+    }
+    trackingConsentStateSubscription.unsubscribe();
+    var startLogsResult = doStartLogs(cachedInitConfiguration, cachedConfiguration);
+    bufferApiCalls.drain(startLogsResult);
+  }
+  return {
+    init: function(initConfiguration) {
+      if (!initConfiguration) {
+        display.error("Missing configuration");
+        return;
+      }
+      initFeatureFlags(initConfiguration.enableExperimentalFeatures);
+      if (canUseEventBridge()) {
+        initConfiguration = overrideInitConfigurationForBridge(initConfiguration);
+      }
+      cachedInitConfiguration = initConfiguration;
+      if (cachedConfiguration) {
+        displayAlreadyInitializedError("DD_LOGS", initConfiguration);
+        return;
+      }
+      var configuration = validateAndBuildLogsConfiguration(initConfiguration);
+      if (!configuration) {
+        return;
+      }
+      cachedConfiguration = configuration;
+      initFetchObservable().subscribe(noop);
+      trackingConsentState.tryToInit(configuration.trackingConsent);
+      tryStartLogs();
+    },
+    get initConfiguration() {
+      return cachedInitConfiguration;
+    },
+    getInternalContext: noop,
+    handleLog: function(message, statusType, handlingStack, context, date) {
+      if (context === void 0) {
+        context = getCommonContext();
+      }
+      if (date === void 0) {
+        date = timeStampNow();
+      }
+      bufferApiCalls.add(function(startLogsResult) {
+        return startLogsResult.handleLog(message, statusType, handlingStack, context, date);
+      });
+    }
+  };
+}
+function overrideInitConfigurationForBridge(initConfiguration) {
+  return assign({}, initConfiguration, { clientToken: "empty" });
+}
+var LOGS_STORAGE_KEY = "logs";
+function makeLogsPublicApi(startLogsImpl) {
+  var customerDataTrackerManager = createCustomerDataTrackerManager();
+  var globalContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(
+    2
+    /* CustomerDataType.GlobalContext */
+  ));
+  var userContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(
+    1
+    /* CustomerDataType.User */
+  ));
+  var trackingConsentState = createTrackingConsentState();
+  function getCommonContext() {
+    return buildCommonContext(globalContextManager, userContextManager);
+  }
+  var strategy = createPreStartStrategy(getCommonContext, trackingConsentState, function(initConfiguration, configuration) {
+    if (initConfiguration.storeContextsAcrossPages) {
+      storeContextManager(
+        configuration,
+        globalContextManager,
+        LOGS_STORAGE_KEY,
+        2
+        /* CustomerDataType.GlobalContext */
+      );
+      storeContextManager(
+        configuration,
+        userContextManager,
+        LOGS_STORAGE_KEY,
+        1
+        /* CustomerDataType.User */
+      );
+    }
+    var startLogsResult = startLogsImpl(initConfiguration, configuration, getCommonContext, trackingConsentState);
+    strategy = createPostStartStrategy(initConfiguration, startLogsResult);
+    return startLogsResult;
+  });
+  var customLoggers = {};
+  var mainLogger = new Logger(function() {
+    var params = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      params[_i] = arguments[_i];
+    }
+    return strategy.handleLog.apply(strategy, params);
+  }, customerDataTrackerManager.createDetachedTracker());
+  return makePublicApi({
+    logger: mainLogger,
+    init: monitor(function(initConfiguration) {
+      return strategy.init(initConfiguration);
+    }),
+    setTrackingConsent: monitor(function(trackingConsent) {
+      trackingConsentState.update(trackingConsent);
+      addTelemetryUsage({ feature: "set-tracking-consent", tracking_consent: trackingConsent });
+    }),
+    getGlobalContext: monitor(function() {
+      return globalContextManager.getContext();
+    }),
+    setGlobalContext: monitor(function(context) {
+      return globalContextManager.setContext(context);
+    }),
+    setGlobalContextProperty: monitor(function(key, value) {
+      return globalContextManager.setContextProperty(key, value);
+    }),
+    removeGlobalContextProperty: monitor(function(key) {
+      return globalContextManager.removeContextProperty(key);
+    }),
+    clearGlobalContext: monitor(function() {
+      return globalContextManager.clearContext();
+    }),
+    createLogger: monitor(function(name, conf) {
+      if (conf === void 0) {
+        conf = {};
+      }
+      customLoggers[name] = new Logger(function() {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          params[_i] = arguments[_i];
+        }
+        return strategy.handleLog.apply(strategy, params);
+      }, customerDataTrackerManager.createDetachedTracker(), sanitize(name), conf.handler, conf.level, sanitize(conf.context));
+      return customLoggers[name];
+    }),
+    getLogger: monitor(function(name) {
+      return customLoggers[name];
+    }),
+    getInitConfiguration: monitor(function() {
+      return deepClone(strategy.initConfiguration);
+    }),
+    getInternalContext: monitor(function(startTime) {
+      return strategy.getInternalContext(startTime);
+    }),
+    setUser: monitor(function(newUser) {
+      if (checkUser(newUser)) {
+        userContextManager.setContext(sanitizeUser(newUser));
+      }
+    }),
+    getUser: monitor(function() {
+      return userContextManager.getContext();
+    }),
+    setUserProperty: monitor(function(key, property) {
+      var _a2;
+      var sanitizedProperty = sanitizeUser((_a2 = {}, _a2[key] = property, _a2))[key];
+      userContextManager.setContextProperty(key, sanitizedProperty);
+    }),
+    removeUserProperty: monitor(function(key) {
+      return userContextManager.removeContextProperty(key);
+    }),
+    clearUser: monitor(function() {
+      return userContextManager.clearContext();
+    })
+  });
+}
+function createPostStartStrategy(initConfiguration, startLogsResult) {
+  return assign({
+    init: function(initConfiguration2) {
+      displayAlreadyInitializedError("DD_LOGS", initConfiguration2);
+    },
+    initConfiguration
+  }, startLogsResult);
+}
+var LOGS_SESSION_KEY = "logs";
+function startLogsSessionManager(configuration, trackingConsentState) {
+  var sessionManager = startSessionManager(configuration, LOGS_SESSION_KEY, function(rawTrackingType) {
+    return computeSessionState(configuration, rawTrackingType);
+  }, trackingConsentState);
+  return {
+    findTrackedSession: function(startTime, options) {
+      if (options === void 0) {
+        options = { returnInactive: false };
+      }
+      var session = sessionManager.findSession(startTime, options);
+      return session && session.trackingType === "1" ? {
+        id: session.id
+      } : void 0;
+    },
+    expireObservable: sessionManager.expireObservable
+  };
+}
+function startLogsSessionManagerStub(configuration) {
+  var isTracked = computeTrackingType(configuration) === "1";
+  var session = isTracked ? {} : void 0;
+  return {
+    findTrackedSession: function() {
+      return session;
+    },
+    expireObservable: new Observable()
+  };
+}
+function computeTrackingType(configuration) {
+  if (!performDraw(configuration.sessionSampleRate)) {
+    return "0";
+  }
+  return "1";
+}
+function computeSessionState(configuration, rawSessionType) {
+  var trackingType = hasValidLoggerSession(rawSessionType) ? rawSessionType : computeTrackingType(configuration);
+  return {
+    trackingType,
+    isTracked: trackingType === "1"
+  };
+}
+function hasValidLoggerSession(trackingType) {
+  return trackingType === "0" || trackingType === "1";
+}
+var logsSentBeforeRumInjectionTelemetryAdded = false;
+function getRUMInternalContext(startTime) {
+  var browserWindow = window;
+  if (willSyntheticsInjectRum()) {
+    var context = getInternalContextFromRumGlobal(browserWindow.DD_RUM_SYNTHETICS);
+    if (!context && !logsSentBeforeRumInjectionTelemetryAdded) {
+      logsSentBeforeRumInjectionTelemetryAdded = true;
+      addTelemetryDebug("Logs sent before RUM is injected by the synthetics worker", {
+        testId: getSyntheticsTestId(),
+        resultId: getSyntheticsResultId()
+      });
+    }
+    return context;
+  }
+  return getInternalContextFromRumGlobal(browserWindow.DD_RUM);
+  function getInternalContextFromRumGlobal(rumGlobal) {
+    if (rumGlobal && rumGlobal.getInternalContext) {
+      return rumGlobal.getInternalContext(startTime);
+    }
+  }
+}
+function startLogsAssembly(sessionManager, configuration, lifeCycle, getCommonContext, reportError) {
+  var statusWithCustom = STATUSES.concat(["custom"]);
+  var logRateLimiters = {};
+  statusWithCustom.forEach(function(status) {
+    logRateLimiters[status] = createEventRateLimiter(status, configuration.eventRateLimiterThreshold, reportError);
+  });
+  lifeCycle.subscribe(0, function(_a2) {
+    var _b, _c;
+    var rawLogsEvent = _a2.rawLogsEvent, _d = _a2.messageContext, messageContext = _d === void 0 ? void 0 : _d, _e = _a2.savedCommonContext, savedCommonContext = _e === void 0 ? void 0 : _e, domainContext = _a2.domainContext;
+    var startTime = getRelativeTime(rawLogsEvent.date);
+    var session = sessionManager.findTrackedSession(startTime);
+    if (!session && (!configuration.sendLogsAfterSessionExpiration || !sessionManager.findTrackedSession(startTime, { returnInactive: true }))) {
+      return;
+    }
+    var commonContext = savedCommonContext || getCommonContext();
+    var log = combine({
+      service: configuration.service,
+      session_id: session ? session.id : void 0,
+      // Insert user first to allow overrides from global context
+      usr: !isEmptyObject(commonContext.user) ? commonContext.user : void 0,
+      view: commonContext.view
+    }, commonContext.context, getRUMInternalContext(startTime), rawLogsEvent, messageContext);
+    if (((_b = configuration.beforeSend) === null || _b === void 0 ? void 0 : _b.call(configuration, log, domainContext)) === false || log.origin !== ErrorSource.AGENT && ((_c = logRateLimiters[log.status]) !== null && _c !== void 0 ? _c : logRateLimiters["custom"]).isLimitReached()) {
+      return;
+    }
+    lifeCycle.notify(1, log);
+  });
+}
+var _a$2;
+var LogStatusForApi = (_a$2 = {}, _a$2[ConsoleApiName.log] = StatusType.info, _a$2[ConsoleApiName.debug] = StatusType.debug, _a$2[ConsoleApiName.info] = StatusType.info, _a$2[ConsoleApiName.warn] = StatusType.warn, _a$2[ConsoleApiName.error] = StatusType.error, _a$2);
+function startConsoleCollection(configuration, lifeCycle) {
+  var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function(log) {
+    var collectedData = {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message: log.message,
+        origin: ErrorSource.CONSOLE,
+        error: log.api === ConsoleApiName.error ? {
+          stack: log.stack,
+          fingerprint: log.fingerprint,
+          causes: log.causes
+        } : void 0,
+        status: LogStatusForApi[log.api]
+      },
+      domainContext: {
+        handlingStack: log.handlingStack
+      }
+    };
+    lifeCycle.notify(0, collectedData);
+  });
+  return {
+    stop: function() {
+      consoleSubscription.unsubscribe();
+    }
+  };
+}
+var _a$1;
+var LogStatusForReport = (_a$1 = {}, _a$1[RawReportType.cspViolation] = StatusType.error, _a$1[RawReportType.intervention] = StatusType.error, _a$1[RawReportType.deprecation] = StatusType.warn, _a$1);
+function startReportCollection(configuration, lifeCycle) {
+  var reportSubscription = initReportObservable(configuration, configuration.forwardReports).subscribe(function(report) {
+    var message = report.message;
+    var status = LogStatusForReport[report.type];
+    var error;
+    if (status === StatusType.error) {
+      error = {
+        kind: report.subtype,
+        stack: report.stack
+      };
+    } else if (report.stack) {
+      message += " Found in ".concat(getFileFromStackTraceString(report.stack));
+    }
+    lifeCycle.notify(0, {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message,
+        origin: ErrorSource.REPORT,
+        error,
+        status
+      }
+    });
+  });
+  return {
+    stop: function() {
+      reportSubscription.unsubscribe();
+    }
+  };
+}
+function startNetworkErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop };
+  }
+  var xhrSubscription = initXhrObservable(configuration).subscribe(function(context) {
+    if (context.state === "complete") {
+      handleResponse("xhr", context);
+    }
+  });
+  var fetchSubscription = initFetchObservable().subscribe(function(context) {
+    if (context.state === "resolve") {
+      handleResponse("fetch", context);
+    }
+  });
+  function handleResponse(type, request) {
+    if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request.status))) {
+      if ("xhr" in request) {
+        computeXhrResponseData(request.xhr, configuration, onResponseDataAvailable);
+      } else if (request.response) {
+        computeFetchResponseText(request.response, configuration, onResponseDataAvailable);
+      } else if (request.error) {
+        computeFetchErrorText(request.error, configuration, onResponseDataAvailable);
+      }
+    }
+    function onResponseDataAvailable(responseData) {
+      var domainContext = {
+        isAborted: request.isAborted,
+        handlingStack: request.handlingStack
+      };
+      lifeCycle.notify(0, {
+        rawLogsEvent: {
+          message: "".concat(format(type), " error ").concat(request.method, " ").concat(request.url),
+          date: request.startClocks.timeStamp,
+          error: {
+            stack: responseData || "Failed to load"
+          },
+          http: {
+            method: request.method,
+            // Cast resource method because of case mismatch cf issue RUMF-1152
+            status_code: request.status,
+            url: request.url
+          },
+          status: StatusType.error,
+          origin: ErrorSource.NETWORK
+        },
+        domainContext
+      });
+    }
+  }
+  return {
+    stop: function() {
+      xhrSubscription.unsubscribe();
+      fetchSubscription.unsubscribe();
+    }
+  };
+}
+function computeXhrResponseData(xhr, configuration, callback) {
+  if (typeof xhr.response === "string") {
+    callback(truncateResponseText(xhr.response, configuration));
+  } else {
+    callback(xhr.response);
+  }
+}
+function computeFetchErrorText(error, configuration, callback) {
+  callback(truncateResponseText(toStackTraceString(computeStackTrace(error)), configuration));
+}
+function computeFetchResponseText(response, configuration, callback) {
+  var clonedResponse = tryToClone(response);
+  if (!clonedResponse || !clonedResponse.body) {
+    callback();
+  } else if (!window.TextDecoder) {
+    clonedResponse.text().then(monitor(function(text) {
+      return callback(truncateResponseText(text, configuration));
+    }), monitor(function(error) {
+      return callback("Unable to retrieve response: ".concat(error));
+    }));
+  } else {
+    truncateResponseStream(clonedResponse.body, configuration.requestErrorResponseLengthLimit, function(error, responseText) {
+      if (error) {
+        callback("Unable to retrieve response: ".concat(error));
+      } else {
+        callback(responseText);
+      }
+    });
+  }
+}
+function isRejected(request) {
+  return request.status === 0 && request.responseType !== "opaque";
+}
+function truncateResponseText(responseText, configuration) {
+  if (responseText.length > configuration.requestErrorResponseLengthLimit) {
+    return "".concat(responseText.substring(0, configuration.requestErrorResponseLengthLimit), "...");
+  }
+  return responseText;
+}
+function format(type) {
+  if ("xhr" === type) {
+    return "XHR";
+  }
+  return "Fetch";
+}
+function truncateResponseStream(stream, bytesLimit, callback) {
+  readBytesFromStream(stream, function(error, bytes, limitExceeded) {
+    if (error) {
+      callback(error);
+    } else {
+      var responseText = new TextDecoder().decode(bytes);
+      if (limitExceeded) {
+        responseText += "...";
+      }
+      callback(void 0, responseText);
+    }
+  }, {
+    bytesLimit,
+    collectStreamBody: true
+  });
+}
+function startRuntimeErrorCollection(configuration, lifeCycle) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop };
+  }
+  var rawErrorObservable = new Observable();
+  var stopRuntimeErrorTracking = trackRuntimeError(rawErrorObservable).stop;
+  var rawErrorSubscription = rawErrorObservable.subscribe(function(rawError) {
+    lifeCycle.notify(0, {
+      rawLogsEvent: {
+        message: rawError.message,
+        date: rawError.startClocks.timeStamp,
+        error: {
+          kind: rawError.type,
+          stack: rawError.stack,
+          causes: rawError.causes
+        },
+        origin: ErrorSource.SOURCE,
+        status: StatusType.error
+      }
+    });
+  });
+  return {
+    stop: function() {
+      stopRuntimeErrorTracking();
+      rawErrorSubscription.unsubscribe();
+    }
+  };
+}
+var LifeCycle = AbstractLifeCycle;
+var _a;
+function startLoggerCollection(lifeCycle) {
+  function handleLog(logsMessage, logger, handlingStack, savedCommonContext, savedDate) {
+    var messageContext = combine(logger.getContext(), logsMessage.context);
+    if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {
+      displayInConsole(logsMessage, messageContext);
+    }
+    if (isAuthorized(logsMessage.status, HandlerType.http, logger)) {
+      var rawLogEventData = {
+        rawLogsEvent: {
+          date: savedDate || timeStampNow(),
+          message: logsMessage.message,
+          status: logsMessage.status,
+          origin: ErrorSource.LOGGER
+        },
+        messageContext,
+        savedCommonContext
+      };
+      if (handlingStack) {
+        rawLogEventData.domainContext = { handlingStack };
+      }
+      lifeCycle.notify(0, rawLogEventData);
+    }
+  }
+  return {
+    handleLog
+  };
+}
+var loggerToConsoleApiName = (_a = {}, _a[StatusType.ok] = ConsoleApiName.debug, _a[StatusType.debug] = ConsoleApiName.debug, _a[StatusType.info] = ConsoleApiName.info, _a[StatusType.notice] = ConsoleApiName.info, _a[StatusType.warn] = ConsoleApiName.warn, _a[StatusType.error] = ConsoleApiName.error, _a[StatusType.critical] = ConsoleApiName.error, _a[StatusType.alert] = ConsoleApiName.error, _a[StatusType.emerg] = ConsoleApiName.error, _a);
+function displayInConsole(_a2, messageContext) {
+  var status = _a2.status, message = _a2.message;
+  originalConsoleMethods[loggerToConsoleApiName[status]].call(globalConsole, message, messageContext);
+}
+function startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session) {
+  var batch = startBatchWithReplica(configuration, {
+    endpoint: configuration.logsEndpointBuilder,
+    encoder: createIdentityEncoder()
+  }, configuration.replica && {
+    endpoint: configuration.replica.logsEndpointBuilder,
+    encoder: createIdentityEncoder()
+  }, reportError, pageExitObservable, session.expireObservable);
+  lifeCycle.subscribe(1, function(serverLogsEvent) {
+    batch.add(serverLogsEvent);
+  });
+  return batch;
+}
+function startLogsBridge(lifeCycle) {
+  var bridge = getEventBridge();
+  lifeCycle.subscribe(1, function(serverLogsEvent) {
+    bridge.send("log", serverLogsEvent);
+  });
+}
+function startInternalContext(sessionManager) {
+  return {
+    get: function(startTime) {
+      var trackedSession = sessionManager.findTrackedSession(startTime);
+      if (trackedSession) {
+        return {
+          session_id: trackedSession.id
+        };
+      }
+    }
+  };
+}
+function startReportError(lifeCycle) {
+  return function(error) {
+    lifeCycle.notify(0, {
+      rawLogsEvent: {
+        message: error.message,
+        date: error.startClocks.timeStamp,
+        origin: ErrorSource.AGENT,
+        status: StatusType.error
+      }
+    });
+    addTelemetryDebug("Error reported to customer", { "error.message": error.message });
+  };
+}
+function startLogsTelemetry(initConfiguration, configuration, reportError, pageExitObservable, session) {
+  var telemetry = startTelemetry("browser-logs-sdk", configuration);
+  telemetry.setContextProvider(function() {
+    var _a2, _b, _c, _d, _e, _f;
+    return {
+      application: {
+        id: (_a2 = getRUMInternalContext()) === null || _a2 === void 0 ? void 0 : _a2.application_id
+      },
+      session: {
+        id: (_b = session.findTrackedSession()) === null || _b === void 0 ? void 0 : _b.id
+      },
+      view: {
+        id: (_d = (_c = getRUMInternalContext()) === null || _c === void 0 ? void 0 : _c.view) === null || _d === void 0 ? void 0 : _d.id
+      },
+      action: {
+        id: (_f = (_e = getRUMInternalContext()) === null || _e === void 0 ? void 0 : _e.user_action) === null || _f === void 0 ? void 0 : _f.id
+      }
+    };
+  });
+  var cleanupTasks = [];
+  if (canUseEventBridge()) {
+    var bridge_1 = getEventBridge();
+    var telemetrySubscription_1 = telemetry.observable.subscribe(function(event) {
+      return bridge_1.send("internal_telemetry", event);
+    });
+    cleanupTasks.push(function() {
+      return telemetrySubscription_1.unsubscribe();
+    });
+  } else {
+    var telemetryBatch_1 = startBatchWithReplica(configuration, {
+      endpoint: configuration.rumEndpointBuilder,
+      encoder: createIdentityEncoder()
+    }, configuration.replica && {
+      endpoint: configuration.replica.rumEndpointBuilder,
+      encoder: createIdentityEncoder()
+    }, reportError, pageExitObservable, session.expireObservable);
+    cleanupTasks.push(function() {
+      return telemetryBatch_1.stop();
+    });
+    var telemetrySubscription_2 = telemetry.observable.subscribe(function(event) {
+      return telemetryBatch_1.add(event, isTelemetryReplicationAllowed(configuration));
+    });
+    cleanupTasks.push(function() {
+      return telemetrySubscription_2.unsubscribe();
+    });
+  }
+  drainPreStartTelemetry();
+  addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration));
+  return {
+    telemetry,
+    stop: function() {
+      cleanupTasks.forEach(function(task) {
+        return task();
+      });
+    }
+  };
+}
+function startLogs(initConfiguration, configuration, getCommonContext, trackingConsentState) {
+  var lifeCycle = new LifeCycle();
+  var cleanupTasks = [];
+  lifeCycle.subscribe(1, function(log) {
+    return sendToExtension("logs", log);
+  });
+  var reportError = startReportError(lifeCycle);
+  var pageExitObservable = createPageExitObservable(configuration);
+  var session = configuration.sessionStoreStrategyType && !canUseEventBridge() && !willSyntheticsInjectRum() ? startLogsSessionManager(configuration, trackingConsentState) : startLogsSessionManagerStub(configuration);
+  var stopLogsTelemetry = startLogsTelemetry(initConfiguration, configuration, reportError, pageExitObservable, session).stop;
+  cleanupTasks.push(function() {
+    return stopLogsTelemetry();
+  });
+  startNetworkErrorCollection(configuration, lifeCycle);
+  startRuntimeErrorCollection(configuration, lifeCycle);
+  startConsoleCollection(configuration, lifeCycle);
+  startReportCollection(configuration, lifeCycle);
+  var handleLog = startLoggerCollection(lifeCycle).handleLog;
+  startLogsAssembly(session, configuration, lifeCycle, getCommonContext, reportError);
+  if (!canUseEventBridge()) {
+    var stopLogsBatch_1 = startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session).stop;
+    cleanupTasks.push(function() {
+      return stopLogsBatch_1();
+    });
+  } else {
+    startLogsBridge(lifeCycle);
+  }
+  var internalContext = startInternalContext(session);
+  return {
+    handleLog,
+    getInternalContext: internalContext.get,
+    stop: function() {
+      cleanupTasks.forEach(function(task) {
+        return task();
+      });
+    }
+  };
+}
+var datadogLogs = makeLogsPublicApi(startLogs);
+defineGlobal(getGlobalObject(), "DD_LOGS", datadogLogs);
+function normalizeArgs(args) {
+  let msg = "";
+  let obj = {};
+  let error;
+  let arrCount = 1;
+  Array.from(arguments).forEach((arg) => {
+    if (typeof arg === "string") {
+      msg += ` ${arg}`;
+    } else if (arg instanceof Error) {
+      error = arg;
+    } else if (Array.isArray(arg)) {
+      obj[`array${arrCount++}`] = arg;
+    } else if (typeof arg === "object") {
+      Object.assign(obj, arg);
+    }
+  });
+  return {
+    message: msg.trim(),
+    properties: obj,
+    error
+  };
+}
+const DEFAULTS = {
+  silentMultipleInit: true,
+  service: "BROWSER_LOG",
+  site: "datadoghq.com",
+  forwardErrorsToLogs: false,
+  sessionSampleRate: 100
+};
+class DatadogLogger {
+  constructor(options = {}) {
+    if (!options.clientToken) {
+      throw new Error('Please provide "clientToken" for your Datadog account');
+    }
+    datadogLogs.init({ ...DEFAULTS, ...options });
+    this.options = options;
+    this.logger = datadogLogs.logger;
+    this.ctx = {};
+  }
+  log() {
+    let normalized = normalizeArgs(...arguments);
+    this.logger.log(normalized.message, Object.assign(normalized.properties, this.ctx));
+  }
+  info() {
+    let normalized = normalizeArgs(...arguments);
+    this.logger.info(normalized.message, Object.assign(normalized.properties, this.ctx));
+  }
+  error() {
+    let normalized = normalizeArgs(...arguments);
+    this.logger.error(normalized.message, Object.assign(normalized.properties, this.ctx), normalized.error);
+  }
+  context(key, value) {
+    if (typeof key === "string") {
+      this.ctx[key] = value;
+    } else if (typeof key === "object") {
+      Object.assign(this.ctx, key);
+    }
+    return this;
+  }
+}
+export {
+  DatadogLogger
+};