@leanbase-giangnd/js 0.0.4 → 0.0.7

package/dist/index.mjs

@@ -1,6 +1,4 @@
-import { isArray, isString, isNullish, isFormData, hasOwnProperty, isNumber, isNull, PostHogPersistedProperty, isUndefined, isFile, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, isBoolean, trim, clampToRange, BucketedRateLimiter, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
-import { strFromU8, gzipSync, strToU8, decompressSync } from 'fflate';
-import { record } from '@rrweb/record';
+import { isArray, isString, isNullish, isFormData, hasOwnProperty, isNumber, isNull, PostHogPersistedProperty, isUndefined, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, isBoolean, trim, clampToRange, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
 
 const breaker = {};
 const ArrayProto = Array.prototype;
@@ -10,7 +8,7 @@ const win = typeof window !== 'undefined' ? window : undefined;
 const global = typeof globalThis !== 'undefined' ? globalThis : win;
 const navigator$1 = global?.navigator;
 const document = global?.document;
-const location$1 = global?.location;
+const location = global?.location;
 global?.fetch;
 global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined;
 global?.AbortController;
@@ -197,13 +195,10 @@ const EVENT_TIMERS_KEY = '__timers';
 const AUTOCAPTURE_DISABLED_SERVER_SIDE = '$autocapture_disabled_server_side';
 const HEATMAPS_ENABLED_SERVER_SIDE = '$heatmaps_enabled_server_side';
 const ERROR_TRACKING_SUPPRESSION_RULES = '$error_tracking_suppression_rules';
-const SESSION_RECORDING_REMOTE_CONFIG = '$session_recording_remote_config';
 // @deprecated can be removed along with eager loaded replay
 const SESSION_RECORDING_ENABLED_SERVER_SIDE = '$session_recording_enabled_server_side';
 const SESSION_ID = '$sesid';
 const SESSION_RECORDING_IS_SAMPLED = '$session_is_sampled';
-const SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION = '$session_recording_url_trigger_activated_session';
-const SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION = '$session_recording_event_trigger_activated_session';
 const ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
 const PERSISTENCE_EARLY_ACCESS_FEATURES = '$early_access_features';
 const PERSISTENCE_FEATURE_FLAG_DETAILS = '$feature_flag_details';
@@ -228,7 +223,7 @@ PostHogPersistedProperty.Queue, PostHogPersistedProperty.FeatureFlagDetails, Pos
 
 /* eslint-disable no-console */
 const PREFIX = '[Leanbase]';
-const logger$3 = {
+const logger = {
   info: (...args) => {
     if (typeof console !== 'undefined') {
       console.log(PREFIX, ...args);
@@ -526,7 +521,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
     if (!matchedSubDomain) {
       const originalMatch = originalCookieDomainFn(hostname);
       if (originalMatch !== matchedSubDomain) {
-        logger$3.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
+        logger.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
       }
       matchedSubDomain = originalMatch;
     }
@@ -538,7 +533,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
 const cookieStore = {
   _is_supported: () => !!document,
   _error: function (msg) {
-    logger$3.error('cookieStore error: ' + msg);
+    logger.error('cookieStore error: ' + msg);
   },
   _get: function (name) {
     if (!document) {
@@ -587,7 +582,7 @@ const cookieStore = {
       const new_cookie_val = name + '=' + encodeURIComponent(JSON.stringify(value)) + expires + '; SameSite=Lax; path=/' + cdomain + secure;
       // 4096 bytes is the size at which some browsers (e.g. firefox) will not store a cookie, warn slightly before that
       if (new_cookie_val.length > 4096 * 0.9) {
-        logger$3.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length);
+        logger.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length);
       }
       document.cookie = new_cookie_val;
       return new_cookie_val;
@@ -629,13 +624,13 @@ const localStore = {
       supported = false;
     }
     if (!supported) {
-      logger$3.error('localStorage unsupported; falling back to cookie store');
+      logger.error('localStorage unsupported; falling back to cookie store');
     }
     _localStorage_supported = supported;
     return supported;
   },
   _error: function (msg) {
-    logger$3.error('localStorage error: ' + msg);
+    logger.error('localStorage error: ' + msg);
   },
   _get: function (name) {
     try {
@@ -721,7 +716,7 @@ const memoryStore = {
     return true;
   },
   _error: function (msg) {
-    logger$3.error('memoryStorage error: ' + msg);
+    logger.error('memoryStorage error: ' + msg);
   },
   _get: function (name) {
     return memoryStorage[name] || null;
@@ -762,7 +757,7 @@ const sessionStore = {
     return sessionStorageSupported;
   },
   _error: function (msg) {
-    logger$3.error('sessionStorage error: ', msg);
+    logger.error('sessionStorage error: ', msg);
   },
   _get: function (name) {
     try {
@@ -796,7 +791,6 @@ const sessionStore = {
   }
 };
 
-const localDomains = ['localhost', '127.0.0.1'];
 /**
  * IE11 doesn't support `new URL`
  * so we can create an anchor element and use that to parse the URL
@@ -811,21 +805,6 @@ const convertToURL = url => {
   location.href = url;
   return location;
 };
-const formDataToQuery = function (formdata, arg_separator = '&') {
-  let use_val;
-  let use_key;
-  const tph_arr = [];
-  each(formdata, function (val, key) {
-    // the key might be literally the string undefined for e.g. if {undefined: 'something'}
-    if (isUndefined(val) || isUndefined(key) || key === 'undefined') {
-      return;
-    }
-    use_val = encodeURIComponent(isFile(val) ? val.name : val.toString());
-    use_key = encodeURIComponent(key);
-    tph_arr[tph_arr.length] = use_key + '=' + use_val;
-  });
-  return tph_arr.join(arg_separator);
-};
 // NOTE: Once we get rid of IE11/op_mini we can start using URLSearchParams
 const getQueryParam = function (url, param) {
   const withoutHash = url.split('#')[0] || '';
@@ -849,7 +828,7 @@ const getQueryParam = function (url, param) {
     try {
       result = decodeURIComponent(result);
     } catch {
-      logger$3.error('Skipping decoding for malformed query param: ' + result);
+      logger.error('Skipping decoding for malformed query param: ' + result);
     }
     return result.replace(/\+/g, ' ');
   }
@@ -888,9 +867,6 @@ const maskQueryParams = function (url, maskedParams, mask) {
   }
   return result;
 };
-const isLocalhost = () => {
-  return localDomains.includes(location.hostname);
-};
 
 /**
  * this device detection code is (at time of writing) about 3% of the size of the entire library
@@ -1183,7 +1159,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.0.4";
+var version = "0.0.7";
 var packageInfo = {
 	version: version};
 
@@ -1333,7 +1309,7 @@ function getReferrerInfo() {
 }
 function getPersonInfo(maskPersonalDataProperties, customPersonalDataProperties) {
   const paramsToMask = maskPersonalDataProperties ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || []) : [];
-  const url = location$1?.href.substring(0, 1000);
+  const url = location?.href.substring(0, 1000);
   // we're being a bit more economical with bytes here because this is stored in the cookie
   return {
     r: getReferrer().substring(0, 1000),
@@ -1401,9 +1377,9 @@ function getEventProperties(maskPersonalDataProperties, customPersonalDataProper
     $timezone: getTimezone(),
     $timezone_offset: getTimezoneOffset()
   }), {
-    $current_url: maskQueryParams(location$1?.href, paramsToMask, MASKED),
-    $host: location$1?.host,
-    $pathname: location$1?.pathname,
+    $current_url: maskQueryParams(location?.href, paramsToMask, MASKED),
+    $host: location?.host,
+    $pathname: location?.pathname,
     $raw_user_agent: userAgent.length > 1000 ? userAgent.substring(0, 997) + '...' : userAgent,
     $browser_version: detectBrowserVersion(userAgent, navigator.vendor),
     $browser_language: getBrowserLanguage(),
@@ -1448,7 +1424,7 @@ class LeanbasePersistence {
     this._storage = this._buildStorage(config);
     this.load();
     if (config.debug) {
-      logger$3.info('Persistence loaded', config['persistence'], {
+      logger.info('Persistence loaded', config['persistence'], {
         ...this.props
       });
     }
@@ -1464,7 +1440,7 @@ class LeanbasePersistence {
   }
   _buildStorage(config) {
     if (CASE_INSENSITIVE_PERSISTENCE_TYPES.indexOf(config['persistence'].toLowerCase()) === -1) {
-      logger$3.info('Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie');
+      logger.info('Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie');
       config['persistence'] = 'localStorage+cookie';
     }
     let store;
@@ -2100,7 +2076,7 @@ function getNestedSpanText(target) {
             text = `${text} ${getNestedSpanText(child)}`.trim();
           }
         } catch (e) {
-          logger$3.error('[AutoCapture]', e);
+          logger.error('[AutoCapture]', e);
         }
       }
     });
@@ -2402,7 +2378,7 @@ class Autocapture {
   }
   _addDomEventHandlers() {
     if (!this.isBrowserSupported()) {
-      logger$3.info('Disabling Automatic Event Collection because this browser is not supported');
+      logger.info('Disabling Automatic Event Collection because this browser is not supported');
       return;
     }
     if (!win || !document) {
@@ -2413,7 +2389,7 @@ class Autocapture {
       try {
         this._captureEvent(e);
       } catch (error) {
-        logger$3.error('Failed to capture event', error);
+        logger.error('Failed to capture event', error);
       }
     };
     addEventListener(document, 'submit', handler, {
@@ -2598,7 +2574,7 @@ class SessionIdManager {
     this._windowIdGenerator = windowIdGenerator || uuidv7;
     const persistenceName = this._config['persistence_name'] || this._config['token'];
     const desiredTimeout = this._config['session_idle_timeout_seconds'] || DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS;
-    this._sessionTimeoutMs = clampToRange(desiredTimeout, MIN_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, logger$3, DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS) * 1000;
+    this._sessionTimeoutMs = clampToRange(desiredTimeout, MIN_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, logger, DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS) * 1000;
     instance.register({
       $configured_session_timeout_ms: this._sessionTimeoutMs
     });
@@ -2625,7 +2601,7 @@ class SessionIdManager {
         const sessionStartTimestamp = uuid7ToTimestampMs(this._config.bootstrap.sessionID);
         this._setSessionId(this._config.bootstrap.sessionID, new Date().getTime(), sessionStartTimestamp);
       } catch (e) {
-        logger$3.error('Invalid sessionID in bootstrap', e);
+        logger.error('Invalid sessionID in bootstrap', e);
       }
     }
     this._listenToReloadWindow();
@@ -2766,7 +2742,7 @@ class SessionIdManager {
     if (noSessionId || activityTimeout || sessionPastMaximumLength) {
       sessionId = this._sessionIdGenerator();
       windowId = this._windowIdGenerator();
-      logger$3.info('new session ID generated', {
+      logger.info('new session ID generated', {
         sessionId,
         windowId,
         changeReason: {
@@ -2895,6 +2871,67 @@ class SessionPropsManager {
   }
 }
 
+var RequestRouterRegion;
+(function (RequestRouterRegion) {
+  RequestRouterRegion["US"] = "us";
+  RequestRouterRegion["EU"] = "eu";
+  RequestRouterRegion["CUSTOM"] = "custom";
+})(RequestRouterRegion || (RequestRouterRegion = {}));
+const ingestionDomain = 'i.posthog.com';
+class RequestRouter {
+  constructor(instance) {
+    this._regionCache = {};
+    this.instance = instance;
+  }
+  get apiHost() {
+    const host = this.instance.config.api_host.trim().replace(/\/$/, '');
+    if (host === 'https://app.posthog.com') {
+      return 'https://us.i.posthog.com';
+    }
+    return host;
+  }
+  get uiHost() {
+    let host = this.instance.config.ui_host?.replace(/\/$/, '');
+    if (!host) {
+      host = this.apiHost.replace(`.${ingestionDomain}`, '.posthog.com');
+    }
+    if (host === 'https://app.posthog.com') {
+      return 'https://us.posthog.com';
+    }
+    return host;
+  }
+  get region() {
+    if (!this._regionCache[this.apiHost]) {
+      if (/https:\/\/(app|us|us-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {
+        this._regionCache[this.apiHost] = RequestRouterRegion.US;
+      } else if (/https:\/\/(eu|eu-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {
+        this._regionCache[this.apiHost] = RequestRouterRegion.EU;
+      } else {
+        this._regionCache[this.apiHost] = RequestRouterRegion.CUSTOM;
+      }
+    }
+    return this._regionCache[this.apiHost];
+  }
+  endpointFor(target, path = '') {
+    if (path) {
+      path = path[0] === '/' ? path : `/${path}`;
+    }
+    if (target === 'ui') {
+      return this.uiHost + path;
+    }
+    if (this.region === RequestRouterRegion.CUSTOM) {
+      return this.apiHost + path;
+    }
+    const suffix = ingestionDomain + path;
+    switch (target) {
+      case 'assets':
+        return `https://${this.region}-assets.${suffix}`;
+      case 'api':
+        return `https://${this.region}.${suffix}`;
+    }
+  }
+}
+
 // This keeps track of the PageView state (such as the previous PageView's path, timestamp, id, and scroll properties).
 // We store the state in memory, which means that for non-SPA sites, the state will be lost on page reload. This means
 // that non-SPA sites should always send a $pageleave event on any navigation, before the page unloads. For SPA sites,
@@ -2955,10 +2992,10 @@ class PageViewManager {
         lastContentY = Math.ceil(lastContentY);
         maxContentY = Math.ceil(maxContentY);
         // if the maximum scroll height is near 0, then the percentage is 1
-        const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger$3);
-        const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger$3);
-        const lastContentPercentage = maxContentHeight <= 1 ? 1 : clampToRange(lastContentY / maxContentHeight, 0, 1, logger$3);
-        const maxContentPercentage = maxContentHeight <= 1 ? 1 : clampToRange(maxContentY / maxContentHeight, 0, 1, logger$3);
+        const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger);
+        const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger);
+        const lastContentPercentage = maxContentHeight <= 1 ? 1 : clampToRange(lastContentY / maxContentHeight, 0, 1, logger);
+        const maxContentPercentage = maxContentHeight <= 1 ? 1 : clampToRange(maxContentY / maxContentHeight, 0, 1, logger);
         properties = extend(properties, {
           $prev_pageview_last_scroll: lastScrollY,
           $prev_pageview_last_scroll_percentage: lastScrollPercentage,
@@ -3121,2846 +3158,202 @@ const isLikelyBot = function (navigator, customBlockedUserAgents) {
   // It would be very bad if posthog-js caused a permission prompt to appear on every page load.
 };
 
-// Type definitions copied from @rrweb/types@2.0.0-alpha.17 and rrweb-snapshot@2.0.0-alpha.17
-// Both packages are MIT licensed: https://github.com/rrweb-io/rrweb
-//
-// These types are copied here to avoid requiring users to install peer dependencies
-// solely for TypeScript type information.
-//
-// Original sources:
-// - @rrweb/types: https://github.com/rrweb-io/rrweb/tree/main/packages/@rrweb/types
-// - rrweb-snapshot: https://github.com/rrweb-io/rrweb/tree/main/packages/rrweb-snapshot
-var NodeType;
-(function (NodeType) {
-  NodeType[NodeType["Document"] = 0] = "Document";
-  NodeType[NodeType["DocumentType"] = 1] = "DocumentType";
-  NodeType[NodeType["Element"] = 2] = "Element";
-  NodeType[NodeType["Text"] = 3] = "Text";
-  NodeType[NodeType["CDATA"] = 4] = "CDATA";
-  NodeType[NodeType["Comment"] = 5] = "Comment";
-})(NodeType || (NodeType = {}));
-var EventType;
-(function (EventType) {
-  EventType[EventType["DomContentLoaded"] = 0] = "DomContentLoaded";
-  EventType[EventType["Load"] = 1] = "Load";
-  EventType[EventType["FullSnapshot"] = 2] = "FullSnapshot";
-  EventType[EventType["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
-  EventType[EventType["Meta"] = 4] = "Meta";
-  EventType[EventType["Custom"] = 5] = "Custom";
-  EventType[EventType["Plugin"] = 6] = "Plugin";
-})(EventType || (EventType = {}));
-var IncrementalSource;
-(function (IncrementalSource) {
-  IncrementalSource[IncrementalSource["Mutation"] = 0] = "Mutation";
-  IncrementalSource[IncrementalSource["MouseMove"] = 1] = "MouseMove";
-  IncrementalSource[IncrementalSource["MouseInteraction"] = 2] = "MouseInteraction";
-  IncrementalSource[IncrementalSource["Scroll"] = 3] = "Scroll";
-  IncrementalSource[IncrementalSource["ViewportResize"] = 4] = "ViewportResize";
-  IncrementalSource[IncrementalSource["Input"] = 5] = "Input";
-  IncrementalSource[IncrementalSource["TouchMove"] = 6] = "TouchMove";
-  IncrementalSource[IncrementalSource["MediaInteraction"] = 7] = "MediaInteraction";
-  IncrementalSource[IncrementalSource["StyleSheetRule"] = 8] = "StyleSheetRule";
-  IncrementalSource[IncrementalSource["CanvasMutation"] = 9] = "CanvasMutation";
-  IncrementalSource[IncrementalSource["Font"] = 10] = "Font";
-  IncrementalSource[IncrementalSource["Log"] = 11] = "Log";
-  IncrementalSource[IncrementalSource["Drag"] = 12] = "Drag";
-  IncrementalSource[IncrementalSource["StyleDeclaration"] = 13] = "StyleDeclaration";
-  IncrementalSource[IncrementalSource["Selection"] = 14] = "Selection";
-  IncrementalSource[IncrementalSource["AdoptedStyleSheet"] = 15] = "AdoptedStyleSheet";
-  IncrementalSource[IncrementalSource["CustomElement"] = 16] = "CustomElement";
-})(IncrementalSource || (IncrementalSource = {}));
-var MouseInteractions;
-(function (MouseInteractions) {
-  MouseInteractions[MouseInteractions["MouseUp"] = 0] = "MouseUp";
-  MouseInteractions[MouseInteractions["MouseDown"] = 1] = "MouseDown";
-  MouseInteractions[MouseInteractions["Click"] = 2] = "Click";
-  MouseInteractions[MouseInteractions["ContextMenu"] = 3] = "ContextMenu";
-  MouseInteractions[MouseInteractions["DblClick"] = 4] = "DblClick";
-  MouseInteractions[MouseInteractions["Focus"] = 5] = "Focus";
-  MouseInteractions[MouseInteractions["Blur"] = 6] = "Blur";
-  MouseInteractions[MouseInteractions["TouchStart"] = 7] = "TouchStart";
-  MouseInteractions[MouseInteractions["TouchMove_Departed"] = 8] = "TouchMove_Departed";
-  MouseInteractions[MouseInteractions["TouchEnd"] = 9] = "TouchEnd";
-  MouseInteractions[MouseInteractions["TouchCancel"] = 10] = "TouchCancel";
-})(MouseInteractions || (MouseInteractions = {}));
-var PointerTypes;
-(function (PointerTypes) {
-  PointerTypes[PointerTypes["Mouse"] = 0] = "Mouse";
-  PointerTypes[PointerTypes["Pen"] = 1] = "Pen";
-  PointerTypes[PointerTypes["Touch"] = 2] = "Touch";
-})(PointerTypes || (PointerTypes = {}));
-var MediaInteractions;
-(function (MediaInteractions) {
-  MediaInteractions[MediaInteractions["Play"] = 0] = "Play";
-  MediaInteractions[MediaInteractions["Pause"] = 1] = "Pause";
-  MediaInteractions[MediaInteractions["Seeked"] = 2] = "Seeked";
-  MediaInteractions[MediaInteractions["VolumeChange"] = 3] = "VolumeChange";
-  MediaInteractions[MediaInteractions["RateChange"] = 4] = "RateChange";
-})(MediaInteractions || (MediaInteractions = {}));
-var CanvasContext;
-(function (CanvasContext) {
-  CanvasContext[CanvasContext["2D"] = 0] = "2D";
-  CanvasContext[CanvasContext["WebGL"] = 1] = "WebGL";
-  CanvasContext[CanvasContext["WebGL2"] = 2] = "WebGL2";
-})(CanvasContext || (CanvasContext = {}));
-
-const _createLogger = prefix => {
-  return {
-    info: (...args) => logger$3.info(prefix, ...args),
-    warn: (...args) => logger$3.warn(prefix, ...args),
-    error: (...args) => logger$3.error(prefix, ...args),
-    critical: (...args) => logger$3.critical(prefix, ...args),
-    uninitializedWarning: methodName => {
-      logger$3.error(prefix, `You must initialize Leanbase before calling ${methodName}`);
-    },
-    createLogger: additionalPrefix => _createLogger(`${prefix} ${additionalPrefix}`)
-  };
-};
-const logger$2 = _createLogger('[Leanbase]');
-const createLogger = _createLogger;
-
-const LOGGER_PREFIX$2 = '[SessionRecording]';
-const REDACTED = 'redacted';
-const defaultNetworkOptions = {
-  initiatorTypes: ['audio', 'beacon', 'body', 'css', 'early-hints', 'embed', 'fetch', 'frame', 'iframe', 'image', 'img', 'input', 'link', 'navigation', 'object', 'ping', 'script', 'track', 'video', 'xmlhttprequest'],
-  maskRequestFn: data => data,
-  recordHeaders: false,
-  recordBody: false,
-  recordInitialRequests: false,
-  recordPerformance: false,
-  performanceEntryTypeToObserve: [
-  // 'event', // This is too noisy as it covers all browser events
-  'first-input',
-  // 'mark', // Mark is used too liberally. We would need to filter for specific marks
-  // 'measure', // Measure is used too liberally. We would need to filter for specific measures
-  'navigation', 'paint', 'resource'],
-  payloadSizeLimitBytes: 1000000,
-  payloadHostDenyList: ['.lr-ingest.io', '.ingest.sentry.io', '.clarity.ms',
-  // NB no leading dot here
-  'analytics.google.com', 'bam.nr-data.net']
-};
-const HEADER_DENY_LIST = ['authorization', 'x-forwarded-for', 'authorization', 'cookie', 'set-cookie', 'x-api-key', 'x-real-ip', 'remote-addr', 'forwarded', 'proxy-authorization', 'x-csrf-token', 'x-csrftoken', 'x-xsrf-token'];
-const PAYLOAD_CONTENT_DENY_LIST = ['password', 'secret', 'passwd', 'api_key', 'apikey', 'auth', 'credentials', 'mysql_pwd', 'privatekey', 'private_key', 'token'];
-// we always remove headers on the deny list because we never want to capture this sensitive data
-const removeAuthorizationHeader = data => {
-  const headers = data.requestHeaders;
-  if (!isNullish(headers)) {
-    const mutableHeaders = isArray(headers) ? Object.fromEntries(headers) : headers;
-    each(Object.keys(mutableHeaders ?? {}), header => {
-      if (HEADER_DENY_LIST.includes(header.toLowerCase())) {
-        mutableHeaders[header] = REDACTED;
-      }
+const defaultConfig = () => ({
+  host: 'https://i.leanbase.co',
+  api_host: 'https://i.leanbase.co',
+  token: '',
+  autocapture: true,
+  rageclick: true,
+  persistence: 'localStorage+cookie',
+  capture_pageview: 'history_change',
+  capture_pageleave: 'if_capture_pageview',
+  persistence_name: '',
+  mask_all_element_attributes: false,
+  cookie_expiration: 365,
+  cross_subdomain_cookie: isCrossDomainCookie(document?.location),
+  custom_campaign_params: [],
+  custom_personal_data_properties: [],
+  disable_persistence: false,
+  mask_personal_data_properties: false,
+  secure_cookie: window?.location?.protocol === 'https:',
+  mask_all_text: false,
+  bootstrap: {},
+  session_idle_timeout_seconds: 30 * 60,
+  save_campaign_params: true,
+  save_referrer: true,
+  opt_out_useragent_filter: false,
+  properties_string_max_length: 65535,
+  loaded: () => {},
+  session_recording: {}
+});
+class Leanbase extends PostHogCore {
+  constructor(token, config) {
+    const mergedConfig = extend(defaultConfig(), config || {}, {
+      token
     });
-    data.requestHeaders = mutableHeaders;
-  }
-  return data;
-};
-const POSTHOG_PATHS_TO_IGNORE = ['/s/', '/e/', '/i/'];
-// want to ignore posthog paths when capturing requests, or we can get trapped in a loop
-// because calls to PostHog would be reported using a call to PostHog which would be reported....
-const ignorePostHogPaths = (data, apiHostConfig) => {
-  const url = convertToURL(data.name);
-  const host = apiHostConfig || '';
-  let replaceValue = host.indexOf('http') === 0 ? convertToURL(host)?.pathname : host;
-  if (replaceValue === '/') {
-    replaceValue = '';
-  }
-  const pathname = url?.pathname.replace(replaceValue || '', '');
-  if (url && pathname && POSTHOG_PATHS_TO_IGNORE.some(path => pathname.indexOf(path) === 0)) {
-    return undefined;
-  }
-  return data;
-};
-function estimateBytes(payload) {
-  return new Blob([payload]).size;
-}
-function enforcePayloadSizeLimit(payload, headers, limit, description) {
-  if (isNullish(payload)) {
-    return payload;
-  }
-  let requestContentLength = headers?.['content-length'] || estimateBytes(payload);
-  if (isString(requestContentLength)) {
-    requestContentLength = parseInt(requestContentLength);
-  }
-  if (requestContentLength > limit) {
-    return LOGGER_PREFIX$2 + ` ${description} body too large to record (${requestContentLength} bytes)`;
-  }
-  return payload;
-}
-// people can have arbitrarily large payloads on their site, but we don't want to ingest them
-const limitPayloadSize = options => {
-  // the smallest of 1MB or the specified limit if there is one
-  const limit = Math.min(1000000, options.payloadSizeLimitBytes ?? 1000000);
-  return data => {
-    if (data?.requestBody) {
-      data.requestBody = enforcePayloadSizeLimit(data.requestBody, data.requestHeaders, limit, 'Request');
-    }
-    if (data?.responseBody) {
-      data.responseBody = enforcePayloadSizeLimit(data.responseBody, data.responseHeaders, limit, 'Response');
-    }
-    return data;
-  };
-};
-function scrubPayload(payload, label) {
-  if (isNullish(payload)) {
-    return payload;
-  }
-  let scrubbed = payload;
-  if (!shouldCaptureValue(scrubbed, false)) {
-    scrubbed = LOGGER_PREFIX$2 + ' ' + label + ' body ' + REDACTED;
+    super(token, mergedConfig);
+    this.personProcessingSetOncePropertiesSent = false;
+    this.isLoaded = false;
+    this.config = mergedConfig;
+    this.visibilityStateListener = null;
+    this.initialPageviewCaptured = false;
+    this.scrollManager = new ScrollManager(this);
+    this.pageViewManager = new PageViewManager(this);
+    this.requestRouter = new RequestRouter(this);
+    this.init(token, mergedConfig);
   }
-  each(PAYLOAD_CONTENT_DENY_LIST, text => {
-    if (scrubbed?.length && scrubbed?.indexOf(text) !== -1) {
-      scrubbed = LOGGER_PREFIX$2 + ' ' + label + ' body ' + REDACTED + ' as might contain: ' + text;
+  init(token, config) {
+    this.setConfig(extend(defaultConfig(), config, {
+      token
+    }));
+    this.isLoaded = true;
+    this.persistence = new LeanbasePersistence(this.config);
+    this.replayAutocapture = new Autocapture(this);
+    this.replayAutocapture.startIfEnabled();
+    // Initialize session manager and props before session recording (matches browser behavior)
+    if (this.config.cookieless_mode !== 'always') {
+      if (!this.sessionManager) {
+        this.sessionManager = new SessionIdManager(this);
+        this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence);
+      }
+      // runtime require to lazy-load replay code; allowed for browser parity
+      // @ts-expect-error - runtime import only available in browser build
+      const {
+        SessionRecording
+      } = require('./extensions/replay/session-recording'); // eslint-disable-line @typescript-eslint/no-require-imports
+      this.sessionRecording = new SessionRecording(this);
+      this.sessionRecording.startIfEnabledOrStop();
     }
-  });
-  return scrubbed;
-}
-function scrubPayloads(capturedRequest) {
-  if (isUndefined(capturedRequest)) {
-    return undefined;
-  }
-  capturedRequest.requestBody = scrubPayload(capturedRequest.requestBody, 'Request');
-  capturedRequest.responseBody = scrubPayload(capturedRequest.responseBody, 'Response');
-  return capturedRequest;
-}
-/**
- *  whether a maskRequestFn is provided or not,
- *  we ensure that we remove the denied header from requests
- *  we _never_ want to record that header by accident
- *  if someone complains then we'll add an opt-in to let them override it
- */
-const buildNetworkRequestOptions = (instanceConfig, remoteNetworkOptions = {}) => {
-  const remoteOptions = remoteNetworkOptions || {};
-  const config = {
-    payloadSizeLimitBytes: defaultNetworkOptions.payloadSizeLimitBytes,
-    performanceEntryTypeToObserve: [...defaultNetworkOptions.performanceEntryTypeToObserve],
-    payloadHostDenyList: [...(remoteOptions.payloadHostDenyList || []), ...defaultNetworkOptions.payloadHostDenyList]
-  };
-  // client can always disable despite remote options
-  const sessionRecordingConfig = instanceConfig.session_recording || {};
-  const capturePerformanceConfig = instanceConfig.capture_performance;
-  const userPerformanceOptIn = isBoolean(capturePerformanceConfig) ? capturePerformanceConfig : !!capturePerformanceConfig?.network_timing;
-  const canRecordHeaders = sessionRecordingConfig.recordHeaders === true && !!remoteOptions.recordHeaders;
-  const canRecordBody = sessionRecordingConfig.recordBody === true && !!remoteOptions.recordBody;
-  const canRecordPerformance = userPerformanceOptIn && !!remoteOptions.recordPerformance;
-  const payloadLimiter = limitPayloadSize(config);
-  const enforcedCleaningFn = d => payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.host || ''));
-  const hasDeprecatedMaskFunction = isFunction(sessionRecordingConfig.maskNetworkRequestFn);
-  if (hasDeprecatedMaskFunction && isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)) {
-    logger$2.warn('Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.');
-  }
-  if (hasDeprecatedMaskFunction) {
-    sessionRecordingConfig.maskCapturedNetworkRequestFn = data => {
-      const cleanedURL = sessionRecordingConfig.maskNetworkRequestFn({
-        url: data.name
-      });
-      return {
-        ...data,
-        name: cleanedURL?.url
-      };
-    };
-  }
-  config.maskRequestFn = isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn) ? data => {
-    const cleanedRequest = enforcedCleaningFn(data);
-    return cleanedRequest ? sessionRecordingConfig.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined : undefined;
-  } : data => scrubPayloads(enforcedCleaningFn(data));
-  return {
-    ...defaultNetworkOptions,
-    ...config,
-    recordHeaders: canRecordHeaders,
-    recordBody: canRecordBody,
-    recordPerformance: canRecordPerformance,
-    recordInitialRequests: canRecordPerformance
-  };
-};
-
-function patch(source, name, replacement) {
-  try {
-    if (!(name in source)) {
-      return () => {
-        //
-      };
+    if (this.config.preloadFeatureFlags !== false) {
+      this.reloadFeatureFlags();
     }
-    const original = source[name];
-    const wrapped = replacement(original);
-    if (isFunction(wrapped)) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      wrapped.prototype = wrapped.prototype || {};
-      Object.defineProperties(wrapped, {
-        __posthog_wrapped__: {
-          enumerable: false,
-          value: true
+    this.config.loaded?.(this);
+    if (this.config.capture_pageview) {
+      setTimeout(() => {
+        if (this.config.cookieless_mode === 'always') {
+          this.captureInitialPageview();
         }
-      });
+      }, 1);
     }
-    source[name] = wrapped;
-    return () => {
-      source[name] = original;
-    };
-  } catch {
-    return () => {
-      //
-    };
+    addEventListener(document, 'DOMContentLoaded', () => {
+      this.loadRemoteConfig();
+    });
+    addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
+      passive: false
+    });
   }
-}
-
-function hostnameFromURL(url) {
-  try {
-    if (typeof url === 'string') {
-      return new URL(url).hostname;
+  captureInitialPageview() {
+    if (!document) {
+      return;
     }
-    if ('url' in url) {
-      return new URL(url.url).hostname;
+    if (document.visibilityState !== 'visible') {
+      if (!this.visibilityStateListener) {
+        this.visibilityStateListener = this.captureInitialPageview.bind(this);
+        addEventListener(document, 'visibilitychange', this.visibilityStateListener);
+      }
+      return;
+    }
+    if (!this.initialPageviewCaptured) {
+      this.initialPageviewCaptured = true;
+      this.capture('$pageview', {
+        title: document.title
+      });
+      if (this.visibilityStateListener) {
+        document.removeEventListener('visibilitychange', this.visibilityStateListener);
+        this.visibilityStateListener = null;
+      }
     }
-    return url.hostname;
-  } catch {
-    return null;
-  }
-}
-function isHostOnDenyList(url, options) {
-  const hostname = hostnameFromURL(url);
-  const defaultNotDenied = {
-    hostname,
-    isHostDenied: false
-  };
-  if (!options.payloadHostDenyList?.length || !hostname?.trim().length) {
-    return defaultNotDenied;
   }
-  for (const deny of options.payloadHostDenyList) {
-    if (hostname.endsWith(deny)) {
-      return {
-        hostname,
-        isHostDenied: true
-      };
+  capturePageLeave() {
+    const {
+      capture_pageleave,
+      capture_pageview
+    } = this.config;
+    if (capture_pageleave === true || capture_pageleave === 'if_capture_pageview' && (capture_pageview === true || capture_pageview === 'history_change')) {
+      this.capture('$pageleave');
     }
   }
-  return defaultNotDenied;
-}
-
-/// <reference lib="dom" />
-const logger$1 = createLogger('[Recorder]');
-const isNavigationTiming = entry => entry.entryType === 'navigation';
-const isResourceTiming = entry => entry.entryType === 'resource';
-function findLast(array, predicate) {
-  const length = array.length;
-  for (let i = length - 1; i >= 0; i -= 1) {
-    if (predicate(array[i])) {
-      return array[i];
-    }
-  }
-  return undefined;
-}
-function isDocument(value) {
-  return !!value && typeof value === 'object' && 'nodeType' in value && value.nodeType === 9;
-}
-function initPerformanceObserver(cb, win, options) {
-  // if we are only observing timings then we could have a single observer for all types, with buffer true,
-  // but we are going to filter by initiatorType _if we are wrapping fetch and xhr as the wrapped functions
-  // will deal with those.
-  // so we have a block which captures requests from before fetch/xhr is wrapped
-  // these are marked `isInitial` so playback can display them differently if needed
-  // they will never have method/status/headers/body because they are pre-wrapping that provides that
-  if (options.recordInitialRequests) {
-    const initialPerformanceEntries = win.performance.getEntries().filter(entry => isNavigationTiming(entry) || isResourceTiming(entry) && options.initiatorTypes.includes(entry.initiatorType));
-    cb({
-      requests: initialPerformanceEntries.flatMap(entry => prepareRequest({
-        entry,
-        method: undefined,
-        status: undefined,
-        networkRequest: {},
-        isInitial: true
-      })),
-      isInitial: true
-    });
+  async loadRemoteConfig() {
+    if (!this.isRemoteConfigLoaded) {
+      const remoteConfig = await this.reloadRemoteConfigAsync();
+      if (remoteConfig) {
+        this.onRemoteConfig(remoteConfig);
+      }
+    }
   }
-  const observer = new win.PerformanceObserver(entries => {
-    // if recordBody or recordHeaders is true then we don't want to record fetch or xhr here
-    // as the wrapped functions will do that. Otherwise, this filter becomes a noop
-    // because we do want to record them here
-    const wrappedInitiatorFilter = entry => options.recordBody || options.recordHeaders ? entry.initiatorType !== 'xmlhttprequest' && entry.initiatorType !== 'fetch' : true;
-    const performanceEntries = entries.getEntries().filter(entry => isNavigationTiming(entry) || isResourceTiming(entry) && options.initiatorTypes.includes(entry.initiatorType) &&
-    // TODO if we are _only_ capturing timing we don't want to filter initiator here
-    wrappedInitiatorFilter(entry));
-    cb({
-      requests: performanceEntries.flatMap(entry => prepareRequest({
-        entry,
-        method: undefined,
-        status: undefined,
-        networkRequest: {}
-      }))
-    });
-  });
-  // compat checked earlier
-  // eslint-disable-next-line compat/compat
-  const entryTypes = PerformanceObserver.supportedEntryTypes.filter(x => options.performanceEntryTypeToObserve.includes(x));
-  // initial records are gathered above, so we don't need to observe and buffer each type separately
-  observer.observe({
-    entryTypes
-  });
-  return () => {
-    observer.disconnect();
-  };
-}
-function shouldRecordHeaders(type, recordHeaders) {
-  return !!recordHeaders && (isBoolean(recordHeaders) || recordHeaders[type]);
-}
-function shouldRecordBody({
-  type,
-  recordBody,
-  headers,
-  url
-}) {
-  function matchesContentType(contentTypes) {
-    const contentTypeHeader = Object.keys(headers).find(key => key.toLowerCase() === 'content-type');
-    const contentType = contentTypeHeader && headers[contentTypeHeader];
-    return contentTypes.some(ct => contentType?.includes(ct));
+  onRemoteConfig(config) {
+    if (!(document && document.body)) {
+      setTimeout(() => {
+        this.onRemoteConfig(config);
+      }, 500);
+      return;
+    }
+    this.isRemoteConfigLoaded = true;
+    this.replayAutocapture?.onRemoteConfig(config);
   }
-  /**
-   * particularly in canvas applications we see many requests to blob URLs
-   * e.g. blob:https://video_url
-   * these blob/object URLs are local to the browser, we can never capture that body
-   * so we can just return false here
-   */
-  function isBlobURL(url) {
-    try {
-      if (typeof url === 'string') {
-        return url.startsWith('blob:');
-      }
-      if (url instanceof URL) {
-        return url.protocol === 'blob:';
-      }
-      if (url instanceof Request) {
-        return isBlobURL(url.url);
-      }
-      return false;
-    } catch {
-      return false;
+  fetch(url, options) {
+    const fetchFn = getFetch();
+    if (!fetchFn) {
+      return Promise.reject(new Error('Fetch API is not available in this environment.'));
     }
+    return fetchFn(url, options);
   }
-  if (!recordBody) return false;
-  if (isBlobURL(url)) return false;
-  if (isBoolean(recordBody)) return true;
-  if (isArray(recordBody)) return matchesContentType(recordBody);
-  const recordBodyType = recordBody[type];
-  if (isBoolean(recordBodyType)) return recordBodyType;
-  return matchesContentType(recordBodyType);
-}
-async function getRequestPerformanceEntry(win, initiatorType, url, start, end, attempt = 0) {
-  if (attempt > 10) {
-    logger$1.warn('Failed to get performance entry for request', {
-      url,
-      initiatorType
+  setConfig(config) {
+    const oldConfig = {
+      ...this.config
+    };
+    if (isObject(config)) {
+      extend(this.config, config);
+      this.persistence?.update_config(this.config, oldConfig);
+      this.replayAutocapture?.startIfEnabled();
+    }
+    const isTempStorage = this.config.persistence === 'sessionStorage' || this.config.persistence === 'memory';
+    this.sessionPersistence = isTempStorage ? this.persistence : new LeanbasePersistence({
+      ...this.config,
+      persistence: 'sessionStorage'
     });
-    return null;
   }
-  const urlPerformanceEntries = win.performance.getEntriesByName(url);
-  const performanceEntry = findLast(urlPerformanceEntries, entry => isResourceTiming(entry) && entry.initiatorType === initiatorType && (isUndefined(start) || entry.startTime >= start) && (isUndefined(end) || entry.startTime <= end));
-  if (!performanceEntry) {
-    await new Promise(resolve => setTimeout(resolve, 50 * attempt));
-    return getRequestPerformanceEntry(win, initiatorType, url, start, end, attempt + 1);
+  getLibraryId() {
+    return 'leanbase';
   }
-  return performanceEntry;
-}
-/**
- * According to MDN https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/response
- * xhr response is typed as any but can be an ArrayBuffer, a Blob, a Document, a JavaScript object,
- * or a string, depending on the value of XMLHttpRequest.responseType, that contains the response entity body.
- *
- * XHR request body is Document | XMLHttpRequestBodyInit | null | undefined
- */
-function _tryReadXHRBody({
-  body,
-  options,
-  url
-}) {
-  if (isNullish(body)) {
-    return null;
+  getLibraryVersion() {
+    return Config.LIB_VERSION;
   }
-  const {
-    hostname,
-    isHostDenied
-  } = isHostOnDenyList(url, options);
-  if (isHostDenied) {
-    return hostname + ' is in deny list';
+  getCustomUserAgent() {
+    return;
+  }
+  getPersistedProperty(key) {
+    return this.persistence?.get_property(key);
   }
-  if (isString(body)) {
-    return body;
+  setPersistedProperty(key, value) {
+    this.persistence?.set_property(key, value);
   }
-  if (isDocument(body)) {
-    return body.textContent;
+  // Backwards-compatible aliases expected by replay/browser code
+  get_property(key) {
+    return this.persistence?.get_property(key);
   }
-  if (isFormData(body)) {
-    return formDataToQuery(body);
+  set_property(key, value) {
+    this.persistence?.set_property(key, value);
   }
-  if (isObject(body)) {
-    try {
-      return JSON.stringify(body);
-    } catch {
-      return '[SessionReplay] Failed to stringify response object';
+  register_for_session(properties) {
+    // PostHogCore may expose registerForSession; call it if available
+    if (isFunction(this.registerForSession)) {
+      this.registerForSession(properties);
+      return;
+    }
+    // fallback: store properties in sessionPersistence
+    if (this.sessionPersistence) {
+      Object.keys(properties).forEach(k => this.sessionPersistence?.set_property(k, properties[k]));
     }
   }
-  return '[SessionReplay] Cannot read body of type ' + toString.call(body);
-}
-function initXhrObserver(cb, win, options) {
-  if (!options.initiatorTypes.includes('xmlhttprequest')) {
-    return () => {
-      //
-    };
-  }
-  const recordRequestHeaders = shouldRecordHeaders('request', options.recordHeaders);
-  const recordResponseHeaders = shouldRecordHeaders('response', options.recordHeaders);
-  const restorePatch = patch(win.XMLHttpRequest.prototype, 'open',
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  originalOpen => {
-    return function (method, url, async = true, username, password) {
-      // because this function is returned in its actual context `this` _is_ an XMLHttpRequest
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      const xhr = this;
-      // check IE earlier than this, we only initialize if Request is present
-      // eslint-disable-next-line compat/compat
-      const req = new Request(url);
-      const networkRequest = {};
-      let start;
-      let end;
-      const requestHeaders = {};
-      const originalSetRequestHeader = xhr.setRequestHeader.bind(xhr);
-      xhr.setRequestHeader = (header, value) => {
-        requestHeaders[header] = value;
-        return originalSetRequestHeader(header, value);
-      };
-      if (recordRequestHeaders) {
-        networkRequest.requestHeaders = requestHeaders;
-      }
-      const originalSend = xhr.send.bind(xhr);
-      xhr.send = body => {
-        if (shouldRecordBody({
-          type: 'request',
-          headers: requestHeaders,
-          url,
-          recordBody: options.recordBody
-        })) {
-          networkRequest.requestBody = _tryReadXHRBody({
-            body,
-            options,
-            url
-          });
-        }
-        start = win.performance.now();
-        return originalSend(body);
-      };
-      const readyStateListener = () => {
-        if (xhr.readyState !== xhr.DONE) {
-          return;
-        }
-        // Clean up the listener immediately when done to prevent memory leaks
-        xhr.removeEventListener('readystatechange', readyStateListener);
-        end = win.performance.now();
-        const responseHeaders = {};
-        const rawHeaders = xhr.getAllResponseHeaders();
-        const headers = rawHeaders.trim().split(/[\r\n]+/);
-        headers.forEach(line => {
-          const parts = line.split(': ');
-          const header = parts.shift();
-          const value = parts.join(': ');
-          if (header) {
-            responseHeaders[header] = value;
-          }
-        });
-        if (recordResponseHeaders) {
-          networkRequest.responseHeaders = responseHeaders;
-        }
-        if (shouldRecordBody({
-          type: 'response',
-          headers: responseHeaders,
-          url,
-          recordBody: options.recordBody
-        })) {
-          networkRequest.responseBody = _tryReadXHRBody({
-            body: xhr.response,
-            options,
-            url
-          });
-        }
-        getRequestPerformanceEntry(win, 'xmlhttprequest', req.url, start, end).then(entry => {
-          const requests = prepareRequest({
-            entry,
-            method: method,
-            status: xhr?.status,
-            networkRequest,
-            start,
-            end,
-            url: url.toString(),
-            initiatorType: 'xmlhttprequest'
-          });
-          cb({
-            requests
-          });
-        }).catch(() => {
-          //
-        });
-      };
-      // This is very tricky code, and making it passive won't bring many performance benefits,
-      // so let's ignore the rule here.
-      // eslint-disable-next-line posthog-js/no-add-event-listener
-      xhr.addEventListener('readystatechange', readyStateListener);
-      originalOpen.call(xhr, method, url, async, username, password);
-    };
-  });
-  return () => {
-    restorePatch();
-  };
-}
-/**
- *  Check if this PerformanceEntry is either a PerformanceResourceTiming or a PerformanceNavigationTiming
- *  NB PerformanceNavigationTiming extends PerformanceResourceTiming
- *  Here we don't care which interface it implements as both expose `serverTimings`
- */
-const exposesServerTiming = event => !isNull(event) && (event.entryType === 'navigation' || event.entryType === 'resource');
-function prepareRequest({
-  entry,
-  method,
-  status,
-  networkRequest,
-  isInitial,
-  start,
-  end,
-  url,
-  initiatorType
-}) {
-  start = entry ? entry.startTime : start;
-  end = entry ? entry.responseEnd : end;
-  // kudos to sentry javascript sdk for excellent background on why to use Date.now() here
-  // https://github.com/getsentry/sentry-javascript/blob/e856e40b6e71a73252e788cd42b5260f81c9c88e/packages/utils/src/time.ts#L70
-  // can't start observer if performance.now() is not available
-  // eslint-disable-next-line compat/compat
-  const timeOrigin = Math.floor(Date.now() - performance.now());
-  // clickhouse can't ingest timestamps that are floats
-  // (in this case representing fractions of a millisecond we don't care about anyway)
-  // use timeOrigin if we really can't gather a start time
-  const timestamp = Math.floor(timeOrigin + (start || 0));
-  const entryJSON = entry ? entry.toJSON() : {
-    name: url
-  };
-  const requests = [{
-    ...entryJSON,
-    startTime: isUndefined(start) ? undefined : Math.round(start),
-    endTime: isUndefined(end) ? undefined : Math.round(end),
-    timeOrigin,
-    timestamp,
-    method: method,
-    initiatorType: initiatorType ? initiatorType : entry ? entry.initiatorType : undefined,
-    status,
-    requestHeaders: networkRequest.requestHeaders,
-    requestBody: networkRequest.requestBody,
-    responseHeaders: networkRequest.responseHeaders,
-    responseBody: networkRequest.responseBody,
-    isInitial
-  }];
-  if (exposesServerTiming(entry)) {
-    for (const timing of entry.serverTiming || []) {
-      requests.push({
-        timeOrigin,
-        timestamp,
-        startTime: Math.round(entry.startTime),
-        name: timing.name,
-        duration: timing.duration,
-        // the spec has a closed list of possible types
-        // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType
-        // but, we need to know this was a server timing so that we know to
-        // match it to the appropriate navigation or resource timing
-        // that matching will have to be on timestamp and $current_url
-        entryType: 'serverTiming'
-      });
-    }
-  }
-  return requests;
-}
-const contentTypePrefixDenyList = ['video/', 'audio/'];
-function _checkForCannotReadResponseBody({
-  r,
-  options,
-  url
-}) {
-  if (r.headers.get('Transfer-Encoding') === 'chunked') {
-    return 'Chunked Transfer-Encoding is not supported';
-  }
-  // `get` and `has` are case-insensitive
-  // but return the header value with the casing that was supplied
-  const contentType = r.headers.get('Content-Type')?.toLowerCase();
-  const contentTypeIsDenied = contentTypePrefixDenyList.some(prefix => contentType?.startsWith(prefix));
-  if (contentType && contentTypeIsDenied) {
-    return `Content-Type ${contentType} is not supported`;
-  }
-  const {
-    hostname,
-    isHostDenied
-  } = isHostOnDenyList(url, options);
-  if (isHostDenied) {
-    return hostname + ' is in deny list';
-  }
-  return null;
-}
-function _tryReadBody(r) {
-  // there are now already multiple places where we're using Promise...
-  // eslint-disable-next-line compat/compat
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => resolve('[SessionReplay] Timeout while trying to read body'), 500);
-    try {
-      r.clone().text().then(txt => resolve(txt), reason => reject(reason)).finally(() => clearTimeout(timeout));
-    } catch {
-      clearTimeout(timeout);
-      resolve('[SessionReplay] Failed to read body');
-    }
-  });
-}
-async function _tryReadRequestBody({
-  r,
-  options,
-  url
-}) {
-  const {
-    hostname,
-    isHostDenied
-  } = isHostOnDenyList(url, options);
-  if (isHostDenied) {
-    return Promise.resolve(hostname + ' is in deny list');
-  }
-  return _tryReadBody(r);
-}
-async function _tryReadResponseBody({
-  r,
-  options,
-  url
-}) {
-  const cannotReadBodyReason = _checkForCannotReadResponseBody({
-    r,
-    options,
-    url
-  });
-  if (!isNull(cannotReadBodyReason)) {
-    return Promise.resolve(cannotReadBodyReason);
-  }
-  return _tryReadBody(r);
-}
-function initFetchObserver(cb, win, options) {
-  if (!options.initiatorTypes.includes('fetch')) {
-    return () => {
-      //
-    };
-  }
-  const recordRequestHeaders = shouldRecordHeaders('request', options.recordHeaders);
-  const recordResponseHeaders = shouldRecordHeaders('response', options.recordHeaders);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  const restorePatch = patch(win, 'fetch', originalFetch => {
-    return async function (url, init) {
-      // check IE earlier than this, we only initialize if Request is present
-      // eslint-disable-next-line compat/compat
-      const req = new Request(url, init);
-      let res;
-      const networkRequest = {};
-      let start;
-      let end;
-      try {
-        const requestHeaders = {};
-        req.headers.forEach((value, header) => {
-          requestHeaders[header] = value;
-        });
-        if (recordRequestHeaders) {
-          networkRequest.requestHeaders = requestHeaders;
-        }
-        if (shouldRecordBody({
-          type: 'request',
-          headers: requestHeaders,
-          url,
-          recordBody: options.recordBody
-        })) {
-          networkRequest.requestBody = await _tryReadRequestBody({
-            r: req,
-            options,
-            url
-          });
-        }
-        start = win.performance.now();
-        res = await originalFetch(req);
-        end = win.performance.now();
-        const responseHeaders = {};
-        res.headers.forEach((value, header) => {
-          responseHeaders[header] = value;
-        });
-        if (recordResponseHeaders) {
-          networkRequest.responseHeaders = responseHeaders;
-        }
-        if (shouldRecordBody({
-          type: 'response',
-          headers: responseHeaders,
-          url,
-          recordBody: options.recordBody
-        })) {
-          networkRequest.responseBody = await _tryReadResponseBody({
-            r: res,
-            options,
-            url
-          });
-        }
-        return res;
-      } finally {
-        getRequestPerformanceEntry(win, 'fetch', req.url, start, end).then(entry => {
-          const requests = prepareRequest({
-            entry,
-            method: req.method,
-            status: res?.status,
-            networkRequest,
-            start,
-            end,
-            url: req.url,
-            initiatorType: 'fetch'
-          });
-          cb({
-            requests
-          });
-        }).catch(() => {
-          //
-        });
-      }
-    };
-  });
-  return () => {
-    restorePatch();
-  };
-}
-let initialisedHandler = null;
-function initNetworkObserver(callback, win,
-// top window or in an iframe
-options) {
-  if (!('performance' in win)) {
-    return () => {
-      //
-    };
-  }
-  if (initialisedHandler) {
-    logger$1.warn('Network observer already initialised, doing nothing');
-    return () => {
-      // the first caller should already have this handler and will be responsible for teardown
-    };
-  }
-  const networkOptions = options ? Object.assign({}, defaultNetworkOptions, options) : defaultNetworkOptions;
-  const cb = data => {
-    const requests = [];
-    data.requests.forEach(request => {
-      const maskedRequest = networkOptions.maskRequestFn(request);
-      if (maskedRequest) {
-        requests.push(maskedRequest);
-      }
-    });
-    if (requests.length > 0) {
-      callback({
-        ...data,
-        requests
-      });
-    }
-  };
-  const performanceObserver = initPerformanceObserver(cb, win, networkOptions);
-  // only wrap fetch and xhr if headers or body are being recorded
-  let xhrObserver = () => {};
-  let fetchObserver = () => {};
-  if (networkOptions.recordHeaders || networkOptions.recordBody) {
-    xhrObserver = initXhrObserver(cb, win, networkOptions);
-    fetchObserver = initFetchObserver(cb, win, networkOptions);
-  }
-  const teardown = () => {
-    performanceObserver();
-    xhrObserver();
-    fetchObserver();
-    // allow future observers to initialize after cleanup
-    initialisedHandler = null;
-  };
-  initialisedHandler = teardown;
-  return teardown;
-}
-// use the plugin name so that when this functionality is adopted into rrweb
-// we can remove this plugin and use the core functionality with the same data
-const NETWORK_PLUGIN_NAME = 'rrweb/network@1';
-// TODO how should this be typed?
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const getRecordNetworkPlugin = options => {
-  return {
-    name: NETWORK_PLUGIN_NAME,
-    observer: initNetworkObserver,
-    options: options
-  };
-};
-// rrweb/networ@1 ends
-
-const DISABLED = 'disabled';
-const SAMPLED = 'sampled';
-const ACTIVE = 'active';
-const BUFFERING = 'buffering';
-const PAUSED = 'paused';
-const LAZY_LOADING = 'lazy_loading';
-const TRIGGER = 'trigger';
-const TRIGGER_ACTIVATED = TRIGGER + '_activated';
-const TRIGGER_PENDING = TRIGGER + '_pending';
-const TRIGGER_DISABLED = TRIGGER + '_' + DISABLED;
-function sessionRecordingUrlTriggerMatches(url, triggers) {
-  return triggers.some(trigger => {
-    switch (trigger.matching) {
-      case 'regex':
-        return new RegExp(trigger.url).test(url);
-      default:
-        return false;
-    }
-  });
-}
-class OrTriggerMatching {
-  constructor(_matchers) {
-    this._matchers = _matchers;
-  }
-  triggerStatus(sessionId) {
-    const statuses = this._matchers.map(m => m.triggerStatus(sessionId));
-    if (statuses.includes(TRIGGER_ACTIVATED)) {
-      return TRIGGER_ACTIVATED;
-    }
-    if (statuses.includes(TRIGGER_PENDING)) {
-      return TRIGGER_PENDING;
-    }
-    return TRIGGER_DISABLED;
-  }
-  stop() {
-    this._matchers.forEach(m => m.stop());
-  }
-}
-class AndTriggerMatching {
-  constructor(_matchers) {
-    this._matchers = _matchers;
-  }
-  triggerStatus(sessionId) {
-    const statuses = new Set();
-    for (const matcher of this._matchers) {
-      statuses.add(matcher.triggerStatus(sessionId));
-    }
-    // trigger_disabled means no config
-    statuses.delete(TRIGGER_DISABLED);
-    switch (statuses.size) {
-      case 0:
-        return TRIGGER_DISABLED;
-      case 1:
-        return Array.from(statuses)[0];
-      default:
-        return TRIGGER_PENDING;
-    }
-  }
-  stop() {
-    this._matchers.forEach(m => m.stop());
-  }
-}
-class PendingTriggerMatching {
-  triggerStatus() {
-    return TRIGGER_PENDING;
-  }
-  stop() {
-    // no-op
-  }
-}
-const isEagerLoadedConfig = x => {
-  return 'sessionRecording' in x;
-};
-class URLTriggerMatching {
-  constructor(_instance) {
-    this._instance = _instance;
-    this._urlTriggers = [];
-    this._urlBlocklist = [];
-    this.urlBlocked = false;
-  }
-  onConfig(config) {
-    this._urlTriggers = (isEagerLoadedConfig(config) ? isObject(config.sessionRecording) ? config.sessionRecording?.urlTriggers : [] : config?.urlTriggers) || [];
-    this._urlBlocklist = (isEagerLoadedConfig(config) ? isObject(config.sessionRecording) ? config.sessionRecording?.urlBlocklist : [] : config?.urlBlocklist) || [];
-  }
-  /**
-   * @deprecated Use onConfig instead
-   */
-  onRemoteConfig(response) {
-    this.onConfig(response);
-  }
-  _urlTriggerStatus(sessionId) {
-    if (this._urlTriggers.length === 0) {
-      return TRIGGER_DISABLED;
-    }
-    const currentTriggerSession = this._instance?.get_property(SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION);
-    return currentTriggerSession === sessionId ? TRIGGER_ACTIVATED : TRIGGER_PENDING;
-  }
-  triggerStatus(sessionId) {
-    const urlTriggerStatus = this._urlTriggerStatus(sessionId);
-    const eitherIsActivated = urlTriggerStatus === TRIGGER_ACTIVATED;
-    const eitherIsPending = urlTriggerStatus === TRIGGER_PENDING;
-    const result = eitherIsActivated ? TRIGGER_ACTIVATED : eitherIsPending ? TRIGGER_PENDING : TRIGGER_DISABLED;
-    this._instance.registerForSession({
-      $sdk_debug_replay_url_trigger_status: result
-    });
-    return result;
-  }
-  checkUrlTriggerConditions(onPause, onResume, onActivate) {
-    if (typeof win === 'undefined' || !win.location.href) {
-      return;
-    }
-    const url = win.location.href;
-    const wasBlocked = this.urlBlocked;
-    const isNowBlocked = sessionRecordingUrlTriggerMatches(url, this._urlBlocklist);
-    if (wasBlocked && isNowBlocked) {
-      // if the url is blocked and was already blocked, do nothing
-      return;
-    } else if (isNowBlocked && !wasBlocked) {
-      onPause();
-    } else if (!isNowBlocked && wasBlocked) {
-      onResume();
-    }
-    if (sessionRecordingUrlTriggerMatches(url, this._urlTriggers)) {
-      onActivate('url');
-    }
-  }
-  stop() {
-    // no-op
-  }
-}
-class LinkedFlagMatching {
-  constructor(_instance) {
-    this._instance = _instance;
-    this.linkedFlag = null;
-    this.linkedFlagSeen = false;
-    this._flagListenerCleanup = () => {};
-  }
-  triggerStatus() {
-    let result = TRIGGER_PENDING;
-    if (isNullish(this.linkedFlag)) {
-      result = TRIGGER_DISABLED;
-    }
-    if (this.linkedFlagSeen) {
-      result = TRIGGER_ACTIVATED;
-    }
-    this._instance.registerForSession({
-      $sdk_debug_replay_linked_flag_trigger_status: result
-    });
-    return result;
-  }
-  onConfig(config, onStarted) {
-    this.linkedFlag = (isEagerLoadedConfig(config) ? isObject(config.sessionRecording) ? config.sessionRecording?.linkedFlag : null : config?.linkedFlag) || null;
-    if (!isNullish(this.linkedFlag) && !this.linkedFlagSeen) {
-      const linkedFlag = isString(this.linkedFlag) ? this.linkedFlag : this.linkedFlag.flag;
-      const linkedVariant = isString(this.linkedFlag) ? null : this.linkedFlag.variant;
-      this._flagListenerCleanup = this._instance.onFeatureFlags(flags => {
-        const flagIsPresent = isObject(flags) && linkedFlag in flags;
-        let linkedFlagMatches = false;
-        if (flagIsPresent) {
-          const variantForFlagKey = flags[linkedFlag];
-          if (isBoolean(variantForFlagKey)) {
-            linkedFlagMatches = variantForFlagKey === true;
-          } else if (linkedVariant) {
-            linkedFlagMatches = variantForFlagKey === linkedVariant;
-          } else {
-            // then this is a variant flag and we want to match any string
-            linkedFlagMatches = !!variantForFlagKey;
-          }
-        }
-        this.linkedFlagSeen = linkedFlagMatches;
-        if (linkedFlagMatches) {
-          onStarted(linkedFlag, linkedVariant);
-        }
-      });
-    }
-  }
-  /**
-   * @deprecated Use onConfig instead
-   */
-  onRemoteConfig(response, onStarted) {
-    this.onConfig(response, onStarted);
-  }
-  stop() {
-    this._flagListenerCleanup();
-  }
-}
-class EventTriggerMatching {
-  constructor(_instance) {
-    this._instance = _instance;
-    this._eventTriggers = [];
-  }
-  onConfig(config) {
-    this._eventTriggers = (isEagerLoadedConfig(config) ? isObject(config.sessionRecording) ? config.sessionRecording?.eventTriggers : [] : config?.eventTriggers) || [];
-  }
-  /**
-   * @deprecated Use onConfig instead
-   */
-  onRemoteConfig(response) {
-    this.onConfig(response);
-  }
-  _eventTriggerStatus(sessionId) {
-    if (this._eventTriggers.length === 0) {
-      return TRIGGER_DISABLED;
-    }
-    const currentTriggerSession = this._instance?.get_property(SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION);
-    return currentTriggerSession === sessionId ? TRIGGER_ACTIVATED : TRIGGER_PENDING;
-  }
-  triggerStatus(sessionId) {
-    const eventTriggerStatus = this._eventTriggerStatus(sessionId);
-    const result = eventTriggerStatus === TRIGGER_ACTIVATED ? TRIGGER_ACTIVATED : eventTriggerStatus === TRIGGER_PENDING ? TRIGGER_PENDING : TRIGGER_DISABLED;
-    this._instance.registerForSession({
-      $sdk_debug_replay_event_trigger_status: result
-    });
-    return result;
-  }
-  stop() {
-    // no-op
-  }
-}
-// we need a no-op matcher before we can lazy-load the other matches, since all matchers wait on remote config anyway
-function nullMatchSessionRecordingStatus(triggersStatus) {
-  if (!triggersStatus.isRecordingEnabled) {
-    return DISABLED;
-  }
-  return BUFFERING;
-}
-function anyMatchSessionRecordingStatus(triggersStatus) {
-  if (!triggersStatus.receivedFlags) {
-    return BUFFERING;
-  }
-  if (!triggersStatus.isRecordingEnabled) {
-    return DISABLED;
-  }
-  if (triggersStatus.urlTriggerMatching.urlBlocked) {
-    return PAUSED;
-  }
-  const sampledActive = triggersStatus.isSampled === true;
-  const triggerMatches = new OrTriggerMatching([triggersStatus.eventTriggerMatching, triggersStatus.urlTriggerMatching, triggersStatus.linkedFlagMatching]).triggerStatus(triggersStatus.sessionId);
-  if (sampledActive) {
-    return SAMPLED;
-  }
-  if (triggerMatches === TRIGGER_ACTIVATED) {
-    return ACTIVE;
-  }
-  if (triggerMatches === TRIGGER_PENDING) {
-    // even if sampled active is false, we should still be buffering
-    // since a pending trigger could override it
-    return BUFFERING;
-  }
-  // if sampling is set and the session is already decided to not be sampled
-  // then we should never be active
-  if (triggersStatus.isSampled === false) {
-    return DISABLED;
-  }
-  return ACTIVE;
-}
-function allMatchSessionRecordingStatus(triggersStatus) {
-  if (!triggersStatus.receivedFlags) {
-    return BUFFERING;
-  }
-  if (!triggersStatus.isRecordingEnabled) {
-    return DISABLED;
-  }
-  if (triggersStatus.urlTriggerMatching.urlBlocked) {
-    return PAUSED;
-  }
-  const andTriggerMatch = new AndTriggerMatching([triggersStatus.eventTriggerMatching, triggersStatus.urlTriggerMatching, triggersStatus.linkedFlagMatching]);
-  const currentTriggerStatus = andTriggerMatch.triggerStatus(triggersStatus.sessionId);
-  const hasTriggersConfigured = currentTriggerStatus !== TRIGGER_DISABLED;
-  const hasSamplingConfigured = isBoolean(triggersStatus.isSampled);
-  if (hasTriggersConfigured && currentTriggerStatus === TRIGGER_PENDING) {
-    return BUFFERING;
-  }
-  if (hasTriggersConfigured && currentTriggerStatus === TRIGGER_DISABLED) {
-    return DISABLED;
-  }
-  // sampling can't ever cause buffering, it's always determined right away or not configured
-  if (hasSamplingConfigured && !triggersStatus.isSampled) {
-    return DISABLED;
-  }
-  // If sampling is configured and set to true, return sampled
-  if (triggersStatus.isSampled === true) {
-    return SAMPLED;
-  }
-  return ACTIVE;
-}
-
-// taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value#circular_references
-function circularReferenceReplacer() {
-  const ancestors = [];
-  return function (_key, value) {
-    if (isObject(value)) {
-      // `this` is the object that value is contained in,
-      // i.e., its direct parent.
-      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
-        ancestors.pop();
-      }
-      if (ancestors.includes(value)) {
-        return '[Circular]';
-      }
-      ancestors.push(value);
-      return value;
-    } else {
-      return value;
-    }
-  };
-}
-function estimateSize(sizeable) {
-  return JSON.stringify(sizeable, circularReferenceReplacer())?.length || 0;
-}
-const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
-const PLUGIN_EVENT_TYPE = 6;
-const MUTATION_SOURCE_TYPE = 0;
-const CONSOLE_LOG_PLUGIN_NAME = 'rrweb/console@1'; // The name of the rr-web plugin that emits console logs
-// Console logs can be really large. This function truncates large logs
-// It's a simple function that just truncates long strings.
-// TODO: Ideally this function would have better handling of objects + lists,
-// so they could still be rendered in a pretty way after truncation.
-function truncateLargeConsoleLogs(_event) {
-  const event = _event;
-  const MAX_STRING_SIZE = 2000; // Maximum number of characters allowed in a string
-  const MAX_STRINGS_PER_LOG = 10; // A log can consist of multiple strings (e.g. consol.log('string1', 'string2'))
-  if (event && isObject(event) && event.type === PLUGIN_EVENT_TYPE && isObject(event.data) && event.data.plugin === CONSOLE_LOG_PLUGIN_NAME) {
-    // Note: event.data.payload.payload comes from rr-web, and is an array of strings
-    if (event.data.payload.payload.length > MAX_STRINGS_PER_LOG) {
-      event.data.payload.payload = event.data.payload.payload.slice(0, MAX_STRINGS_PER_LOG);
-      event.data.payload.payload.push('...[truncated]');
-    }
-    const updatedPayload = [];
-    for (let i = 0; i < event.data.payload.payload.length; i++) {
-      if (event.data.payload.payload[i] &&
-      // Value can be null
-      event.data.payload.payload[i].length > MAX_STRING_SIZE) {
-        updatedPayload.push(event.data.payload.payload[i].slice(0, MAX_STRING_SIZE) + '...[truncated]');
-      } else {
-        updatedPayload.push(event.data.payload.payload[i]);
-      }
-    }
-    event.data.payload.payload = updatedPayload;
-    // Return original type
-    return _event;
-  }
-  return _event;
-}
-
-class MutationThrottler {
-  constructor(_rrweb, _options = {}) {
-    this._rrweb = _rrweb;
-    this._options = _options;
-    this._loggedTracker = {};
-    this._onNodeRateLimited = key => {
-      if (!this._loggedTracker[key]) {
-        this._loggedTracker[key] = true;
-        const node = this._getNode(key);
-        this._options.onBlockedNode?.(key, node);
-      }
-    };
-    this._getNodeOrRelevantParent = id => {
-      // For some nodes we know they are part of a larger tree such as an SVG.
-      // For those we want to block the entire node, not just the specific attribute
-      const node = this._getNode(id);
-      // Check if the node is an Element and then find the closest parent that is an SVG
-      if (node?.nodeName !== 'svg' && node instanceof Element) {
-        const closestSVG = node.closest('svg');
-        if (closestSVG) {
-          return [this._rrweb.mirror.getId(closestSVG), closestSVG];
-        }
-      }
-      return [id, node];
-    };
-    this._getNode = id => this._rrweb.mirror.getNode(id);
-    this._numberOfChanges = data => {
-      return (data.removes?.length ?? 0) + (data.attributes?.length ?? 0) + (data.texts?.length ?? 0) + (data.adds?.length ?? 0);
-    };
-    this.throttleMutations = event => {
-      if (event.type !== INCREMENTAL_SNAPSHOT_EVENT_TYPE || event.data.source !== MUTATION_SOURCE_TYPE) {
-        return event;
-      }
-      const data = event.data;
-      const initialMutationCount = this._numberOfChanges(data);
-      if (data.attributes) {
-        // Most problematic mutations come from attrs where the style or minor properties are changed rapidly
-        data.attributes = data.attributes.filter(attr => {
-          const [nodeId] = this._getNodeOrRelevantParent(attr.id);
-          const isRateLimited = this._rateLimiter.consumeRateLimit(nodeId);
-          if (isRateLimited) {
-            return false;
-          }
-          return attr;
-        });
-      }
-      // Check if every part of the mutation is empty in which case there is nothing to do
-      const mutationCount = this._numberOfChanges(data);
-      if (mutationCount === 0 && initialMutationCount !== mutationCount) {
-        // If we have modified the mutation count and the remaining count is 0, then we don't need the event.
-        return;
-      }
-      return event;
-    };
-    const configuredBucketSize = this._options.bucketSize ?? 100;
-    const effectiveBucketSize = Math.max(configuredBucketSize - 1, 1);
-    this._rateLimiter = new BucketedRateLimiter({
-      bucketSize: effectiveBucketSize,
-      refillRate: this._options.refillRate ?? 10,
-      refillInterval: 1000,
-      // one second
-      _onBucketRateLimited: this._onNodeRateLimited,
-      _logger: logger$2
-    });
-  }
-  reset() {
-    this._loggedTracker = {};
-  }
-  stop() {
-    this._rateLimiter.stop();
-    this.reset();
-  }
-}
-
-function simpleHash(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) - hash + str.charCodeAt(i); // (hash * 31) + char code
-    hash |= 0; // Convert to 32bit integer
-  }
-  return Math.abs(hash);
-}
-/*
- * receives percent as a number between 0 and 1
- */
-function sampleOnProperty(prop, percent) {
-  return simpleHash(prop) % 100 < clampToRange(percent * 100, 0, 100, logger$2);
-}
-
-const BASE_ENDPOINT = '/s/';
-const DEFAULT_CANVAS_QUALITY = 0.4;
-const DEFAULT_CANVAS_FPS = 4;
-const MAX_CANVAS_FPS = 12;
-const MAX_CANVAS_QUALITY = 1;
-const TWO_SECONDS = 2000;
-const ONE_KB = 1024;
-const ONE_MINUTE = 1000 * 60;
-const FIVE_MINUTES = ONE_MINUTE * 5;
-const RECORDING_IDLE_THRESHOLD_MS = FIVE_MINUTES;
-const RECORDING_MAX_EVENT_SIZE = ONE_KB * ONE_KB * 0.9; // ~1mb (with some wiggle room)
-const RECORDING_BUFFER_TIMEOUT = 2000; // 2 seconds
-const SESSION_RECORDING_BATCH_KEY = 'recordings';
-const LOGGER_PREFIX$1 = '[SessionRecording]';
-const logger = createLogger(LOGGER_PREFIX$1);
-const ACTIVE_SOURCES = [IncrementalSource.MouseMove, IncrementalSource.MouseInteraction, IncrementalSource.Scroll, IncrementalSource.ViewportResize, IncrementalSource.Input, IncrementalSource.TouchMove, IncrementalSource.MediaInteraction, IncrementalSource.Drag];
-const newQueuedEvent = rrwebMethod => ({
-  rrwebMethod,
-  enqueuedAt: Date.now(),
-  attempt: 1
-});
-function getRRWebRecord() {
-  return record;
-}
-function gzipToString(data) {
-  return strFromU8(gzipSync(strToU8(JSON.stringify(data))), true);
-}
-/**
- * rrweb's packer takes an event and returns a string or the reverse on `unpack`.
- * but we want to be able to inspect metadata during ingestion.
- * and don't want to compress the entire event,
- * so we have a custom packer that only compresses part of some events
- */
-function compressEvent(event) {
-  try {
-    if (event.type === EventType.FullSnapshot) {
-      return {
-        ...event,
-        data: gzipToString(event.data),
-        cv: '2024-10'
-      };
-    }
-    if (event.type === EventType.IncrementalSnapshot && event.data.source === IncrementalSource.Mutation) {
-      return {
-        ...event,
-        cv: '2024-10',
-        data: {
-          ...event.data,
-          texts: gzipToString(event.data.texts),
-          attributes: gzipToString(event.data.attributes),
-          removes: gzipToString(event.data.removes),
-          adds: gzipToString(event.data.adds)
-        }
-      };
-    }
-    if (event.type === EventType.IncrementalSnapshot && event.data.source === IncrementalSource.StyleSheetRule) {
-      return {
-        ...event,
-        cv: '2024-10',
-        data: {
-          ...event.data,
-          adds: event.data.adds ? gzipToString(event.data.adds) : undefined,
-          removes: event.data.removes ? gzipToString(event.data.removes) : undefined
-        }
-      };
-    }
-  } catch (e) {
-    logger.error('could not compress event - will use uncompressed event', e);
-  }
-  return event;
-}
-function isSessionIdleEvent(e) {
-  return e.type === EventType.Custom && e.data.tag === 'sessionIdle';
-}
-/** When we put the recording into a paused state, we add a custom event.
- *  However, in the paused state, events are dropped and never make it to the buffer,
- *  so we need to manually let this one through */
-function isRecordingPausedEvent(e) {
-  return e.type === EventType.Custom && e.data.tag === 'recording paused';
-}
-const SEVEN_MEGABYTES = 1024 * 1024 * 7 * 0.9; // ~7mb (with some wiggle room)
-// recursively splits large buffers into smaller ones
-// uses a pretty high size limit to avoid splitting too much
-function splitBuffer(buffer, sizeLimit = SEVEN_MEGABYTES) {
-  if (buffer.size >= sizeLimit && buffer.data.length > 1) {
-    const half = Math.floor(buffer.data.length / 2);
-    const firstHalf = buffer.data.slice(0, half);
-    const secondHalf = buffer.data.slice(half);
-    return [splitBuffer({
-      size: estimateSize(firstHalf),
-      data: firstHalf,
-      sessionId: buffer.sessionId,
-      windowId: buffer.windowId
-    }), splitBuffer({
-      size: estimateSize(secondHalf),
-      data: secondHalf,
-      sessionId: buffer.sessionId,
-      windowId: buffer.windowId
-    })].flatMap(x => x);
-  } else {
-    return [buffer];
-  }
-}
-class LazyLoadedSessionRecording {
-  get sessionId() {
-    return this._sessionId;
-  }
-  get _sessionManager() {
-    if (!this._instance.sessionManager) {
-      throw new Error(LOGGER_PREFIX$1 + ' must be started with a valid sessionManager.');
-    }
-    return this._instance.sessionManager;
-  }
-  get _sessionIdleThresholdMilliseconds() {
-    return this._instance.config.session_recording?.session_idle_threshold_ms || RECORDING_IDLE_THRESHOLD_MS;
-  }
-  get _isSampled() {
-    const currentValue = this._instance.get_property(SESSION_RECORDING_IS_SAMPLED);
-    // originally we would store `true` or `false` or nothing,
-    // but that would mean sometimes we would carry on recording on session id change
-    return isBoolean(currentValue) ? currentValue : isString(currentValue) ? currentValue === this.sessionId : null;
-  }
-  get _sampleRate() {
-    const rate = this._remoteConfig?.sampleRate;
-    return isNumber(rate) ? rate : null;
-  }
-  get _minimumDuration() {
-    const duration = this._remoteConfig?.minimumDurationMilliseconds;
-    return isNumber(duration) ? duration : null;
-  }
-  constructor(_instance) {
-    this._instance = _instance;
-    this._endpoint = BASE_ENDPOINT;
-    /**
-     * Util to help developers working on this feature manually override
-     */
-    this._forceAllowLocalhostNetworkCapture = false;
-    this._stopRrweb = undefined;
-    this._lastActivityTimestamp = Date.now();
-    /**
-     * and a queue - that contains rrweb events that we want to send to rrweb, but rrweb wasn't able to accept them yet
-     */
-    this._queuedRRWebEvents = [];
-    this._isIdle = 'unknown';
-    // we need to be able to check the state of the event and url triggers separately
-    // as we make some decisions based on them without referencing LinkedFlag etc
-    this._triggerMatching = new PendingTriggerMatching();
-    this._removePageViewCaptureHook = undefined;
-    this._removeEventTriggerCaptureHook = undefined;
-    this._statusMatcher = nullMatchSessionRecordingStatus;
-    this._onSessionIdListener = undefined;
-    this._onSessionIdleResetForcedListener = undefined;
-    this._samplingSessionListener = undefined;
-    this._forceIdleSessionIdListener = undefined;
-    this._onSessionIdCallback = (sessionId, windowId, changeReason) => {
-      if (changeReason) {
-        this._tryAddCustomEvent('$session_id_change', {
-          sessionId,
-          windowId,
-          changeReason
-        });
-        this._clearConditionalRecordingPersistence();
-        if (!this._stopRrweb) {
-          this.start('session_id_changed');
-        }
-        if (isNumber(this._sampleRate) && isNullish(this._samplingSessionListener)) {
-          this._makeSamplingDecision(sessionId);
-        }
-      }
-    };
-    this._onBeforeUnload = () => {
-      this._flushBuffer();
-    };
-    this._onOffline = () => {
-      this._tryAddCustomEvent('browser offline', {});
-    };
-    this._onOnline = () => {
-      this._tryAddCustomEvent('browser online', {});
-    };
-    this._onVisibilityChange = () => {
-      if (document?.visibilityState) {
-        const label = 'window ' + document.visibilityState;
-        this._tryAddCustomEvent(label, {});
-      }
-    };
-    // we know there's a sessionManager, so don't need to start without a session id
-    const {
-      sessionId,
-      windowId
-    } = this._sessionManager.checkAndGetSessionAndWindowId();
-    this._sessionId = sessionId;
-    this._windowId = windowId;
-    this._linkedFlagMatching = new LinkedFlagMatching(this._instance);
-    this._urlTriggerMatching = new URLTriggerMatching(this._instance);
-    this._eventTriggerMatching = new EventTriggerMatching(this._instance);
-    this._buffer = this._clearBuffer();
-    if (this._sessionIdleThresholdMilliseconds >= this._sessionManager.sessionTimeoutMs) {
-      logger.warn(`session_idle_threshold_ms (${this._sessionIdleThresholdMilliseconds}) is greater than the session timeout (${this._sessionManager.sessionTimeoutMs}). Session will never be detected as idle`);
-    }
-  }
-  get _masking() {
-    const masking_server_side = this._remoteConfig?.masking;
-    const masking_client_side = {
-      maskAllInputs: this._instance.config.session_recording?.maskAllInputs,
-      maskTextSelector: this._instance.config.session_recording?.maskTextSelector,
-      blockSelector: this._instance.config.session_recording?.blockSelector
-    };
-    const maskAllInputs = masking_client_side?.maskAllInputs ?? masking_server_side?.maskAllInputs;
-    const maskTextSelector = masking_client_side?.maskTextSelector ?? masking_server_side?.maskTextSelector;
-    const blockSelector = masking_client_side?.blockSelector ?? masking_server_side?.blockSelector;
-    return !isUndefined(maskAllInputs) || !isUndefined(maskTextSelector) || !isUndefined(blockSelector) ? {
-      maskAllInputs: maskAllInputs ?? true,
-      maskTextSelector,
-      blockSelector
-    } : undefined;
-  }
-  get _canvasRecording() {
-    const canvasRecording_client_side = this._instance.config.session_recording?.captureCanvas;
-    const canvasRecording_server_side = this._remoteConfig?.canvasRecording;
-    const enabled = canvasRecording_client_side?.recordCanvas ?? canvasRecording_server_side?.enabled ?? false;
-    const fps = canvasRecording_client_side?.canvasFps ?? canvasRecording_server_side?.fps ?? DEFAULT_CANVAS_FPS;
-    let quality = canvasRecording_client_side?.canvasQuality ?? canvasRecording_server_side?.quality ?? DEFAULT_CANVAS_QUALITY;
-    if (typeof quality === 'string') {
-      const parsed = parseFloat(quality);
-      quality = isNaN(parsed) ? 0.4 : parsed;
-    }
-    return {
-      enabled,
-      fps: clampToRange(fps, 0, MAX_CANVAS_FPS, createLogger('canvas recording fps'), DEFAULT_CANVAS_FPS),
-      quality: clampToRange(quality, 0, MAX_CANVAS_QUALITY, createLogger('canvas recording quality'), DEFAULT_CANVAS_QUALITY)
-    };
-  }
-  get _isConsoleLogCaptureEnabled() {
-    const enabled_server_side = !!this._remoteConfig?.consoleLogRecordingEnabled;
-    const enabled_client_side = this._instance.config.enable_recording_console_log;
-    return enabled_client_side ?? enabled_server_side;
-  }
-  // network payload capture config has three parts
-  // each can be configured server side or client side
-  get _networkPayloadCapture() {
-    const networkPayloadCapture_server_side = this._remoteConfig?.networkPayloadCapture;
-    const networkPayloadCapture_client_side = {
-      recordHeaders: this._instance.config.session_recording?.recordHeaders,
-      recordBody: this._instance.config.session_recording?.recordBody
-    };
-    const headersOptIn = networkPayloadCapture_client_side?.recordHeaders === true;
-    const bodyOptIn = networkPayloadCapture_client_side?.recordBody === true;
-    const clientPerformanceConfig = this._instance.config.capture_performance;
-    const clientPerformanceOptIn = isObject(clientPerformanceConfig) ? !!clientPerformanceConfig.network_timing : !!clientPerformanceConfig;
-    const serverAllowsHeaders = networkPayloadCapture_server_side?.recordHeaders ?? true;
-    const serverAllowsBody = networkPayloadCapture_server_side?.recordBody ?? true;
-    const capturePerfResponse = networkPayloadCapture_server_side?.capturePerformance;
-    const serverAllowsPerformance = (() => {
-      if (isObject(capturePerfResponse)) {
-        return !!capturePerfResponse.network_timing;
-      }
-      return capturePerfResponse ?? true;
-    })();
-    const headersEnabled = headersOptIn && serverAllowsHeaders;
-    const bodyEnabled = bodyOptIn && serverAllowsBody;
-    const networkTimingEnabled = clientPerformanceOptIn && serverAllowsPerformance;
-    if (!headersEnabled && !bodyEnabled && !networkTimingEnabled) {
-      return undefined;
-    }
-    return {
-      recordHeaders: headersEnabled,
-      recordBody: bodyEnabled,
-      recordPerformance: networkTimingEnabled,
-      payloadHostDenyList: networkPayloadCapture_server_side?.payloadHostDenyList
-    };
-  }
-  _gatherRRWebPlugins() {
-    const plugins = [];
-    if (this._isConsoleLogCaptureEnabled) {
-      logger.info('Console log capture requested but console plugin is not bundled in this build yet.');
-    }
-    if (this._networkPayloadCapture) {
-      const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture;
-      if (canRecordNetwork) {
-        plugins.push(getRecordNetworkPlugin(buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture)));
-      } else {
-        logger.info('NetworkCapture not started because we are on localhost.');
-      }
-    }
-    return plugins;
-  }
-  _maskUrl(url) {
-    const userSessionRecordingOptions = this._instance.config.session_recording || {};
-    if (userSessionRecordingOptions.maskNetworkRequestFn) {
-      let networkRequest = {
-        url
-      };
-      // TODO we should deprecate this and use the same function for this masking and the rrweb/network plugin
-      // TODO or deprecate this and provide a new clearer name so this would be `maskURLPerformanceFn` or similar
-      networkRequest = userSessionRecordingOptions.maskNetworkRequestFn(networkRequest);
-      return networkRequest?.url;
-    }
-    return url;
-  }
-  _tryRRWebMethod(queuedRRWebEvent) {
-    try {
-      queuedRRWebEvent.rrwebMethod();
-      return true;
-    } catch (e) {
-      // Sometimes a race can occur where the recorder is not fully started yet
-      if (this._queuedRRWebEvents.length < 10) {
-        this._queuedRRWebEvents.push({
-          enqueuedAt: queuedRRWebEvent.enqueuedAt || Date.now(),
-          attempt: queuedRRWebEvent.attempt + 1,
-          rrwebMethod: queuedRRWebEvent.rrwebMethod
-        });
-      } else {
-        logger.warn('could not emit queued rrweb event.', e, queuedRRWebEvent);
-      }
-      return false;
-    }
-  }
-  _tryAddCustomEvent(tag, payload) {
-    return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().addCustomEvent(tag, payload)));
-  }
-  _pageViewFallBack() {
-    try {
-      if (this._instance.config.capture_pageview || !win) {
-        return;
-      }
-      // Strip hash parameters from URL since they often aren't helpful
-      // Use URL constructor for proper parsing to handle edge cases
-      // recording doesn't run in IE11, so we don't need compat here
-      // eslint-disable-next-line compat/compat
-      const url = new URL(win.location.href);
-      const hrefWithoutHash = url.origin + url.pathname + url.search;
-      const currentUrl = this._maskUrl(hrefWithoutHash);
-      if (this._lastHref !== currentUrl) {
-        this._lastHref = currentUrl;
-        this._tryAddCustomEvent('$url_changed', {
-          href: currentUrl
-        });
-      }
-    } catch {
-      // If URL processing fails, don't capture anything
-    }
-  }
-  _processQueuedEvents() {
-    if (this._queuedRRWebEvents.length) {
-      // if rrweb isn't ready to accept events earlier, then we queued them up.
-      // now that `emit` has been called rrweb should be ready to accept them.
-      // so, before we process this event, we try our queued events _once_ each
-      // we don't want to risk queuing more things and never exiting this loop!
-      // if they fail here, they'll be pushed into a new queue
-      // and tried on the next loop.
-      // there is a risk of this queue growing in an uncontrolled manner.
-      // so its length is limited elsewhere
-      // for now this is to help us ensure we can capture events that happen
-      // and try to identify more about when it is failing
-      const itemsToProcess = [...this._queuedRRWebEvents];
-      this._queuedRRWebEvents = [];
-      itemsToProcess.forEach(queuedRRWebEvent => {
-        if (Date.now() - queuedRRWebEvent.enqueuedAt <= TWO_SECONDS) {
-          this._tryRRWebMethod(queuedRRWebEvent);
-        }
-      });
-    }
-  }
-  _tryTakeFullSnapshot() {
-    return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().takeFullSnapshot()));
-  }
-  get _fullSnapshotIntervalMillis() {
-    if (this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING && !['sampled', 'active'].includes(this.status)) {
-      return ONE_MINUTE;
-    }
-    return this._instance.config.session_recording?.full_snapshot_interval_millis ?? FIVE_MINUTES;
-  }
-  _scheduleFullSnapshot() {
-    if (this._fullSnapshotTimer) {
-      clearInterval(this._fullSnapshotTimer);
-    }
-    // we don't schedule snapshots while idle
-    if (this._isIdle === true) {
-      return;
-    }
-    const interval = this._fullSnapshotIntervalMillis;
-    if (!interval) {
-      return;
-    }
-    this._fullSnapshotTimer = setInterval(() => {
-      this._tryTakeFullSnapshot();
-    }, interval);
-  }
-  _pauseRecording() {
-    // we check _urlBlocked not status, since more than one thing can affect status
-    if (this._urlTriggerMatching.urlBlocked) {
-      return;
-    }
-    // we can't flush the buffer here since someone might be starting on a blocked page.
-    // and we need to be sure that we don't record that page,
-    // so we might not get the below custom event, but events will report the paused status.
-    // which will allow debugging of sessions that start on blocked pages
-    this._urlTriggerMatching.urlBlocked = true;
-    // Clear the snapshot timer since we don't want new snapshots while paused
-    clearInterval(this._fullSnapshotTimer);
-    logger.info('recording paused due to URL blocker');
-    this._tryAddCustomEvent('recording paused', {
-      reason: 'url blocker'
-    });
-  }
-  _resumeRecording() {
-    // we check _urlBlocked not status, since more than one thing can affect status
-    if (!this._urlTriggerMatching.urlBlocked) {
-      return;
-    }
-    this._urlTriggerMatching.urlBlocked = false;
-    this._tryTakeFullSnapshot();
-    this._scheduleFullSnapshot();
-    this._tryAddCustomEvent('recording resumed', {
-      reason: 'left blocked url'
-    });
-    logger.info('recording resumed');
-  }
-  _activateTrigger(triggerType) {
-    if (this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING) {
-      // status is stored separately for URL and event triggers
-      this._instance?.persistence?.register({
-        [triggerType === 'url' ? SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION : SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION]: this._sessionId
-      });
-      this._flushBuffer();
-      this._reportStarted(triggerType + '_trigger_matched');
-    }
-  }
-  get isStarted() {
-    return !!this._stopRrweb;
-  }
-  get _remoteConfig() {
-    const persistedConfig = this._instance.get_property(SESSION_RECORDING_REMOTE_CONFIG);
-    if (!persistedConfig) {
-      return undefined;
-    }
-    const parsedConfig = isObject(persistedConfig) ? persistedConfig : JSON.parse(persistedConfig);
-    return parsedConfig;
-  }
-  start(startReason) {
-    const config = this._remoteConfig;
-    if (!config) {
-      logger.info('remote config must be stored in persistence before recording can start');
-      return;
-    }
-    // We want to ensure the sessionManager is reset if necessary on loading the recorder
-    this._sessionManager.checkAndGetSessionAndWindowId();
-    if (config?.endpoint) {
-      this._endpoint = config?.endpoint;
-    }
-    if (config?.triggerMatchType === 'any') {
-      this._statusMatcher = anyMatchSessionRecordingStatus;
-      this._triggerMatching = new OrTriggerMatching([this._eventTriggerMatching, this._urlTriggerMatching]);
-    } else {
-      // either the setting is "ALL"
-      // or we default to the most restrictive
-      this._statusMatcher = allMatchSessionRecordingStatus;
-      this._triggerMatching = new AndTriggerMatching([this._eventTriggerMatching, this._urlTriggerMatching]);
-    }
-    this._instance.registerForSession({
-      $sdk_debug_replay_remote_trigger_matching_config: config?.triggerMatchType ?? null
-    });
-    this._urlTriggerMatching.onConfig(config);
-    this._eventTriggerMatching.onConfig(config);
-    this._removeEventTriggerCaptureHook?.();
-    this._addEventTriggerListener();
-    this._linkedFlagMatching.onConfig(config, (flag, variant) => {
-      this._reportStarted('linked_flag_matched', {
-        flag,
-        variant
-      });
-    });
-    this._makeSamplingDecision(this.sessionId);
-    this._startRecorder();
-    // calling addEventListener multiple times is safe and will not add duplicates
-    addEventListener(win, 'beforeunload', this._onBeforeUnload);
-    addEventListener(win, 'offline', this._onOffline);
-    addEventListener(win, 'online', this._onOnline);
-    addEventListener(win, 'visibilitychange', this._onVisibilityChange);
-    if (!this._onSessionIdListener) {
-      this._onSessionIdListener = this._sessionManager.onSessionId(this._onSessionIdCallback);
-    }
-    if (!this._onSessionIdleResetForcedListener) {
-      this._onSessionIdleResetForcedListener = this._sessionManager.on('forcedIdleReset', () => {
-        // a session was forced to reset due to idle timeout and lack of activity
-        this._clearConditionalRecordingPersistence();
-        this._isIdle = 'unknown';
-        this.stop();
-        // then we want a session id listener to restart the recording when a new session starts
-        this._forceIdleSessionIdListener = this._sessionManager.onSessionId((sessionId, windowId, changeReason) => {
-          // this should first unregister itself
-          this._forceIdleSessionIdListener?.();
-          this._forceIdleSessionIdListener = undefined;
-          this._onSessionIdCallback(sessionId, windowId, changeReason);
-        });
-      });
-    }
-    if (isNullish(this._removePageViewCaptureHook)) {
-      // :TRICKY: rrweb does not capture navigation within SPA-s, so hook into our $pageview events to get access to all events.
-      //   Dropping the initial event is fine (it's always captured by rrweb).
-      this._removePageViewCaptureHook = this._instance.on('eventCaptured', event => {
-        // If anything could go wrong here,
-        // it has the potential to block the main loop,
-        // so we catch all errors.
-        try {
-          if (event.event === '$pageview') {
-            const href = event?.properties.$current_url ? this._maskUrl(event?.properties.$current_url) : '';
-            if (!href) {
-              return;
-            }
-            this._tryAddCustomEvent('$pageview', {
-              href
-            });
-          }
-        } catch (e) {
-          logger.error('Could not add $pageview to rrweb session', e);
-        }
-      });
-    }
-    if (this.status === ACTIVE) {
-      this._reportStarted(startReason || 'recording_initialized');
-    }
-  }
-  stop() {
-    win?.removeEventListener('beforeunload', this._onBeforeUnload);
-    win?.removeEventListener('offline', this._onOffline);
-    win?.removeEventListener('online', this._onOnline);
-    win?.removeEventListener('visibilitychange', this._onVisibilityChange);
-    this._clearBuffer();
-    clearInterval(this._fullSnapshotTimer);
-    this._clearFlushBufferTimer();
-    this._removePageViewCaptureHook?.();
-    this._removePageViewCaptureHook = undefined;
-    this._removeEventTriggerCaptureHook?.();
-    this._removeEventTriggerCaptureHook = undefined;
-    this._onSessionIdListener?.();
-    this._onSessionIdListener = undefined;
-    this._onSessionIdleResetForcedListener?.();
-    this._onSessionIdleResetForcedListener = undefined;
-    this._samplingSessionListener?.();
-    this._samplingSessionListener = undefined;
-    this._forceIdleSessionIdListener?.();
-    this._forceIdleSessionIdListener = undefined;
-    this._eventTriggerMatching.stop();
-    this._urlTriggerMatching.stop();
-    this._linkedFlagMatching.stop();
-    this._mutationThrottler?.stop();
-    // Clear any queued rrweb events to prevent memory leaks from closures
-    this._queuedRRWebEvents = [];
-    this._stopRrweb?.();
-    this._stopRrweb = undefined;
-    logger.info('stopped');
-  }
-  onRRwebEmit(rawEvent) {
-    this._processQueuedEvents();
-    if (!rawEvent || !isObject(rawEvent)) {
-      return;
-    }
-    if (rawEvent.type === EventType.Meta) {
-      const href = this._maskUrl(rawEvent.data.href);
-      this._lastHref = href;
-      if (!href) {
-        return;
-      }
-      rawEvent.data.href = href;
-    } else {
-      this._pageViewFallBack();
-    }
-    // Check if the URL matches any trigger patterns
-    this._urlTriggerMatching.checkUrlTriggerConditions(() => this._pauseRecording(), () => this._resumeRecording(), triggerType => this._activateTrigger(triggerType));
-    // always have to check if the URL is blocked really early,
-    // or you risk getting stuck in a loop
-    if (this._urlTriggerMatching.urlBlocked && !isRecordingPausedEvent(rawEvent)) {
-      return;
-    }
-    // we're processing a full snapshot, so we should reset the timer
-    if (rawEvent.type === EventType.FullSnapshot) {
-      this._scheduleFullSnapshot();
-      // Full snapshots reset rrweb's node IDs, so clear any logged node tracking
-      this._mutationThrottler?.reset();
-    }
-    // Clear the buffer if waiting for a trigger and only keep data from after the current full snapshot
-    // we always start trigger pending so need to wait for flags before we know if we're really pending
-    if (rawEvent.type === EventType.FullSnapshot && this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING) {
-      this._clearBufferBeforeMostRecentMeta();
-    }
-    const throttledEvent = this._mutationThrottler ? this._mutationThrottler.throttleMutations(rawEvent) : rawEvent;
-    if (!throttledEvent) {
-      return;
-    }
-    // TODO: Re-add ensureMaxMessageSize once we are confident in it
-    const event = truncateLargeConsoleLogs(throttledEvent);
-    this._updateWindowAndSessionIds(event);
-    // When in an idle state we keep recording but don't capture the events,
-    // we don't want to return early if idle is 'unknown'
-    if (this._isIdle === true && !isSessionIdleEvent(event)) {
-      return;
-    }
-    if (isSessionIdleEvent(event)) {
-      // session idle events have a timestamp when rrweb sees them
-      // which can artificially lengthen a session
-      // we know when we detected it based on the payload and can correct the timestamp
-      const payload = event.data.payload;
-      if (payload) {
-        const lastActivity = payload.lastActivityTimestamp;
-        const threshold = payload.threshold;
-        event.timestamp = lastActivity + threshold;
-      }
-    }
-    const eventToSend = this._instance.config.session_recording?.compress_events ?? true ? compressEvent(event) : event;
-    const size = estimateSize(eventToSend);
-    const properties = {
-      $snapshot_bytes: size,
-      $snapshot_data: eventToSend,
-      $session_id: this._sessionId,
-      $window_id: this._windowId
-    };
-    if (this.status === DISABLED) {
-      this._clearBuffer();
-      return;
-    }
-    this._captureSnapshotBuffered(properties);
-  }
-  get status() {
-    return this._statusMatcher({
-      // can't get here without recording being enabled...
-      receivedFlags: true,
-      isRecordingEnabled: true,
-      // things that do still vary
-      isSampled: this._isSampled,
-      urlTriggerMatching: this._urlTriggerMatching,
-      eventTriggerMatching: this._eventTriggerMatching,
-      linkedFlagMatching: this._linkedFlagMatching,
-      sessionId: this.sessionId
-    });
-  }
-  log(message, level = 'log') {
-    this._instance.sessionRecording?.onRRwebEmit({
-      type: 6,
-      data: {
-        plugin: 'rrweb/console@1',
-        payload: {
-          level,
-          trace: [],
-          // Even though it is a string, we stringify it as that's what rrweb expects
-          payload: [JSON.stringify(message)]
-        }
-      },
-      timestamp: Date.now()
-    });
-  }
-  overrideLinkedFlag() {
-    this._linkedFlagMatching.linkedFlagSeen = true;
-    this._tryTakeFullSnapshot();
-    this._reportStarted('linked_flag_overridden');
-  }
-  /**
-   * this ignores the sampling config and (if other conditions are met) causes capture to start
-   *
-   * It is not usual to call this directly,
-   * instead call `posthog.startSessionRecording({sampling: true})`
-   * */
-  overrideSampling() {
-    this._instance.persistence?.register({
-      // short-circuits the `makeSamplingDecision` function in the session recording module
-      [SESSION_RECORDING_IS_SAMPLED]: this.sessionId
-    });
-    this._tryTakeFullSnapshot();
-    this._reportStarted('sampling_overridden');
-  }
-  /**
-   * this ignores the URL/Event trigger config and (if other conditions are met) causes capture to start
-   *
-   * It is not usual to call this directly,
-   * instead call `posthog.startSessionRecording({trigger: 'url' | 'event'})`
-   * */
-  overrideTrigger(triggerType) {
-    this._activateTrigger(triggerType);
-  }
-  _clearFlushBufferTimer() {
-    if (this._flushBufferTimer) {
-      clearTimeout(this._flushBufferTimer);
-      this._flushBufferTimer = undefined;
-    }
-  }
-  _flushBuffer() {
-    this._clearFlushBufferTimer();
-    const minimumDuration = this._minimumDuration;
-    const sessionDuration = this._sessionDuration;
-    // if we have old data in the buffer but the session has rotated, then the
-    // session duration might be negative. In that case we want to flush the buffer
-    const isPositiveSessionDuration = isNumber(sessionDuration) && sessionDuration >= 0;
-    const isBelowMinimumDuration = isNumber(minimumDuration) && isPositiveSessionDuration && sessionDuration < minimumDuration;
-    if (this.status === BUFFERING || this.status === PAUSED || this.status === DISABLED || isBelowMinimumDuration) {
-      this._flushBufferTimer = setTimeout(() => {
-        this._flushBuffer();
-      }, RECORDING_BUFFER_TIMEOUT);
-      return this._buffer;
-    }
-    if (this._buffer.data.length > 0) {
-      const snapshotEvents = splitBuffer(this._buffer);
-      snapshotEvents.forEach(snapshotBuffer => {
-        this._captureSnapshot({
-          $snapshot_bytes: snapshotBuffer.size,
-          $snapshot_data: snapshotBuffer.data,
-          $session_id: snapshotBuffer.sessionId,
-          $window_id: snapshotBuffer.windowId,
-          $lib: 'web',
-          $lib_version: Config.LIB_VERSION
-        });
-      });
-    }
-    // buffer is empty, we clear it in case the session id has changed
-    return this._clearBuffer();
-  }
-  _captureSnapshotBuffered(properties) {
-    const additionalBytes = 2 + (this._buffer?.data.length || 0); // 2 bytes for the array brackets and 1 byte for each comma
-    if (!this._isIdle && (
-    // we never want to flush when idle
-    this._buffer.size + properties.$snapshot_bytes + additionalBytes > RECORDING_MAX_EVENT_SIZE || this._buffer.sessionId !== this._sessionId)) {
-      this._buffer = this._flushBuffer();
-    }
-    this._buffer.size += properties.$snapshot_bytes;
-    this._buffer.data.push(properties.$snapshot_data);
-    if (!this._flushBufferTimer && !this._isIdle) {
-      this._flushBufferTimer = setTimeout(() => {
-        this._flushBuffer();
-      }, RECORDING_BUFFER_TIMEOUT);
-    }
-  }
-  _captureSnapshot(properties) {
-    // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.
-    this._instance.capture('$snapshot', properties, {
-      _url: this._snapshotUrl(),
-      _noTruncate: true,
-      _batchKey: SESSION_RECORDING_BATCH_KEY,
-      skip_client_rate_limiting: true
-    });
-  }
-  _snapshotUrl() {
-    const host = this._instance.config.host || '';
-    try {
-      // eslint-disable-next-line compat/compat
-      return new URL(this._endpoint, host).href;
-    } catch {
-      const normalizedHost = host.endsWith('/') ? host.slice(0, -1) : host;
-      const normalizedEndpoint = this._endpoint.startsWith('/') ? this._endpoint.slice(1) : this._endpoint;
-      return `${normalizedHost}/${normalizedEndpoint}`;
-    }
-  }
-  get _sessionDuration() {
-    const mostRecentSnapshot = this._buffer?.data[this._buffer?.data.length - 1];
-    const {
-      sessionStartTimestamp
-    } = this._sessionManager.checkAndGetSessionAndWindowId(true);
-    return mostRecentSnapshot ? mostRecentSnapshot.timestamp - sessionStartTimestamp : null;
-  }
-  _clearBufferBeforeMostRecentMeta() {
-    if (!this._buffer || this._buffer.data.length === 0) {
-      return this._clearBuffer();
-    }
-    // Find the last meta event index by iterating backwards
-    let lastMetaIndex = -1;
-    for (let i = this._buffer.data.length - 1; i >= 0; i--) {
-      if (this._buffer.data[i].type === EventType.Meta) {
-        lastMetaIndex = i;
-        break;
-      }
-    }
-    if (lastMetaIndex >= 0) {
-      this._buffer.data = this._buffer.data.slice(lastMetaIndex);
-      this._buffer.size = this._buffer.data.reduce((acc, curr) => acc + estimateSize(curr), 0);
-      return this._buffer;
-    } else {
-      return this._clearBuffer();
-    }
-  }
-  _clearBuffer() {
-    this._buffer = {
-      size: 0,
-      data: [],
-      sessionId: this._sessionId,
-      windowId: this._windowId
-    };
-    return this._buffer;
-  }
-  _reportStarted(startReason, tagPayload) {
-    this._instance.registerForSession({
-      $session_recording_start_reason: startReason
-    });
-    logger.info(startReason.replace('_', ' '), tagPayload);
-    if (!includes(['recording_initialized', 'session_id_changed'], startReason)) {
-      this._tryAddCustomEvent(startReason, tagPayload);
-    }
-  }
-  _isInteractiveEvent(event) {
-    return event.type === INCREMENTAL_SNAPSHOT_EVENT_TYPE && ACTIVE_SOURCES.indexOf(event.data?.source) !== -1;
-  }
-  _updateWindowAndSessionIds(event) {
-    // Some recording events are triggered by non-user events (e.g. "X minutes ago" text updating on the screen).
-    // We don't want to extend the session or trigger a new session in these cases. These events are designated by event
-    // type -> incremental update, and source -> mutation.
-    const isUserInteraction = this._isInteractiveEvent(event);
-    if (!isUserInteraction && !this._isIdle) {
-      // We check if the lastActivityTimestamp is old enough to go idle
-      const timeSinceLastActivity = event.timestamp - this._lastActivityTimestamp;
-      if (timeSinceLastActivity > this._sessionIdleThresholdMilliseconds) {
-        // we mark as idle right away,
-        // or else we get multiple idle events
-        // if there are lots of non-user activity events being emitted
-        this._isIdle = true;
-        // don't take full snapshots while idle
-        clearInterval(this._fullSnapshotTimer);
-        this._tryAddCustomEvent('sessionIdle', {
-          eventTimestamp: event.timestamp,
-          lastActivityTimestamp: this._lastActivityTimestamp,
-          threshold: this._sessionIdleThresholdMilliseconds,
-          bufferLength: this._buffer.data.length,
-          bufferSize: this._buffer.size
-        });
-        // proactively flush the buffer in case the session is idle for a long time
-        this._flushBuffer();
-      }
-    }
-    let returningFromIdle = false;
-    if (isUserInteraction) {
-      this._lastActivityTimestamp = event.timestamp;
-      if (this._isIdle) {
-        const idleWasUnknown = this._isIdle === 'unknown';
-        // Remove the idle state
-        this._isIdle = false;
-        // if the idle state was unknown, we don't want to add an event, since we're just in bootup
-        // whereas if it was true, we know we've been idle for a while, and we can mark ourselves as returning from idle
-        if (!idleWasUnknown) {
-          this._tryAddCustomEvent('sessionNoLongerIdle', {
-            reason: 'user activity',
-            type: event.type
-          });
-          returningFromIdle = true;
-        }
-      }
-    }
-    if (this._isIdle) {
-      return;
-    }
-    // We only want to extend the session if it is an interactive event.
-    const {
-      windowId,
-      sessionId
-    } = this._sessionManager.checkAndGetSessionAndWindowId(!isUserInteraction, event.timestamp);
-    const sessionIdChanged = this._sessionId !== sessionId;
-    const windowIdChanged = this._windowId !== windowId;
-    this._windowId = windowId;
-    this._sessionId = sessionId;
-    if (sessionIdChanged || windowIdChanged) {
-      this.stop();
-      this.start('session_id_changed');
-    } else if (returningFromIdle) {
-      this._scheduleFullSnapshot();
-    }
-  }
-  _clearConditionalRecordingPersistence() {
-    this._instance?.persistence?.unregister(SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION);
-    this._instance?.persistence?.unregister(SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION);
-    this._instance?.persistence?.unregister(SESSION_RECORDING_IS_SAMPLED);
-  }
-  _makeSamplingDecision(sessionId) {
-    const sessionIdChanged = this._sessionId !== sessionId;
-    // capture the current sample rate
-    // because it is re-used multiple times
-    // and the bundler won't minimize any of the references
-    const currentSampleRate = this._sampleRate;
-    if (!isNumber(currentSampleRate)) {
-      this._instance.persistence?.unregister(SESSION_RECORDING_IS_SAMPLED);
-      return;
-    }
-    const storedIsSampled = this._isSampled;
-    /**
-     * if we get this far, then we should make a sampling decision.
-     * When the session id changes or there is no stored sampling decision for this session id
-     * then we should make a new decision.
-     *
-     * Otherwise, we should use the stored decision.
-     */
-    const makeDecision = sessionIdChanged || !isBoolean(storedIsSampled);
-    const shouldSample = makeDecision ? sampleOnProperty(sessionId, currentSampleRate) : storedIsSampled;
-    if (makeDecision) {
-      if (shouldSample) {
-        this._reportStarted(SAMPLED);
-      } else {
-        logger.warn(`Sample rate (${currentSampleRate}) has determined that this sessionId (${sessionId}) will not be sent to the server.`);
-      }
-      this._tryAddCustomEvent('samplingDecisionMade', {
-        sampleRate: currentSampleRate,
-        isSampled: shouldSample
-      });
-    }
-    this._instance.persistence?.register({
-      [SESSION_RECORDING_IS_SAMPLED]: shouldSample ? sessionId : false
-    });
-  }
-  _addEventTriggerListener() {
-    if (this._eventTriggerMatching._eventTriggers.length === 0 || !isNullish(this._removeEventTriggerCaptureHook)) {
-      return;
-    }
-    this._removeEventTriggerCaptureHook = this._instance.on('eventCaptured', event => {
-      // If anything could go wrong here, it has the potential to block the main loop,
-      // so we catch all errors.
-      try {
-        if (this._eventTriggerMatching._eventTriggers.includes(event.event)) {
-          this._activateTrigger('event');
-        }
-      } catch (e) {
-        logger.error('Could not activate event trigger', e);
-      }
-    });
-  }
-  get sdkDebugProperties() {
-    const {
-      sessionStartTimestamp
-    } = this._sessionManager.checkAndGetSessionAndWindowId(true);
-    return {
-      $recording_status: this.status,
-      $sdk_debug_replay_internal_buffer_length: this._buffer.data.length,
-      $sdk_debug_replay_internal_buffer_size: this._buffer.size,
-      $sdk_debug_current_session_duration: this._sessionDuration,
-      $sdk_debug_session_start: sessionStartTimestamp
-    };
-  }
-  _startRecorder() {
-    if (this._stopRrweb) {
-      return;
-    }
-    // rrweb config info: https://github.com/rrweb-io/rrweb/blob/7d5d0033258d6c29599fb08412202d9a2c7b9413/src/record/index.ts#L28
-    const sessionRecordingOptions = {
-      // a limited set of the rrweb config options that we expose to our users.
-      // see https://github.com/rrweb-io/rrweb/blob/master/guide.md
-      blockClass: 'ph-no-capture',
-      blockSelector: undefined,
-      ignoreClass: 'ph-ignore-input',
-      maskTextClass: 'ph-mask',
-      maskTextSelector: undefined,
-      maskTextFn: undefined,
-      maskAllInputs: true,
-      maskInputOptions: {
-        password: true
-      },
-      maskInputFn: undefined,
-      slimDOMOptions: {},
-      collectFonts: false,
-      inlineStylesheet: true,
-      recordCrossOriginIframes: false
-    };
-    // only allows user to set our allowlisted options
-    const userSessionRecordingOptions = this._instance.config.session_recording;
-    for (const [key, value] of Object.entries(userSessionRecordingOptions || {})) {
-      if (key in sessionRecordingOptions) {
-        if (key === 'maskInputOptions') {
-          // ensure password config is set if not included
-          sessionRecordingOptions.maskInputOptions = {
-            password: true,
-            ...value
-          };
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          sessionRecordingOptions[key] = value;
-        }
-      }
-    }
-    if (this._canvasRecording && this._canvasRecording.enabled) {
-      sessionRecordingOptions.recordCanvas = true;
-      sessionRecordingOptions.sampling = {
-        canvas: this._canvasRecording.fps
-      };
-      sessionRecordingOptions.dataURLOptions = {
-        type: 'image/webp',
-        quality: this._canvasRecording.quality
-      };
-    }
-    if (this._masking) {
-      sessionRecordingOptions.maskAllInputs = this._masking.maskAllInputs ?? true;
-      sessionRecordingOptions.maskTextSelector = this._masking.maskTextSelector ?? undefined;
-      sessionRecordingOptions.blockSelector = this._masking.blockSelector ?? undefined;
-    }
-    const rrwebRecord = getRRWebRecord();
-    if (!rrwebRecord) {
-      logger.error('_startRecorder was called but rrwebRecord is not available. This indicates something has gone wrong.');
-      return;
-    }
-    this._mutationThrottler = this._mutationThrottler ?? new MutationThrottler(rrwebRecord, {
-      refillRate: this._instance.config.session_recording?.__mutationThrottlerRefillRate,
-      bucketSize: this._instance.config.session_recording?.__mutationThrottlerBucketSize,
-      onBlockedNode: (id, node) => {
-        const message = `Too many mutations on node '${id}'. Rate limiting. This could be due to SVG animations or something similar`;
-        logger.info(message, {
-          node: node
-        });
-        this.log(LOGGER_PREFIX$1 + ' ' + message, 'warn');
-      }
-    });
-    const activePlugins = this._gatherRRWebPlugins();
-    this._stopRrweb = rrwebRecord({
-      emit: event => {
-        this.onRRwebEmit(event);
-      },
-      plugins: activePlugins,
-      ...sessionRecordingOptions
-    });
-    // We reset the last activity timestamp, resetting the idle timer
-    this._lastActivityTimestamp = Date.now();
-    // stay unknown if we're not sure if we're idle or not
-    this._isIdle = isBoolean(this._isIdle) ? this._isIdle : 'unknown';
-    this.tryAddCustomEvent('$remote_config_received', this._remoteConfig);
-    this._tryAddCustomEvent('$session_options', {
-      sessionRecordingOptions,
-      activePlugins: activePlugins.map(p => p?.name)
-    });
-    this._tryAddCustomEvent('$posthog_config', {
-      config: this._instance.config
-    });
-  }
-  tryAddCustomEvent(tag, payload) {
-    return this._tryAddCustomEvent(tag, payload);
-  }
-}
-
-const LOGGER_PREFIX = '[SessionRecording]';
-const log = {
-  info: (...args) => logger$3.info(LOGGER_PREFIX, ...args),
-  warn: (...args) => logger$3.warn(LOGGER_PREFIX, ...args),
-  error: (...args) => logger$3.error(LOGGER_PREFIX, ...args)
-};
-class SessionRecording {
-  get started() {
-    return !!this._lazyLoadedSessionRecording?.isStarted;
-  }
-  /**
-   * defaults to buffering mode until a flags response is received
-   * once a flags response is received status can be disabled, active or sampled
-   */
-  get status() {
-    if (this._lazyLoadedSessionRecording) {
-      return this._lazyLoadedSessionRecording.status;
-    }
-    if (this._receivedFlags && !this._isRecordingEnabled) {
-      return DISABLED;
-    }
-    return LAZY_LOADING;
-  }
-  constructor(_instance) {
-    this._instance = _instance;
-    this._forceAllowLocalhostNetworkCapture = false;
-    this._receivedFlags = false;
-    this._serverRecordingEnabled = false;
-    this._persistFlagsOnSessionListener = undefined;
-    if (!this._instance.sessionManager) {
-      log.error('started without valid sessionManager');
-      throw new Error(LOGGER_PREFIX + ' started without valid sessionManager. This is a bug.');
-    }
-    if (this._instance.config.cookieless_mode === 'always') {
-      throw new Error(LOGGER_PREFIX + ' cannot be used with cookieless_mode="always"');
-    }
-  }
-  get _isRecordingEnabled() {
-    if (!win) {
-      return false;
-    }
-    if (!this._serverRecordingEnabled) {
-      return false;
-    }
-    if (this._instance.config.disable_session_recording) {
-      return false;
-    }
-    return true;
-  }
-  startIfEnabledOrStop(startReason) {
-    const canRunReplay = !isUndefined(Object.assign) && !isUndefined(Array.from);
-    if (!this._isRecordingEnabled || !canRunReplay) {
-      this.stopRecording();
-      return;
-    }
-    if (this._lazyLoadedSessionRecording?.isStarted) {
-      return;
-    }
-    // According to the rrweb docs, rrweb is not supported on IE11 and below:
-    // "rrweb does not support IE11 and below because it uses the MutationObserver API, which was supported by these browsers."
-    // https://github.com/rrweb-io/rrweb/blob/master/guide.md#compatibility-note
-    //
-    // However, MutationObserver does exist on IE11, it just doesn't work well and does not detect all changes.
-    // Instead, when we load "recorder.js", the first JS error is about "Object.assign" and "Array.from" being undefined.
-    // Thus instead of MutationObserver, we look for this function and block recording if it's undefined.
-    this._lazyLoadAndStart(startReason);
-    log.info('starting');
-  }
-  /**
-   * session recording waits until it receives remote config before loading the script
-   * this is to ensure we can control the script name remotely
-   * and because we wait until we have local and remote config to determine if we should start at all
-   * if start is called and there is no remote config then we wait until there is
-   */
-  _lazyLoadAndStart(startReason) {
-    // by checking `_isRecordingEnabled` here we know that
-    // we have stored remote config and client config to read
-    // replay waits for both local and remote config before starting
-    if (!this._isRecordingEnabled) {
-      return;
-    }
-    this._onScriptLoaded(startReason);
-  }
-  stopRecording() {
-    this._persistFlagsOnSessionListener?.();
-    this._persistFlagsOnSessionListener = undefined;
-    this._lazyLoadedSessionRecording?.stop();
-  }
-  _resetSampling() {
-    this._instance.persistence?.unregister(SESSION_RECORDING_IS_SAMPLED);
-  }
-  _persistRemoteConfig(response) {
-    if (this._instance.persistence) {
-      const persistence = this._instance.persistence;
-      const persistResponse = () => {
-        const sessionRecordingConfigResponse = response.sessionRecording === false ? undefined : response.sessionRecording;
-        const receivedSampleRate = sessionRecordingConfigResponse?.sampleRate;
-        const parsedSampleRate = isNullish(receivedSampleRate) ? null : parseFloat(receivedSampleRate);
-        if (isNullish(parsedSampleRate)) {
-          this._resetSampling();
-        }
-        const receivedMinimumDuration = sessionRecordingConfigResponse?.minimumDurationMilliseconds;
-        persistence.register({
-          [SESSION_RECORDING_REMOTE_CONFIG]: {
-            enabled: !!sessionRecordingConfigResponse,
-            ...sessionRecordingConfigResponse,
-            networkPayloadCapture: {
-              capturePerformance: response.capturePerformance,
-              ...sessionRecordingConfigResponse?.networkPayloadCapture
-            },
-            canvasRecording: {
-              enabled: sessionRecordingConfigResponse?.recordCanvas,
-              fps: sessionRecordingConfigResponse?.canvasFps,
-              quality: sessionRecordingConfigResponse?.canvasQuality
-            },
-            sampleRate: parsedSampleRate,
-            minimumDurationMilliseconds: isUndefined(receivedMinimumDuration) ? null : receivedMinimumDuration,
-            endpoint: sessionRecordingConfigResponse?.endpoint,
-            triggerMatchType: sessionRecordingConfigResponse?.triggerMatchType,
-            masking: sessionRecordingConfigResponse?.masking,
-            urlTriggers: sessionRecordingConfigResponse?.urlTriggers
-          }
-        });
-      };
-      persistResponse();
-      // in case we see multiple flags responses, we should only use the response from the most recent one
-      this._persistFlagsOnSessionListener?.();
-      // we 100% know there is a session manager by this point
-      this._persistFlagsOnSessionListener = this._instance.sessionManager?.onSessionId(persistResponse);
-    }
-  }
-  _clearRemoteConfig() {
-    this._instance.persistence?.unregister(SESSION_RECORDING_REMOTE_CONFIG);
-    this._resetSampling();
-  }
-  onRemoteConfig(response) {
-    if (!('sessionRecording' in response)) {
-      // if sessionRecording is not in the response, we do nothing
-      log.info('skipping remote config with no sessionRecording', response);
-      return;
-    }
-    this._receivedFlags = true;
-    if (response.sessionRecording === false) {
-      this._serverRecordingEnabled = false;
-      this._clearRemoteConfig();
-      this.stopRecording();
-      return;
-    }
-    this._serverRecordingEnabled = true;
-    this._persistRemoteConfig(response);
-    this.startIfEnabledOrStop();
-  }
-  log(message, level = 'log') {
-    if (this._lazyLoadedSessionRecording?.log) {
-      this._lazyLoadedSessionRecording.log(message, level);
-    } else {
-      logger$3.warn('log called before recorder was ready');
-    }
-  }
-  _onScriptLoaded(startReason) {
-    if (!this._lazyLoadedSessionRecording) {
-      this._lazyLoadedSessionRecording = new LazyLoadedSessionRecording(this._instance);
-      this._lazyLoadedSessionRecording._forceAllowLocalhostNetworkCapture = this._forceAllowLocalhostNetworkCapture;
-    }
-    this._lazyLoadedSessionRecording.start(startReason);
-  }
-  /**
-   * this is maintained on the public API only because it has always been on the public API
-   * if you are calling this directly you are certainly doing something wrong
-   * @deprecated
-   */
-  onRRwebEmit(rawEvent) {
-    this._lazyLoadedSessionRecording?.onRRwebEmit?.(rawEvent);
-  }
-  /**
-   * this ignores the linked flag config and (if other conditions are met) causes capture to start
-   *
-   * It is not usual to call this directly,
-   * instead call `posthog.startSessionRecording({linked_flag: true})`
-   * */
-  overrideLinkedFlag() {
-    // TODO what if this gets called before lazy loading is done
-    this._lazyLoadedSessionRecording?.overrideLinkedFlag();
-  }
-  /**
-   * this ignores the sampling config and (if other conditions are met) causes capture to start
-   *
-   * It is not usual to call this directly,
-   * instead call `posthog.startSessionRecording({sampling: true})`
-   * */
-  overrideSampling() {
-    // TODO what if this gets called before lazy loading is done
-    this._lazyLoadedSessionRecording?.overrideSampling();
-  }
-  /**
-   * this ignores the URL/Event trigger config and (if other conditions are met) causes capture to start
-   *
-   * It is not usual to call this directly,
-   * instead call `posthog.startSessionRecording({trigger: 'url' | 'event'})`
-   * */
-  overrideTrigger(triggerType) {
-    // TODO what if this gets called before lazy loading is done
-    this._lazyLoadedSessionRecording?.overrideTrigger(triggerType);
-  }
-  /*
-   * whenever we capture an event, we add these properties to the event
-   * these are used to debug issues with the session recording
-   * when looking at the event feed for a session
-   */
-  get sdkDebugProperties() {
-    return this._lazyLoadedSessionRecording?.sdkDebugProperties || {
-      $recording_status: this.status
-    };
-  }
-  /**
-   * This adds a custom event to the session recording
-   *
-   * It is not intended for arbitrary public use - playback only displays known custom events
-   * And is exposed on the public interface only so that other parts of the SDK are able to use it
-   *
-   * if you are calling this from client code, you're probably looking for `posthog.capture('$custom_event', {...})`
-   */
-  tryAddCustomEvent(tag, payload) {
-    return !!this._lazyLoadedSessionRecording?.tryAddCustomEvent(tag, payload);
-  }
-}
-
-const defaultConfig = () => ({
-  host: 'https://i.leanbase.co',
-  token: '',
-  autocapture: true,
-  rageclick: true,
-  disable_session_recording: false,
-  session_recording: {
-    // Force-enable session recording locally unless explicitly disabled via config
-    forceClientRecording: true
-  },
-  enable_recording_console_log: undefined,
-  persistence: 'localStorage+cookie',
-  capture_pageview: 'history_change',
-  capture_pageleave: 'if_capture_pageview',
-  persistence_name: '',
-  mask_all_element_attributes: false,
-  cookie_expiration: 365,
-  cross_subdomain_cookie: isCrossDomainCookie(document?.location),
-  custom_campaign_params: [],
-  custom_personal_data_properties: [],
-  disable_persistence: false,
-  mask_personal_data_properties: false,
-  secure_cookie: window?.location?.protocol === 'https:',
-  mask_all_text: false,
-  bootstrap: {},
-  session_idle_timeout_seconds: 30 * 60,
-  save_campaign_params: true,
-  save_referrer: true,
-  opt_out_useragent_filter: false,
-  properties_string_max_length: 65535,
-  loaded: () => {}
-});
-class Leanbase extends PostHogCore {
-  constructor(token, config) {
-    const mergedConfig = extend(defaultConfig(), config || {}, {
-      token
-    });
-    super(token, mergedConfig);
-    this.personProcessingSetOncePropertiesSent = false;
-    this.isLoaded = false;
-    this.config = mergedConfig;
-    this.visibilityStateListener = null;
-    this.initialPageviewCaptured = false;
-    this.scrollManager = new ScrollManager(this);
-    this.pageViewManager = new PageViewManager(this);
-    this.init(token, mergedConfig);
-  }
-  init(token, config) {
-    this.setConfig(extend(defaultConfig(), config, {
-      token
-    }));
-    this.isLoaded = true;
-    this.persistence = new LeanbasePersistence(this.config);
-    if (this.config.cookieless_mode !== 'always') {
-      this.sessionManager = new SessionIdManager(this);
-      this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence);
-    }
-    this.replayAutocapture = new Autocapture(this);
-    this.replayAutocapture.startIfEnabled();
-    if (this.sessionManager && this.config.cookieless_mode !== 'always') {
-      this.sessionRecording = new SessionRecording(this);
-      this.sessionRecording.startIfEnabledOrStop();
-    }
-    if (this.config.preloadFeatureFlags !== false) {
-      this.reloadFeatureFlags();
-    }
-    this.config.loaded?.(this);
-    if (this.config.capture_pageview) {
-      setTimeout(() => {
-        if (this.config.cookieless_mode === 'always') {
-          this.captureInitialPageview();
-        }
-      }, 1);
-    }
-    addEventListener(document, 'DOMContentLoaded', () => {
-      this.loadRemoteConfig();
-    });
-    addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
-      passive: false
-    });
-  }
-  captureInitialPageview() {
-    if (!document) {
-      return;
-    }
-    if (document.visibilityState !== 'visible') {
-      if (!this.visibilityStateListener) {
-        this.visibilityStateListener = this.captureInitialPageview.bind(this);
-        addEventListener(document, 'visibilitychange', this.visibilityStateListener);
-      }
-      return;
-    }
-    if (!this.initialPageviewCaptured) {
-      this.initialPageviewCaptured = true;
-      this.capture('$pageview', {
-        title: document.title
-      });
-      if (this.visibilityStateListener) {
-        document.removeEventListener('visibilitychange', this.visibilityStateListener);
-        this.visibilityStateListener = null;
-      }
-    }
-  }
-  capturePageLeave() {
-    const {
-      capture_pageleave,
-      capture_pageview
-    } = this.config;
-    if (capture_pageleave === true || capture_pageleave === 'if_capture_pageview' && (capture_pageview === true || capture_pageview === 'history_change')) {
-      this.capture('$pageleave');
-    }
-  }
-  async loadRemoteConfig() {
-    if (!this.isRemoteConfigLoaded) {
-      const remoteConfig = await this.reloadRemoteConfigAsync();
-      if (remoteConfig) {
-        this.onRemoteConfig(remoteConfig);
-      }
-    }
-  }
-  onRemoteConfig(config) {
-    if (!(document && document.body)) {
-      setTimeout(() => {
-        this.onRemoteConfig(config);
-      }, 500);
-      return;
-    }
-    this.isRemoteConfigLoaded = true;
-    this.replayAutocapture?.onRemoteConfig(config);
-    this.sessionRecording?.onRemoteConfig(config);
-  }
-  async fetch(url, options) {
-    const fetchFn = getFetch();
-    if (!fetchFn) {
-      throw new Error('Fetch API is not available in this environment.');
-    }
-    try {
-      const isPost = !options.method || options.method.toUpperCase() === 'POST';
-      const isBatchEndpoint = typeof url === 'string' && url.endsWith('/batch/');
-      if (isPost && isBatchEndpoint && options && options.body) {
-        let parsed = null;
-        try {
-          const headers = options.headers || {};
-          const contentEncoding = (headers['Content-Encoding'] || headers['content-encoding'] || '').toLowerCase();
-          const toUint8 = async body => {
-            if (typeof body === 'string') return new TextEncoder().encode(body);
-            if (typeof Blob !== 'undefined' && body instanceof Blob) {
-              const ab = await body.arrayBuffer();
-              return new Uint8Array(ab);
-            }
-            if (body instanceof ArrayBuffer) return new Uint8Array(body);
-            if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer ?? body);
-            try {
-              return new TextEncoder().encode(String(body));
-            } catch {
-              return null;
-            }
-          };
-          if (contentEncoding === 'gzip' || contentEncoding === 'deflate') {
-            const u8 = await toUint8(options.body);
-            if (u8) {
-              try {
-                const dec = decompressSync(u8);
-                const s = strFromU8(dec);
-                parsed = JSON.parse(s);
-              } catch {
-                parsed = null;
-              }
-            }
-          } else {
-            if (typeof options.body === 'string') {
-              parsed = JSON.parse(options.body);
-            } else {
-              const u8 = await toUint8(options.body);
-              if (u8) {
-                try {
-                  parsed = JSON.parse(new TextDecoder().decode(u8));
-                } catch {
-                  parsed = null;
-                }
-              } else {
-                try {
-                  parsed = JSON.parse(String(options.body));
-                } catch {
-                  parsed = null;
-                }
-              }
-            }
-          }
-        } catch {
-          parsed = null;
-        }
-        if (parsed && isArray(parsed.batch)) {
-          const hasSnapshot = parsed.batch.some(item => item && item.event === '$snapshot');
-          // Debug logging to help diagnose routing issues
-          try {
-            // eslint-disable-next-line no-console
-            console.debug('[Leanbase.fetch] parsed.batch.length=', parsed.batch.length, 'hasSnapshot=', hasSnapshot);
-          } catch {}
-          // If remote config has explicitly disabled session recording, drop snapshot events
-          try {
-            // Read persisted remote config that SessionRecording stores
-            const persisted = this.get_property(SESSION_RECORDING_REMOTE_CONFIG);
-            const serverAllowsRecording = !(persisted && persisted.enabled === false || this.config.disable_session_recording === true);
-            if (!serverAllowsRecording && hasSnapshot) {
-              // remove snapshot events from the batch before sending to /batch/
-              parsed.batch = parsed.batch.filter(item => !(item && item.event === '$snapshot'));
-              // If no events remain, short-circuit and avoid sending an empty batch
-              if (!parsed.batch.length) {
-                try {
-                  // eslint-disable-next-line no-console
-                  console.debug('[Leanbase.fetch] sessionRecording disabled, dropping snapshot-only batch');
-                } catch {}
-                return {
-                  status: 200,
-                  json: async () => ({})
-                };
-              }
-              // re-encode the body so the underlying fetch receives the modified batch
-              try {
-                const newBody = JSON.stringify(parsed);
-                options = {
-                  ...options,
-                  body: newBody
-                };
-              } catch {}
-            }
-          } catch {}
-          if (hasSnapshot) {
-            const host = this.config && this.config.host || '';
-            const newUrl = host ? `${host.replace(/\/$/, '')}/s/` : url;
-            try {
-              // eslint-disable-next-line no-console
-              console.debug('[Leanbase.fetch] routing snapshot batch to', newUrl);
-            } catch {}
-            return fetchFn(newUrl, options);
-          }
-        }
-      }
-    } catch {
-      return fetchFn(url, options);
-    }
-    return fetchFn(url, options);
-  }
-  setConfig(config) {
-    const oldConfig = {
-      ...this.config
-    };
-    if (isObject(config)) {
-      extend(this.config, config);
-      this.persistence?.update_config(this.config, oldConfig);
-      this.replayAutocapture?.startIfEnabled();
-      this.sessionRecording?.startIfEnabledOrStop();
-    }
-    const isTempStorage = this.config.persistence === 'sessionStorage' || this.config.persistence === 'memory';
-    this.sessionPersistence = isTempStorage ? this.persistence : new LeanbasePersistence({
-      ...this.config,
-      persistence: 'sessionStorage'
-    });
-  }
-  getLibraryId() {
-    return 'leanbase';
-  }
-  getLibraryVersion() {
-    return Config.LIB_VERSION;
-  }
-  getCustomUserAgent() {
-    return;
-  }
-  getPersistedProperty(key) {
-    return this.persistence?.get_property(key);
-  }
-  get_property(key) {
-    return this.persistence?.get_property(key);
-  }
-  setPersistedProperty(key, value) {
-    this.persistence?.set_property(key, value);
+  unregister_for_session(property) {
+    if (isFunction(this.unregisterForSession)) {
+      this.unregisterForSession(property);
+      return;
+    }
+    if (this.sessionPersistence) {
+      this.sessionPersistence.set_property(property, null);
+    }
   }
   calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
     if (!this.persistence || !this.sessionPersistence) {
@@ -5981,7 +3374,7 @@ class Leanbase extends PostHogCore {
       };
       properties['distinct_id'] = persistenceProps.distinct_id;
       if (!(isString(properties['distinct_id']) || isNumber(properties['distinct_id'])) || isEmptyString(properties['distinct_id'])) {
-        logger$3.error('Invalid distinct_id for replay event. This indicates a bug in your implementation');
+        logger.error('Invalid distinct_id for replay event. This indicates a bug in your implementation');
       }
       return properties;
     }
@@ -5997,13 +3390,6 @@ class Leanbase extends PostHogCore {
     if (this.sessionPropsManager) {
       extend(properties, this.sessionPropsManager.getSessionProps());
     }
-    try {
-      if (this.sessionRecording) {
-        extend(properties, this.sessionRecording.sdkDebugProperties);
-      }
-    } catch (e) {
-      properties['$sdk_debug_error_capturing_properties'] = String(e);
-    }
     let pageviewProperties = this.pageViewManager.doEvent();
     if (eventName === '$pageview' && !readOnly) {
       pageviewProperties = this.pageViewManager.doPageView(timestamp, uuid);
@@ -6056,11 +3442,11 @@ class Leanbase extends PostHogCore {
       return;
     }
     if (isUndefined(event) || !isString(event)) {
-      logger$3.error('No event name provided to posthog.capture');
+      logger.error('No event name provided to posthog.capture');
       return;
     }
     if (properties?.$current_url && !isString(properties?.$current_url)) {
-      logger$3.error('Invalid `$current_url` property provided to `posthog.capture`. Input must be a string. Ignoring provided value.');
+      logger.error('Invalid `$current_url` property provided to `posthog.capture`. Input must be a string. Ignoring provided value.');
       delete properties?.$current_url;
     }
     this.sessionPersistence.update_search_keyword();