@leanbase-giangnd/js 0.0.7 → 0.1.1

package/dist/index.mjs

@@ -1,4 +1,6 @@
-import { isArray, isString, isNullish, isFormData, hasOwnProperty, isNumber, isNull, PostHogPersistedProperty, isUndefined, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, isBoolean, trim, clampToRange, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
+import { isArray, isNullish, isFormData, hasOwnProperty, isString, isNull, isNumber, PostHogPersistedProperty, isUndefined, isFile, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, trim, isBoolean, clampToRange, BucketedRateLimiter, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
+import { record } from '@rrweb/record';
+import { strFromU8, gzipSync, strToU8 } from 'fflate';
 
 const breaker = {};
 const ArrayProto = Array.prototype;
@@ -8,7 +10,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 = global?.location;
+const location$1 = global?.location;
 global?.fetch;
 global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined;
 global?.AbortController;
@@ -195,10 +197,13 @@ 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';
@@ -223,7 +228,7 @@ PostHogPersistedProperty.Queue, PostHogPersistedProperty.FeatureFlagDetails, Pos
 
 /* eslint-disable no-console */
 const PREFIX = '[Leanbase]';
-const logger = {
+const logger$3 = {
   info: (...args) => {
     if (typeof console !== 'undefined') {
       console.log(PREFIX, ...args);
@@ -521,7 +526,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
     if (!matchedSubDomain) {
       const originalMatch = originalCookieDomainFn(hostname);
       if (originalMatch !== matchedSubDomain) {
-        logger.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
+        logger$3.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
       }
       matchedSubDomain = originalMatch;
     }
@@ -533,7 +538,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
 const cookieStore = {
   _is_supported: () => !!document,
   _error: function (msg) {
-    logger.error('cookieStore error: ' + msg);
+    logger$3.error('cookieStore error: ' + msg);
   },
   _get: function (name) {
     if (!document) {
@@ -582,7 +587,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.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length);
+        logger$3.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length);
       }
       document.cookie = new_cookie_val;
       return new_cookie_val;
@@ -624,13 +629,13 @@ const localStore = {
       supported = false;
     }
     if (!supported) {
-      logger.error('localStorage unsupported; falling back to cookie store');
+      logger$3.error('localStorage unsupported; falling back to cookie store');
     }
     _localStorage_supported = supported;
     return supported;
   },
   _error: function (msg) {
-    logger.error('localStorage error: ' + msg);
+    logger$3.error('localStorage error: ' + msg);
   },
   _get: function (name) {
     try {
@@ -716,7 +721,7 @@ const memoryStore = {
     return true;
   },
   _error: function (msg) {
-    logger.error('memoryStorage error: ' + msg);
+    logger$3.error('memoryStorage error: ' + msg);
   },
   _get: function (name) {
     return memoryStorage[name] || null;
@@ -757,7 +762,7 @@ const sessionStore = {
     return sessionStorageSupported;
   },
   _error: function (msg) {
-    logger.error('sessionStorage error: ', msg);
+    logger$3.error('sessionStorage error: ', msg);
   },
   _get: function (name) {
     try {
@@ -791,6 +796,7 @@ 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
@@ -805,6 +811,21 @@ 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] || '';
@@ -828,7 +849,7 @@ const getQueryParam = function (url, param) {
     try {
       result = decodeURIComponent(result);
     } catch {
-      logger.error('Skipping decoding for malformed query param: ' + result);
+      logger$3.error('Skipping decoding for malformed query param: ' + result);
     }
     return result.replace(/\+/g, ' ');
   }
@@ -867,6 +888,9 @@ 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
@@ -1159,7 +1183,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.0.7";
+var version = "0.1.1";
 var packageInfo = {
 	version: version};
 
@@ -1309,7 +1333,7 @@ function getReferrerInfo() {
 }
 function getPersonInfo(maskPersonalDataProperties, customPersonalDataProperties) {
   const paramsToMask = maskPersonalDataProperties ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || []) : [];
-  const url = location?.href.substring(0, 1000);
+  const url = location$1?.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),
@@ -1377,9 +1401,9 @@ function getEventProperties(maskPersonalDataProperties, customPersonalDataProper
     $timezone: getTimezone(),
     $timezone_offset: getTimezoneOffset()
   }), {
-    $current_url: maskQueryParams(location?.href, paramsToMask, MASKED),
-    $host: location?.host,
-    $pathname: location?.pathname,
+    $current_url: maskQueryParams(location$1?.href, paramsToMask, MASKED),
+    $host: location$1?.host,
+    $pathname: location$1?.pathname,
     $raw_user_agent: userAgent.length > 1000 ? userAgent.substring(0, 997) + '...' : userAgent,
     $browser_version: detectBrowserVersion(userAgent, navigator.vendor),
     $browser_language: getBrowserLanguage(),
@@ -1424,7 +1448,7 @@ class LeanbasePersistence {
     this._storage = this._buildStorage(config);
     this.load();
     if (config.debug) {
-      logger.info('Persistence loaded', config['persistence'], {
+      logger$3.info('Persistence loaded', config['persistence'], {
         ...this.props
       });
     }
@@ -1440,7 +1464,7 @@ class LeanbasePersistence {
   }
   _buildStorage(config) {
     if (CASE_INSENSITIVE_PERSISTENCE_TYPES.indexOf(config['persistence'].toLowerCase()) === -1) {
-      logger.info('Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie');
+      logger$3.info('Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie');
       config['persistence'] = 'localStorage+cookie';
     }
     let store;
@@ -2076,7 +2100,7 @@ function getNestedSpanText(target) {
             text = `${text} ${getNestedSpanText(child)}`.trim();
           }
         } catch (e) {
-          logger.error('[AutoCapture]', e);
+          logger$3.error('[AutoCapture]', e);
         }
       }
     });
@@ -2378,7 +2402,7 @@ class Autocapture {
   }
   _addDomEventHandlers() {
     if (!this.isBrowserSupported()) {
-      logger.info('Disabling Automatic Event Collection because this browser is not supported');
+      logger$3.info('Disabling Automatic Event Collection because this browser is not supported');
       return;
     }
     if (!win || !document) {
@@ -2389,7 +2413,7 @@ class Autocapture {
       try {
         this._captureEvent(e);
       } catch (error) {
-        logger.error('Failed to capture event', error);
+        logger$3.error('Failed to capture event', error);
       }
     };
     addEventListener(document, 'submit', handler, {
@@ -2574,7 +2598,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, DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS) * 1000;
+    this._sessionTimeoutMs = clampToRange(desiredTimeout, MIN_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, logger$3, DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS) * 1000;
     instance.register({
       $configured_session_timeout_ms: this._sessionTimeoutMs
     });
@@ -2601,7 +2625,7 @@ class SessionIdManager {
         const sessionStartTimestamp = uuid7ToTimestampMs(this._config.bootstrap.sessionID);
         this._setSessionId(this._config.bootstrap.sessionID, new Date().getTime(), sessionStartTimestamp);
       } catch (e) {
-        logger.error('Invalid sessionID in bootstrap', e);
+        logger$3.error('Invalid sessionID in bootstrap', e);
       }
     }
     this._listenToReloadWindow();
@@ -2742,7 +2766,7 @@ class SessionIdManager {
     if (noSessionId || activityTimeout || sessionPastMaximumLength) {
       sessionId = this._sessionIdGenerator();
       windowId = this._windowIdGenerator();
-      logger.info('new session ID generated', {
+      logger$3.info('new session ID generated', {
         sessionId,
         windowId,
         changeReason: {
@@ -2871,67 +2895,6 @@ 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,
@@ -2992,10 +2955,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);
-        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);
+        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);
         properties = extend(properties, {
           $prev_pageview_last_scroll: lastScrollY,
           $prev_pageview_last_scroll_percentage: lastScrollPercentage,
@@ -3158,206 +3121,2762 @@ const isLikelyBot = function (navigator, customBlockedUserAgents) {
   // It would be very bad if posthog-js caused a permission prompt to appear on every page load.
 };
 
-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
-    });
-    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);
-  }
-  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();
-    }
-    if (this.config.preloadFeatureFlags !== false) {
-      this.reloadFeatureFlags();
+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;
+
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {
+        //
+      };
     }
-    this.config.loaded?.(this);
-    if (this.config.capture_pageview) {
-      setTimeout(() => {
-        if (this.config.cookieless_mode === 'always') {
-          this.captureInitialPageview();
+    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
         }
-      }, 1);
+      });
     }
-    addEventListener(document, 'DOMContentLoaded', () => {
-      this.loadRemoteConfig();
-    });
-    addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
-      passive: false
-    });
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch {
+    return () => {
+      //
+    };
   }
-  captureInitialPageview() {
-    if (!document) {
-      return;
-    }
-    if (document.visibilityState !== 'visible') {
-      if (!this.visibilityStateListener) {
-        this.visibilityStateListener = this.captureInitialPageview.bind(this);
-        addEventListener(document, 'visibilitychange', this.visibilityStateListener);
-      }
-      return;
+}
+
+function hostnameFromURL(url) {
+  try {
+    if (typeof url === 'string') {
+      return new URL(url).hostname;
     }
-    if (!this.initialPageviewCaptured) {
-      this.initialPageviewCaptured = true;
-      this.capture('$pageview', {
-        title: document.title
-      });
-      if (this.visibilityStateListener) {
-        document.removeEventListener('visibilitychange', this.visibilityStateListener);
-        this.visibilityStateListener = null;
-      }
+    if ('url' in url) {
+      return new URL(url.url).hostname;
     }
+    return url.hostname;
+  } catch {
+    return 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');
+}
+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
+      };
     }
   }
-  async loadRemoteConfig() {
-    if (!this.isRemoteConfigLoaded) {
-      const remoteConfig = await this.reloadRemoteConfigAsync();
-      if (remoteConfig) {
-        this.onRemoteConfig(remoteConfig);
+  return defaultNotDenied;
+}
+
+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;
       }
-    }
+    });
+    data.requestHeaders = mutableHeaders;
   }
-  onRemoteConfig(config) {
-    if (!(document && document.body)) {
-      setTimeout(() => {
-        this.onRemoteConfig(config);
-      }, 500);
-      return;
-    }
-    this.isRemoteConfigLoaded = true;
-    this.replayAutocapture?.onRemoteConfig(config);
+  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;
   }
-  fetch(url, options) {
-    const fetchFn = getFetch();
-    if (!fetchFn) {
-      return Promise.reject(new Error('Fetch API is not available in this environment.'));
+  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;
+  }
+  each(PAYLOAD_CONTENT_DENY_LIST, text => {
+    if (scrubbed?.length && scrubbed?.indexOf(text) !== -1) {
+      scrubbed = LOGGER_PREFIX$2 + ' ' + label + ' body ' + REDACTED + ' as might contain: ' + text;
     }
-    return fetchFn(url, options);
+  });
+  return scrubbed;
+}
+function scrubPayloads(capturedRequest) {
+  if (isUndefined(capturedRequest)) {
+    return undefined;
   }
-  setConfig(config) {
-    const oldConfig = {
-      ...this.config
+  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
+      };
     };
-    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'
+  }
+  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
+  };
+};
+
+/// <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
     });
   }
