@leanbase-giangnd/js 0.0.7 → 0.1.1

package/dist/leanbase.iife.js

@@ -1,4 +1,4 @@
-var leanbase = (function () {
+var leanbase = (function (record) {
     'use strict';
 
     const normalizeFlagsResponse = (flagsResponse)=>{
@@ -329,6 +329,7 @@ var leanbase = (function () {
     const isNumber = (x)=>'[object Number]' == type_utils_toString.call(x);
     const isBoolean = (x)=>'[object Boolean]' === type_utils_toString.call(x);
     const isFormData = (x)=>x instanceof FormData;
+    const isFile = (x)=>x instanceof File;
     const isPlainError = (x)=>x instanceof Error;
 
     function clampToRange(value, min, max, logger, fallbackValue) {
@@ -348,6 +349,48 @@ var leanbase = (function () {
         return clampToRange(fallbackValue || max, min, max, logger);
     }
 
+    class BucketedRateLimiter {
+        constructor(_options){
+            this._options = _options;
+            this._buckets = {};
+            this._refillBuckets = ()=>{
+                Object.keys(this._buckets).forEach((key)=>{
+                    const newTokens = this._getBucket(key) + this._refillRate;
+                    if (newTokens >= this._bucketSize) delete this._buckets[key];
+                    else this._setBucket(key, newTokens);
+                });
+            };
+            this._getBucket = (key)=>this._buckets[String(key)];
+            this._setBucket = (key, value)=>{
+                this._buckets[String(key)] = value;
+            };
+            this.consumeRateLimit = (key)=>{
+                let tokens = this._getBucket(key);
+                if (void 0 === tokens) tokens = this._bucketSize;
+                if (tokens <= 0) {
+                    this._onBucketRateLimited?.(key);
+                    return true;
+                }
+                tokens -= 1;
+                this._setBucket(key, tokens);
+                return false;
+            };
+            this._onBucketRateLimited = this._options._onBucketRateLimited;
+            this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
+            this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
+            this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
+            this._removeInterval = setInterval(()=>{
+                this._refillBuckets();
+            }, this._refillInterval);
+        }
+        stop() {
+            if (this._removeInterval) {
+                clearInterval(this._removeInterval);
+                this._removeInterval = void 0;
+            }
+        }
+    }
+
     class PromiseQueue {
         add(promise) {
             const promiseUUID = uuidv7$1();
@@ -465,7 +508,7 @@ var leanbase = (function () {
         };
         return lockedMethods;
     }
-    const _createLogger = (prefix, maybeCall, consoleLike)=>{
+    const _createLogger$1 = (prefix, maybeCall, consoleLike)=>{
         function _log(level, ...args) {
             maybeCall(()=>{
                 const consoleMethod = consoleLike[level];
@@ -485,12 +528,12 @@ var leanbase = (function () {
             critical: (...args)=>{
                 consoleLike['error'](prefix, ...args);
             },
-            createLogger: (additionalPrefix)=>_createLogger(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike)
+            createLogger: (additionalPrefix)=>_createLogger$1(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike)
         };
         return logger;
     };
-    function createLogger(prefix, maybeCall) {
-        return _createLogger(prefix, maybeCall, createConsole());
+    function createLogger$1(prefix, maybeCall) {
+        return _createLogger$1(prefix, maybeCall, createConsole());
     }
 
     class PostHogFetchHttpError extends Error {
@@ -569,7 +612,7 @@ var leanbase = (function () {
             this.evaluationEnvironments = options?.evaluationEnvironments;
             this._initPromise = Promise.resolve();
             this._isInitialized = true;
-            this._logger = createLogger('[PostHog]', this.logMsgIfDebug.bind(this));
+            this._logger = createLogger$1('[PostHog]', this.logMsgIfDebug.bind(this));
             this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
         }
         logMsgIfDebug(fn) {
@@ -1647,7 +1690,7 @@ var leanbase = (function () {
     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;
@@ -1834,10 +1877,13 @@ var leanbase = (function () {
     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';
@@ -1862,7 +1908,7 @@ var leanbase = (function () {
 
     /* eslint-disable no-console */
     const PREFIX = '[Leanbase]';
-    const logger = {
+    const logger$3 = {
       info: (...args) => {
         if (typeof console !== 'undefined') {
           console.log(PREFIX, ...args);
@@ -2160,7 +2206,7 @@ var leanbase = (function () {
         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;
         }
@@ -2172,7 +2218,7 @@ var leanbase = (function () {
     const cookieStore = {
       _is_supported: () => !!document,
       _error: function (msg) {
-        logger.error('cookieStore error: ' + msg);
+        logger$3.error('cookieStore error: ' + msg);
       },
       _get: function (name) {
         if (!document) {
@@ -2221,7 +2267,7 @@ var leanbase = (function () {
           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;
@@ -2263,13 +2309,13 @@ var leanbase = (function () {
           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 {
@@ -2355,7 +2401,7 @@ var leanbase = (function () {
         return true;
       },
       _error: function (msg) {
-        logger.error('memoryStorage error: ' + msg);
+        logger$3.error('memoryStorage error: ' + msg);
       },
       _get: function (name) {
         return memoryStorage[name] || null;
@@ -2396,7 +2442,7 @@ var leanbase = (function () {
         return sessionStorageSupported;
       },
       _error: function (msg) {
-        logger.error('sessionStorage error: ', msg);
+        logger$3.error('sessionStorage error: ', msg);
       },
       _get: function (name) {
         try {
@@ -2430,6 +2476,7 @@ var leanbase = (function () {
       }
     };
 
+    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
@@ -2444,6 +2491,21 @@ var leanbase = (function () {
       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] || '';
@@ -2467,7 +2529,7 @@ var leanbase = (function () {
         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, ' ');
       }
@@ -2506,6 +2568,9 @@ var leanbase = (function () {
       }
       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
@@ -2798,7 +2863,7 @@ var leanbase = (function () {
       }
     };
 
-    var version = "0.0.7";
+    var version = "0.1.1";
     var packageInfo = {
     	version: version};
 
@@ -2948,7 +3013,7 @@ var leanbase = (function () {
     }
     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),
@@ -3016,9 +3081,9 @@ var leanbase = (function () {
         $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(),
@@ -3063,7 +3128,7 @@ var leanbase = (function () {
         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
           });
         }
@@ -3079,7 +3144,7 @@ var leanbase = (function () {
       }
       _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;
@@ -3715,7 +3780,7 @@ var leanbase = (function () {
                 text = `${text} ${getNestedSpanText(child)}`.trim();
               }
             } catch (e) {
-              logger.error('[AutoCapture]', e);
+              logger$3.error('[AutoCapture]', e);
             }
           }
         });
@@ -4017,7 +4082,7 @@ var leanbase = (function () {
       }
       _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) {
@@ -4028,7 +4093,7 @@ var leanbase = (function () {
           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, {
@@ -4213,7 +4278,7 @@ var leanbase = (function () {
         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
         });
@@ -4240,7 +4305,7 @@ var leanbase = (function () {
             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();
@@ -4381,7 +4446,7 @@ var leanbase = (function () {
         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: {
@@ -4510,67 +4575,6 @@ var leanbase = (function () {
       }
     }
 
-    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,
@@ -4631,10 +4635,10 @@ var leanbase = (function () {
             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,
@@ -4797,208 +4801,3348 @@ var leanbase = (function () {
       // 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 fetchFn(url, options);
+      return data;
+    };
+    function estimateBytes(payload) {
+      return new Blob([payload]).size;
+    }
+    function enforcePayloadSizeLimit(payload, headers, limit, description) {
+      if (isNullish(payload)) {
+        return payload;
       }
-      setConfig(config) {
-        const oldConfig = {
-          ...this.config
-        };
-        if (isObject(config)) {
-          extend(this.config, config);
-          this.persistence?.update_config(this.config, oldConfig);
-          this.replayAutocapture?.startIfEnabled();
-        }
-        const isTempStorage = this.config.persistence === 'sessionStorage' || this.config.persistence === 'memory';
-        this.sessionPersistence = isTempStorage ? this.persistence : new LeanbasePersistence({
-          ...this.config,
-          persistence: 'sessionStorage'
-        });
+      let requestContentLength = headers?.['content-length'] || estimateBytes(payload);
+      if (isString(requestContentLength)) {
+        requestContentLength = parseInt(requestContentLength);
       }
-      getLibraryId() {
-        return 'leanbase';
+      if (requestContentLength > limit) {
+        return LOGGER_PREFIX$2 + ` ${description} body too large to record (${requestContentLength} bytes)`;
       }
-      getLibraryVersion() {
-        return Config.LIB_VERSION;
+      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;
       }
-      getCustomUserAgent() {
-        return;
+      let scrubbed = payload;
+      if (!shouldCaptureValue(scrubbed, false)) {
+        scrubbed = LOGGER_PREFIX$2 + ' ' + label + ' body ' + REDACTED;
       }
-      getPersistedProperty(key) {
-        return this.persistence?.get_property(key);
+      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 scrubbed;
+    }
+    function scrubPayloads(capturedRequest) {
+      if (isUndefined(capturedRequest)) {
+        return undefined;
       }
-      setPersistedProperty(key, value) {
-        this.persistence?.set_property(key, value);
+      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
+          };
+        };
       }
-      // Backwards-compatible aliases expected by replay/browser code
-      get_property(key) {
-        return this.persistence?.get_property(key);
+      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
+        });
       }
-      set_property(key, value) {
-        this.persistence?.set_property(key, value);
+      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));
       }
-      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]));
+      /**
+       * 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;
         }
       }
-      unregister_for_session(property) {
-        if (isFunction(this.unregisterForSession)) {
-          this.unregisterForSession(property);
-          return;
-        }
-        if (this.sessionPersistence) {
-          this.sessionPersistence.set_property(property, null);
-        }
+      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;
       }
-      calculateEventProperties(eventName, eventProperties, timestamp, uuid, readOnly) {
-        if (!this.persistence || !this.sessionPersistence) {
-          return eventProperties;
-        }
-        timestamp = timestamp || new Date();
+      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);
+      }
+      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;
+      }
+      const {
+        hostname,
+        isHostDenied
+      } = isHostOnDenyList(url, options);
+      if (isHostDenied) {
+        return hostname + ' is in deny list';
+      }
+      if (isString(body)) {
+        return body;
+      }
+      if (isDocument(body)) {
+        return body.textContent;
+      }
+      if (isFormData(body)) {
+        return formDataToQuery(body);
+      }
+      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.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;
+    }
+
+    // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+    // https://tools.ietf.org/html/rfc1951
+    // You may also wish to take a look at the guide I made about this program:
+    // https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+    // Much of the following code is similar to that of UZIP.js:
+    // https://github.com/photopea/UZIP.js
+    // Many optimizations have been made, so the bundle size is ultimately smaller but performance is similar.
+    // Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+    // is better for memory in most engines (I *think*).
+    // Mediocre shim
+    var Worker;
+    try {
+        Worker = require('worker_threads').Worker;
+    }
+    catch (e) {
+    }
+
+    // aliases for shorter compressed code (most minifers don't do this)
+    var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+    // fixed length extra bits
+    var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+    // fixed distance extra bits
+    // see fleb note
+    var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+    // code length index map
+    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    // get base, reverse index map from extra bits
+    var freb = function (eb, start) {
+        var b = new u16(31);
+        for (var i = 0; i < 31; ++i) {
+            b[i] = start += 1 << eb[i - 1];
+        }
+        // numbers here are at max 18 bits
+        var r = new u32(b[30]);
+        for (var i = 1; i < 30; ++i) {
+            for (var j = b[i]; j < b[i + 1]; ++j) {
+                r[j] = ((j - b[i]) << 5) | i;
+            }
+        }
+        return [b, r];
+    };
+    var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+    // we can ignore the fact that the other numbers are wrong; they never happen anyway
+    fl[28] = 258, revfl[258] = 28;
+    var _b = freb(fdeb, 0), revfd = _b[1];
+    // map of value to reverse (assuming 16 bits)
+    var rev = new u16(32768);
+    for (var i = 0; i < 32768; ++i) {
+        // reverse table algorithm from SO
+        var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+    }
+    // create huffman tree from u8 "map": index -> code length for code index
+    // mb (max bits) must be at most 15
+    // TODO: optimize/split up?
+    var hMap = (function (cd, mb, r) {
+        var s = cd.length;
+        // index
+        var i = 0;
+        // u16 "map": index -> # of codes with bit length = index
+        var l = new u16(mb);
+        // length of cd must be 288 (total # of codes)
+        for (; i < s; ++i)
+            ++l[cd[i] - 1];
+        // u16 "map": index -> minimum code for bit length = index
+        var le = new u16(mb);
+        for (i = 0; i < mb; ++i) {
+            le[i] = (le[i - 1] + l[i - 1]) << 1;
+        }
+        var co;
+        if (r) {
+            // u16 "map": index -> number of actual bits, symbol for code
+            co = new u16(1 << mb);
+            // bits to remove for reverser
+            var rvb = 15 - mb;
+            for (i = 0; i < s; ++i) {
+                // ignore 0 lengths
+                if (cd[i]) {
+                    // num encoding both symbol and bits read
+                    var sv = (i << 4) | cd[i];
+                    // free bits
+                    var r_1 = mb - cd[i];
+                    // start value
+                    var v = le[cd[i] - 1]++ << r_1;
+                    // m is end value
+                    for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                        // every 16 bit value starting with the code yields the same result
+                        co[rev[v] >>> rvb] = sv;
+                    }
+                }
+            }
+        }
+        else {
+            co = new u16(s);
+            for (i = 0; i < s; ++i)
+                co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+        }
+        return co;
+    });
+    // fixed length tree
+    var flt = new u8(288);
+    for (var i = 0; i < 144; ++i)
+        flt[i] = 8;
+    for (var i = 144; i < 256; ++i)
+        flt[i] = 9;
+    for (var i = 256; i < 280; ++i)
+        flt[i] = 7;
+    for (var i = 280; i < 288; ++i)
+        flt[i] = 8;
+    // fixed distance tree
+    var fdt = new u8(32);
+    for (var i = 0; i < 32; ++i)
+        fdt[i] = 5;
+    // fixed length map
+    var flm = /*#__PURE__*/ hMap(flt, 9, 0);
+    // fixed distance map
+    var fdm = /*#__PURE__*/ hMap(fdt, 5, 0);
+    // get end of byte
+    var shft = function (p) { return ((p / 8) >> 0) + (p & 7 && 1); };
+    // typed array slice - allows garbage collector to free original reference,
+    // while being more compatible than .slice
+    var slc = function (v, s, e) {
+        if (e == null || e > v.length)
+            e = v.length;
+        // can't use .constructor in case user-supplied
+        var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    // starting at p, write the minimum number of bits that can hold v to d
+    var wbits = function (d, p, v) {
+        v <<= p & 7;
+        var o = (p / 8) >> 0;
+        d[o] |= v;
+        d[o + 1] |= v >>> 8;
+    };
+    // starting at p, write the minimum number of bits (>8) that can hold v to d
+    var wbits16 = function (d, p, v) {
+        v <<= p & 7;
+        var o = (p / 8) >> 0;
+        d[o] |= v;
+        d[o + 1] |= v >>> 8;
+        d[o + 2] |= v >>> 16;
+    };
+    // creates code lengths from a frequency table
+    var hTree = function (d, mb) {
+        // Need extra info to make a tree
+        var t = [];
+        for (var i = 0; i < d.length; ++i) {
+            if (d[i])
+                t.push({ s: i, f: d[i] });
+        }
+        var s = t.length;
+        var t2 = t.slice();
+        if (!s)
+            return [new u8(0), 0];
+        if (s == 1) {
+            var v = new u8(t[0].s + 1);
+            v[t[0].s] = 1;
+            return [v, 1];
+        }
+        t.sort(function (a, b) { return a.f - b.f; });
+        // after i2 reaches last ind, will be stopped
+        // freq must be greater than largest possible number of symbols
+        t.push({ s: -1, f: 25001 });
+        var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+        t[0] = { s: -1, f: l.f + r.f, l: l, r: r };
+        // efficient algorithm from UZIP.js
+        // i0 is lookbehind, i2 is lookahead - after processing two low-freq
+        // symbols that combined have high freq, will start processing i2 (high-freq,
+        // non-composite) symbols instead
+        // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/
+        while (i1 != s - 1) {
+            l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+            r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+            t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };
+        }
+        var maxSym = t2[0].s;
+        for (var i = 1; i < s; ++i) {
+            if (t2[i].s > maxSym)
+                maxSym = t2[i].s;
+        }
+        // code lengths
+        var tr = new u16(maxSym + 1);
+        // max bits in tree
+        var mbt = ln(t[i1 - 1], tr, 0);
+        if (mbt > mb) {
+            // more algorithms from UZIP.js
+            // TODO: find out how this code works (debt)
+            //  ind    debt
+            var i = 0, dt = 0;
+            //    left            cost
+            var lft = mbt - mb, cst = 1 << lft;
+            t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });
+            for (; i < s; ++i) {
+                var i2_1 = t2[i].s;
+                if (tr[i2_1] > mb) {
+                    dt += cst - (1 << (mbt - tr[i2_1]));
+                    tr[i2_1] = mb;
+                }
+                else
+                    break;
+            }
+            dt >>>= lft;
+            while (dt > 0) {
+                var i2_2 = t2[i].s;
+                if (tr[i2_2] < mb)
+                    dt -= 1 << (mb - tr[i2_2]++ - 1);
+                else
+                    ++i;
+            }
+            for (; i >= 0 && dt; --i) {
+                var i2_3 = t2[i].s;
+                if (tr[i2_3] == mb) {
+                    --tr[i2_3];
+                    ++dt;
+                }
+            }
+            mbt = mb;
+        }
+        return [new u8(tr), mbt];
+    };
+    // get the max length and assign length codes
+    var ln = function (n, l, d) {
+        return n.s == -1
+            ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))
+            : (l[n.s] = d);
+    };
+    // length codes generation
+    var lc = function (c) {
+        var s = c.length;
+        // Note that the semicolon was intentional
+        while (s && !c[--s])
+            ;
+        var cl = new u16(++s);
+        //  ind      num         streak
+        var cli = 0, cln = c[0], cls = 1;
+        var w = function (v) { cl[cli++] = v; };
+        for (var i = 1; i <= s; ++i) {
+            if (c[i] == cln && i != s)
+                ++cls;
+            else {
+                if (!cln && cls > 2) {
+                    for (; cls > 138; cls -= 138)
+                        w(32754);
+                    if (cls > 2) {
+                        w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);
+                        cls = 0;
+                    }
+                }
+                else if (cls > 3) {
+                    w(cln), --cls;
+                    for (; cls > 6; cls -= 6)
+                        w(8304);
+                    if (cls > 2)
+                        w(((cls - 3) << 5) | 8208), cls = 0;
+                }
+                while (cls--)
+                    w(cln);
+                cls = 1;
+                cln = c[i];
+            }
+        }
+        return [cl.subarray(0, cli), s];
+    };
+    // calculate the length of output from tree, code lengths
+    var clen = function (cf, cl) {
+        var l = 0;
+        for (var i = 0; i < cl.length; ++i)
+            l += cf[i] * cl[i];
+        return l;
+    };
+    // writes a fixed block
+    // returns the new bit pos
+    var wfblk = function (out, pos, dat) {
+        // no need to write 00 as type: TypedArray defaults to 0
+        var s = dat.length;
+        var o = shft(pos + 2);
+        out[o] = s & 255;
+        out[o + 1] = s >>> 8;
+        out[o + 2] = out[o] ^ 255;
+        out[o + 3] = out[o + 1] ^ 255;
+        for (var i = 0; i < s; ++i)
+            out[o + i + 4] = dat[i];
+        return (o + 4 + s) * 8;
+    };
+    // writes a block
+    var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+        wbits(out, p++, final);
+        ++lf[256];
+        var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];
+        var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];
+        var _c = lc(dlt), lclt = _c[0], nlc = _c[1];
+        var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];
+        var lcfreq = new u16(19);
+        for (var i = 0; i < lclt.length; ++i)
+            lcfreq[lclt[i] & 31]++;
+        for (var i = 0; i < lcdt.length; ++i)
+            lcfreq[lcdt[i] & 31]++;
+        var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];
+        var nlcc = 19;
+        for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+            ;
+        var flen = (bl + 5) << 3;
+        var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+        var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
+        if (flen <= ftlen && flen <= dtlen)
+            return wfblk(out, p, dat.subarray(bs, bs + bl));
+        var lm, ll, dm, dl;
+        wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+        if (dtlen < ftlen) {
+            lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+            var llm = hMap(lct, mlcb, 0);
+            wbits(out, p, nlc - 257);
+            wbits(out, p + 5, ndc - 1);
+            wbits(out, p + 10, nlcc - 4);
+            p += 14;
+            for (var i = 0; i < nlcc; ++i)
+                wbits(out, p + 3 * i, lct[clim[i]]);
+            p += 3 * nlcc;
+            var lcts = [lclt, lcdt];
+            for (var it = 0; it < 2; ++it) {
+                var clct = lcts[it];
+                for (var i = 0; i < clct.length; ++i) {
+                    var len = clct[i] & 31;
+                    wbits(out, p, llm[len]), p += lct[len];
+                    if (len > 15)
+                        wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;
+                }
+            }
+        }
+        else {
+            lm = flm, ll = flt, dm = fdm, dl = fdt;
+        }
+        for (var i = 0; i < li; ++i) {
+            if (syms[i] > 255) {
+                var len = (syms[i] >>> 18) & 31;
+                wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+                if (len > 7)
+                    wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];
+                var dst = syms[i] & 31;
+                wbits16(out, p, dm[dst]), p += dl[dst];
+                if (dst > 3)
+                    wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];
+            }
+            else {
+                wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
+            }
+        }
+        wbits16(out, p, lm[256]);
+        return p + ll[256];
+    };
+    // deflate options (nice << 13) | chain
+    var deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+    // compresses data into a raw DEFLATE buffer
+    var dflt = function (dat, lvl, plvl, pre, post, lst) {
+        var s = dat.length;
+        var o = new u8(pre + s + 5 * (1 + Math.floor(s / 7000)) + post);
+        // writing to this writes to the output buffer
+        var w = o.subarray(pre, o.length - post);
+        var pos = 0;
+        if (!lvl || s < 8) {
+            for (var i = 0; i <= s; i += 65535) {
+                // end
+                var e = i + 65535;
+                if (e < s) {
+                    // write full block
+                    pos = wfblk(w, pos, dat.subarray(i, e));
+                }
+                else {
+                    // write final block
+                    w[i] = lst;
+                    pos = wfblk(w, pos, dat.subarray(i, s));
+                }
+            }
+        }
+        else {
+            var opt = deo[lvl - 1];
+            var n = opt >>> 13, c = opt & 8191;
+            var msk_1 = (1 << plvl) - 1;
+            //    prev 2-byte val map    curr 2-byte val map
+            var prev = new u16(32768), head = new u16(msk_1 + 1);
+            var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+            var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
+            // 24576 is an arbitrary number of maximum symbols per block
+            // 424 buffer for last block
+            var syms = new u32(25000);
+            // length/literal freq   distance freq
+            var lf = new u16(288), df = new u16(32);
+            //  l/lcnt  exbits  index  l/lind  waitdx  bitpos
+            var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
+            for (; i < s; ++i) {
+                // hash value
+                var hv = hsh(i);
+                // index mod 32768
+                var imod = i & 32767;
+                // previous index with this value
+                var pimod = head[hv];
+                prev[imod] = pimod;
+                head[hv] = imod;
+                // We always should modify head and prev, but only add symbols if
+                // this data is not yet processed ("wait" for wait index)
+                if (wi <= i) {
+                    // bytes remaining
+                    var rem = s - i;
+                    if ((lc_1 > 7000 || li > 24576) && rem > 423) {
+                        pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+                        li = lc_1 = eb = 0, bs = i;
+                        for (var j = 0; j < 286; ++j)
+                            lf[j] = 0;
+                        for (var j = 0; j < 30; ++j)
+                            df[j] = 0;
+                    }
+                    //  len    dist   chain
+                    var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;
+                    if (rem > 2 && hv == hsh(i - dif)) {
+                        var maxn = Math.min(n, rem) - 1;
+                        var maxd = Math.min(32767, i);
+                        // max possible length
+                        // not capped at dif because decompressors implement "rolling" index population
+                        var ml = Math.min(258, rem);
+                        while (dif <= maxd && --ch_1 && imod != pimod) {
+                            if (dat[i + l] == dat[i + l - dif]) {
+                                var nl = 0;
+                                for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                                    ;
+                                if (nl > l) {
+                                    l = nl, d = dif;
+                                    // break out early when we reach "nice" (we are satisfied enough)
+                                    if (nl > maxn)
+                                        break;
+                                    // now, find the rarest 2-byte sequence within this
+                                    // length of literals and search for that instead.
+                                    // Much faster than just using the start
+                                    var mmd = Math.min(dif, nl - 2);
+                                    var md = 0;
+                                    for (var j = 0; j < mmd; ++j) {
+                                        var ti = (i - dif + j + 32768) & 32767;
+                                        var pti = prev[ti];
+                                        var cd = (ti - pti + 32768) & 32767;
+                                        if (cd > md)
+                                            md = cd, pimod = ti;
+                                    }
+                                }
+                            }
+                            // check the previous match
+                            imod = pimod, pimod = prev[imod];
+                            dif += (imod - pimod + 32768) & 32767;
+                        }
+                    }
+                    // d will be nonzero only when a match was found
+                    if (d) {
+                        // store both dist and len data in one Uint32
+                        // Make sure this is recognized as a len/dist with 28th bit (2^28)
+                        syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
+                        var lin = revfl[l] & 31, din = revfd[d] & 31;
+                        eb += fleb[lin] + fdeb[din];
+                        ++lf[257 + lin];
+                        ++df[din];
+                        wi = i + l;
+                        ++lc_1;
+                    }
+                    else {
+                        syms[li++] = dat[i];
+                        ++lf[dat[i]];
+                    }
+                }
+            }
+            pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+        }
+        return slc(o, 0, pre + shft(pos) + post);
+    };
+    // CRC32 table
+    var crct = /*#__PURE__*/ (function () {
+        var t = new u32(256);
+        for (var i = 0; i < 256; ++i) {
+            var c = i, k = 9;
+            while (--k)
+                c = ((c & 1) && 0xEDB88320) ^ (c >>> 1);
+            t[i] = c;
+        }
+        return t;
+    })();
+    // CRC32
+    var crc = function () {
+        var c = 0xFFFFFFFF;
+        return {
+            p: function (d) {
+                // closures have awful performance
+                var cr = c;
+                for (var i = 0; i < d.length; ++i)
+                    cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);
+                c = cr;
+            },
+            d: function () { return c ^ 0xFFFFFFFF; }
+        };
+    };
+    // deflate with opts
+    var dopt = function (dat, opt, pre, post, st) {
+        return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, true);
+    };
+    // write bytes
+    var wbytes = function (d, b, v) {
+        for (; v; ++b)
+            d[b] = v, v >>>= 8;
+    };
+    // gzip header
+    var gzh = function (c, o) {
+        var fn = o.filename;
+        c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix
+        if (o.mtime != 0)
+            wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));
+        if (fn) {
+            c[3] = 8;
+            for (var i = 0; i <= fn.length; ++i)
+                c[i + 10] = fn.charCodeAt(i);
+        }
+    };
+    // gzip header length
+    var gzhl = function (o) { return 10 + ((o.filename && (o.filename.length + 1)) || 0); };
+    /**
+     * Compresses data with GZIP
+     * @param data The data to compress
+     * @param opts The compression options
+     * @returns The gzipped version of the data
+     */
+    function gzipSync(data, opts) {
+        if (opts === void 0) { opts = {}; }
+        var c = crc(), l = data.length;
+        c.p(data);
+        var d = dopt(data, opts, gzhl(opts), 8), s = d.length;
+        return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
+    }
+    /**
+     * Converts a string into a Uint8Array for use with compression/decompression methods
+     * @param str The string to encode
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless decoding a binary string.
+     * @returns The string encoded in UTF-8/Latin-1 binary
+     */
+    function strToU8(str, latin1) {
+        var l = str.length;
+        if (typeof TextEncoder != 'undefined')
+            return new TextEncoder().encode(str);
+        var ar = new u8(str.length + (str.length >>> 1));
+        var ai = 0;
+        var w = function (v) { ar[ai++] = v; };
+        for (var i = 0; i < l; ++i) {
+            if (ai + 5 > ar.length) {
+                var n = new u8(ai + 8 + ((l - i) << 1));
+                n.set(ar);
+                ar = n;
+            }
+            var c = str.charCodeAt(i);
+            if (c < 128 || latin1)
+                w(c);
+            else if (c < 2048)
+                w(192 | (c >>> 6)), w(128 | (c & 63));
+            else if (c > 55295 && c < 57344)
+                c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),
+                    w(240 | (c >>> 18)), w(128 | ((c >>> 12) & 63)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+            else
+                w(224 | (c >>> 12)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+        }
+        return slc(ar, 0, ai);
+    }
+    /**
+     * Converts a Uint8Array to a string
+     * @param dat The data to decode to string
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless encoding to binary string.
+     * @returns The original UTF-8/Latin-1 string
+     */
+    function strFromU8(dat, latin1) {
+        var r = '';
+        for (var i = 0; i < dat.length;) {
+            var c = dat[i++];
+            r += String.fromCharCode(c);
+        }
+        return r;
+    }
+
+    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.record;
+    }
+    function gzipToString(data) {
+      return strFromU8(gzipSync(strToU8(JSON.stringify(data))));
+    }
+    /**
+     * 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);
         let properties = {
           ...eventProperties
@@ -5013,7 +8157,7 @@ var leanbase = (function () {
           };
           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;
         }
@@ -5029,6 +8173,13 @@ var leanbase = (function () {
         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);
@@ -5081,11 +8232,11 @@ var leanbase = (function () {
           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();
@@ -5221,5 +8372,5 @@ var leanbase = (function () {
 
     return api;
 
-})();
+})(record);
 //# sourceMappingURL=leanbase.iife.js.map