-  getLibraryId() {
-    return 'leanbase';
+  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));
   }
-  getLibraryVersion() {
-    return Config.LIB_VERSION;
+  /**
+   * 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;
+    }
   }
-  getCustomUserAgent() {
-    return;
+  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
+    });
+    return null;
   }
-  getPersistedProperty(key) {
-    return this.persistence?.get_property(key);
+  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);
   }
-  setPersistedProperty(key, value) {
-    this.persistence?.set_property(key, value);
+  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;
   }
-  // Backwards-compatible aliases expected by replay/browser code
-  get_property(key) {
-    return this.persistence?.get_property(key);
+  const {
+    hostname,
+    isHostDenied
+  } = isHostOnDenyList(url, options);
+  if (isHostDenied) {
+    return hostname + ' is in deny list';
   }
-  set_property(key, value) {
-    this.persistence?.set_property(key, value);
+  if (isString(body)) {
+    return body;
   }
-  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]));
-    }
+  if (isDocument(body)) {
+    return body.textContent;
   }
-  unregister_for_session(property) {
-    if (isFunction(this.unregisterForSession)) {
-      this.unregisterForSession(property);
-      return;
-    }
-    if (this.sessionPersistence) {
-      this.sessionPersistence.set_property(property, null);
-    }
+  if (isFormData(body)) {
+    return formDataToQuery(body);
   }
-  calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
-    if (!this.persistence || !this.sessionPersistence) {
-      return eventProperties;
+  if (isObject(body)) {
+    try {
+      return JSON.stringify(body);
+    } catch {
+      return '[SessionReplay] Failed to stringify response object';
+    }
+  }
+  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
+
+// Use a safe global target (prefer `win`, fallback to globalThis)
+const _target = win ?? globalThis;
+_target.__PosthogExtensions__ = _target.__PosthogExtensions__ || {};
+// Expose rrweb.record under the same contract
+_target.__PosthogExtensions__.rrweb = _target.__PosthogExtensions__.rrweb || {
+  record: record
+};
+// Provide initSessionRecording if not present — return a new LazyLoadedSessionRecording when called
+_target.__PosthogExtensions__.initSessionRecording = _target.__PosthogExtensions__.initSessionRecording || (instance => {
+  return new LazyLoadedSessionRecording(instance);
+});
+// Provide a no-op loadExternalDependency that calls the callback immediately (since rrweb is bundled)
+_target.__PosthogExtensions__.loadExternalDependency = _target.__PosthogExtensions__.loadExternalDependency || ((instance, scriptName, cb) => {
+  if (cb) cb(undefined);
+});
+// Provide rrwebPlugins object with network plugin factory if not present
+_target.__PosthogExtensions__.rrwebPlugins = _target.__PosthogExtensions__.rrwebPlugins || {};
+_target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin = _target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin || (() => getRecordNetworkPlugin);
+
+// 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 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() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ext = globalThis.__PosthogExtensions__;
+    if (ext && ext.rrweb && ext.rrweb.record) {
+      return ext.rrweb.record;
+    }
+  } catch {
+    // ignore
+  }
+  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._instance.requestRouter.endpointFor('api', this._endpoint),
+      _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() {
+    const enabled_server_side = !!this._instance.get_property(SESSION_RECORDING_REMOTE_CONFIG)?.enabled;
+    const enabled_client_side = !this._instance.config.disable_session_recording;
+    const isDisabled = this._instance.config.disable_session_recording || this._instance.consent?.isOptedOut?.();
+    return win && enabled_server_side && enabled_client_side && !isDisabled;
+  }
+  startIfEnabledOrStop(startReason) {
+    if (this._isRecordingEnabled && this._lazyLoadedSessionRecording?.isStarted) {
+      return;
+    }
+    const canRunReplay = !isUndefined(Object.assign) && !isUndefined(Array.from);
+    if (this._isRecordingEnabled && canRunReplay) {
+      this._lazyLoadAndStart(startReason);
+      log.info('starting');
+    } else {
+      this.stopRecording();
+    }
+  }
+  /**
+   * 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);
+  }
+  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);
+  }
+  setConfig(config) {
+    const oldConfig = {
+      ...this.config
+    };
+    if (isObject(config)) {
+      extend(this.config, config);
+      if (!this.config.api_host && this.config.host) {
+        this.config.api_host = this.config.host;
+      }
+      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);
+  }
+  calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
+    if (!this.persistence || !this.sessionPersistence) {
+      return eventProperties;
     }
     timestamp = timestamp || new Date();
     const startTimestamp = readOnly ? undefined : this.persistence?.remove_event_timer(eventName);
@@ -3374,7 +5893,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.error('Invalid distinct_id for replay event. This indicates a bug in your implementation');
+        logger$3.error('Invalid distinct_id for replay event. This indicates a bug in your implementation');
       }
       return properties;
     }
@@ -3390,6 +5909,13 @@ 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);
@@ -3442,11 +5968,11 @@ class Leanbase extends PostHogCore {
       return;
     }
     if (isUndefined(event) || !isString(event)) {
-      logger.error('No event name provided to posthog.capture');
+      logger$3.error('No event name provided to posthog.capture');
       return;
     }
     if (properties?.$current_url && !isString(properties?.$current_url)) {
-      logger.error('Invalid `$current_url` property provided to `posthog.capture`. Input must be a string. Ignoring provided value.');
+      logger$3.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();