@leanbase-giangnd/js 0.3.2 → 0.4.0

package/dist/index.cjs

@@ -231,7 +231,7 @@ core.PostHogPersistedProperty.Queue, core.PostHogPersistedProperty.FeatureFlagDe
 
 /* eslint-disable no-console */
 const PREFIX = '[Leanbase]';
-const logger$2 = {
+const logger$3 = {
   info: (...args) => {
     if (typeof console !== 'undefined') {
       console.log(PREFIX, ...args);
@@ -529,7 +529,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
     if (!matchedSubDomain) {
       const originalMatch = originalCookieDomainFn(hostname);
       if (originalMatch !== matchedSubDomain) {
-        logger$2.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
+        logger$3.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain);
       }
       matchedSubDomain = originalMatch;
     }
@@ -541,7 +541,7 @@ function chooseCookieDomain(hostname, cross_subdomain) {
 const cookieStore = {
   _is_supported: () => !!document,
   _error: function (msg) {
-    logger$2.error('cookieStore error: ' + msg);
+    logger$3.error('cookieStore error: ' + msg);
   },
   _get: function (name) {
     if (!document) {
@@ -590,7 +590,7 @@ const cookieStore = {
       const new_cookie_val = name + '=' + encodeURIComponent(JSON.stringify(value)) + expires + '; SameSite=Lax; path=/' + cdomain + secure;
       // 4096 bytes is the size at which some browsers (e.g. firefox) will not store a cookie, warn slightly before that
       if (new_cookie_val.length > 4096 * 0.9) {
-        logger$2.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;
@@ -632,13 +632,13 @@ const localStore = {
       supported = false;
     }
     if (!supported) {
-      logger$2.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$2.error('localStorage error: ' + msg);
+    logger$3.error('localStorage error: ' + msg);
   },
   _get: function (name) {
     try {
@@ -724,7 +724,7 @@ const memoryStore = {
     return true;
   },
   _error: function (msg) {
-    logger$2.error('memoryStorage error: ' + msg);
+    logger$3.error('memoryStorage error: ' + msg);
   },
   _get: function (name) {
     return memoryStorage[name] || null;
@@ -765,7 +765,7 @@ const sessionStore = {
     return sessionStorageSupported;
   },
   _error: function (msg) {
-    logger$2.error('sessionStorage error: ', msg);
+    logger$3.error('sessionStorage error: ', msg);
   },
   _get: function (name) {
     try {
@@ -814,6 +814,21 @@ const convertToURL = url => {
   location.href = url;
   return location;
 };
+const formDataToQuery = function (formdata, arg_separator = '&') {
+  let use_val;
+  let use_key;
+  const tph_arr = [];
+  each(formdata, function (val, key) {
+    // the key might be literally the string undefined for e.g. if {undefined: 'something'}
+    if (core.isUndefined(val) || core.isUndefined(key) || key === 'undefined') {
+      return;
+    }
+    use_val = encodeURIComponent(core.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] || '';
@@ -837,7 +852,7 @@ const getQueryParam = function (url, param) {
     try {
       result = decodeURIComponent(result);
     } catch {
-      logger$2.error('Skipping decoding for malformed query param: ' + result);
+      logger$3.error('Skipping decoding for malformed query param: ' + result);
     }
     return result.replace(/\+/g, ' ');
   }
@@ -1171,7 +1186,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.3.2";
+var version = "0.4.0";
 var packageInfo = {
 	version: version};
 
@@ -1436,7 +1451,7 @@ class LeanbasePersistence {
     this._storage = this._buildStorage(config);
     this.load();
     if (config.debug) {
-      logger$2.info('Persistence loaded', config['persistence'], {
+      logger$3.info('Persistence loaded', config['persistence'], {
         ...this.props
       });
     }
@@ -1452,7 +1467,7 @@ class LeanbasePersistence {
   }
   _buildStorage(config) {
     if (CASE_INSENSITIVE_PERSISTENCE_TYPES.indexOf(config['persistence'].toLowerCase()) === -1) {
-      logger$2.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;
@@ -2088,7 +2103,7 @@ function getNestedSpanText(target) {
             text = `${text} ${getNestedSpanText(child)}`.trim();
           }
         } catch (e) {
-          logger$2.error('[AutoCapture]', e);
+          logger$3.error('[AutoCapture]', e);
         }
       }
     });
@@ -2390,7 +2405,7 @@ class Autocapture {
   }
   _addDomEventHandlers() {
     if (!this.isBrowserSupported()) {
-      logger$2.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) {
@@ -2401,7 +2416,7 @@ class Autocapture {
       try {
         this._captureEvent(e);
       } catch (error) {
-        logger$2.error('Failed to capture event', error);
+        logger$3.error('Failed to capture event', error);
       }
     };
     addEventListener(document, 'submit', handler, {
@@ -2586,7 +2601,7 @@ class SessionIdManager {
     this._windowIdGenerator = windowIdGenerator || uuidv7;
     const persistenceName = this._config['persistence_name'] || this._config['token'];
     const desiredTimeout = this._config['session_idle_timeout_seconds'] || DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS;
-    this._sessionTimeoutMs = core.clampToRange(desiredTimeout, MIN_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, logger$2, DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS) * 1000;
+    this._sessionTimeoutMs = core.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
     });
@@ -2613,7 +2628,7 @@ class SessionIdManager {
         const sessionStartTimestamp = uuid7ToTimestampMs(this._config.bootstrap.sessionID);
         this._setSessionId(this._config.bootstrap.sessionID, new Date().getTime(), sessionStartTimestamp);
       } catch (e) {
-        logger$2.error('Invalid sessionID in bootstrap', e);
+        logger$3.error('Invalid sessionID in bootstrap', e);
       }
     }
     this._listenToReloadWindow();
@@ -2754,7 +2769,7 @@ class SessionIdManager {
     if (noSessionId || activityTimeout || sessionPastMaximumLength) {
       sessionId = this._sessionIdGenerator();
       windowId = this._windowIdGenerator();
-      logger$2.info('new session ID generated', {
+      logger$3.info('new session ID generated', {
         sessionId,
         windowId,
         changeReason: {
@@ -2943,10 +2958,10 @@ class PageViewManager {
         lastContentY = Math.ceil(lastContentY);
         maxContentY = Math.ceil(maxContentY);
         // if the maximum scroll height is near 0, then the percentage is 1
-        const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger$2);
-        const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger$2);
-        const lastContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(lastContentY / maxContentHeight, 0, 1, logger$2);
-        const maxContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(maxContentY / maxContentHeight, 0, 1, logger$2);
+        const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(lastScrollY / maxScrollHeight, 0, 1, logger$3);
+        const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : core.clampToRange(maxScrollY / maxScrollHeight, 0, 1, logger$3);
+        const lastContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(lastContentY / maxContentHeight, 0, 1, logger$3);
+        const maxContentPercentage = maxContentHeight <= 1 ? 1 : core.clampToRange(maxContentY / maxContentHeight, 0, 1, logger$3);
         properties = extend(properties, {
           $prev_pageview_last_scroll: lastScrollY,
           $prev_pageview_last_scroll_percentage: lastScrollPercentage,
@@ -3211,17 +3226,17 @@ var CanvasContext;
 
 const _createLogger = prefix => {
   return {
-    info: (...args) => logger$2.info(prefix, ...args),
-    warn: (...args) => logger$2.warn(prefix, ...args),
-    error: (...args) => logger$2.error(prefix, ...args),
-    critical: (...args) => logger$2.critical(prefix, ...args),
+    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$2.error(prefix, `You must initialize Leanbase before calling ${methodName}`);
+      logger$3.error(prefix, `You must initialize Leanbase before calling ${methodName}`);
     },
     createLogger: additionalPrefix => _createLogger(`${prefix} ${additionalPrefix}`)
   };
 };
-const logger$1 = _createLogger('[Leanbase]');
+const logger$2 = _createLogger('[Leanbase]');
 const createLogger = _createLogger;
 
 const LOGGER_PREFIX$2 = '[SessionRecording]';
@@ -3295,7 +3310,7 @@ function enforcePayloadSizeLimit(payload, headers, limit, description) {
 // 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);
+  const limit = Math.min(1000000, options.payloadSizeLimitBytes ?? 1000000);
   return data => {
     if (data?.requestBody) {
       data.requestBody = enforcePayloadSizeLimit(data.requestBody, data.requestHeaders, limit, 'Request');
@@ -3353,7 +3368,7 @@ const buildNetworkRequestOptions = (instanceConfig, remoteNetworkOptions = {}) =
   const enforcedCleaningFn = d => payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.host || ''));
   const hasDeprecatedMaskFunction = core.isFunction(sessionRecordingConfig.maskNetworkRequestFn);
   if (hasDeprecatedMaskFunction && core.isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)) {
-    logger$1.warn('Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.');
+    logger$2.warn('Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.');
   }
   if (hasDeprecatedMaskFunction) {
     sessionRecordingConfig.maskCapturedNetworkRequestFn = data => {
@@ -3800,7 +3815,7 @@ class MutationThrottler {
       refillInterval: 1000,
       // one second
       _onBucketRateLimited: this._onNodeRateLimited,
-      _logger: logger$1
+      _logger: logger$2
     });
   }
   reset() {
@@ -3824,7 +3839,7 @@ function simpleHash(str) {
  * receives percent as a number between 0 and 1
  */
 function sampleOnProperty(prop, percent) {
-  return simpleHash(prop) % 100 < core.clampToRange(percent * 100, 0, 100, logger$1);
+  return simpleHash(prop) % 100 < core.clampToRange(percent * 100, 0, 100, logger$2);
 }
 
 /* eslint-disable posthog-js/no-direct-function-check */
@@ -3855,7 +3870,7 @@ const RECORDING_MAX_EVENT_SIZE = ONE_KB * ONE_KB * 0.9; // ~1mb (with some wiggl
 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 logger$1 = 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,
@@ -3904,7 +3919,7 @@ async function loadRRWeb() {
       return rr;
     }
   } catch (e) {
-    logger.error('could not dynamically load rrweb', e);
+    logger$1.error('could not dynamically load rrweb', e);
   }
   return null;
 }
@@ -3951,7 +3966,7 @@ function compressEvent(event) {
       };
     }
   } catch (e) {
-    logger.error('could not compress event - will use uncompressed event', e);
+    logger$1.error('could not compress event - will use uncompressed event', e);
   }
   return event;
 }
@@ -3988,6 +4003,11 @@ function splitBuffer(buffer, sizeLimit = SEVEN_MEGABYTES) {
   }
 }
 class LazyLoadedSessionRecording {
+  _debug(...args) {
+    if (this._instance?.config?.debug) {
+      logger$1.info(...args);
+    }
+  }
   get sessionId() {
     return this._sessionId;
   }
@@ -4002,9 +4022,9 @@ class LazyLoadedSessionRecording {
     if (!this._loggedPermanentlyDisabled) {
       this._loggedPermanentlyDisabled = true;
       if (error) {
-        logger.error(`replay disabled: ${reason}`, error);
+        logger$1.error(`replay disabled: ${reason}`, error);
       } else {
-        logger.error(`replay disabled: ${reason}`);
+        logger$1.error(`replay disabled: ${reason}`);
       }
     }
   }
@@ -4104,7 +4124,7 @@ class LazyLoadedSessionRecording {
     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`);
+      logger$1.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() {
@@ -4178,25 +4198,62 @@ class LazyLoadedSessionRecording {
       payloadHostDenyList: networkPayloadCapture_server_side?.payloadHostDenyList
     };
   }
-  _gatherRRWebPlugins() {
+  async _loadConsolePlugin() {
+    try {
+      const mod = await import('@rrweb/rrweb-plugin-console-record');
+      const factory = mod?.getRecordConsolePlugin ?? mod?.default?.getRecordConsolePlugin;
+      if (typeof factory === 'function') {
+        const plugin = factory();
+        this._debug('Console plugin loaded');
+        return plugin;
+      }
+      logger$1.warn('console plugin factory unavailable after import');
+    } catch (e) {
+      logger$1.warn('could not load console plugin', e);
+    }
+    return null;
+  }
+  async _loadNetworkPlugin(networkPayloadCapture) {
+    try {
+      const mod = await Promise.resolve().then(function () { return networkPlugin; });
+      const factory = mod?.getRecordNetworkPlugin ?? mod?.default?.getRecordNetworkPlugin;
+      if (typeof factory === 'function') {
+        const options = buildNetworkRequestOptions(this._instance.config, networkPayloadCapture);
+        const plugin = factory(options);
+        this._debug('Network plugin loaded');
+        return plugin;
+      }
+      logger$1.warn('network plugin factory unavailable after import');
+    } catch (e) {
+      logger$1.warn('could not load network plugin', e);
+    }
+    return null;
+  }
+  async _gatherRRWebPlugins() {
     const plugins = [];
+    if (!win) {
+      return plugins;
+    }
     if (this._isConsoleLogCaptureEnabled) {
-      logger.info('Console log capture requested but console plugin is not bundled in this build yet.');
+      const consolePlugin = await this._loadConsolePlugin();
+      if (consolePlugin) {
+        plugins.push(consolePlugin);
+      }
     }
     if (this._networkPayloadCapture) {
       const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture;
       if (canRecordNetwork) {
-        const assignableWindow = globalThis;
-        const networkFactory = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordNetworkPlugin?.();
-        if (typeof networkFactory === 'function') {
-          plugins.push(networkFactory(buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture)));
-        } else {
-          logger.info('Network plugin factory not available yet; skipping network plugin');
+        const networkPlugin = await this._loadNetworkPlugin(this._networkPayloadCapture);
+        if (networkPlugin) {
+          plugins.push(networkPlugin);
         }
       } else {
-        logger.info('NetworkCapture not started because we are on localhost.');
+        this._debug('NetworkCapture not started because we are on localhost.');
       }
     }
+    if (plugins.length > 0) {
+      this._debug('Replay plugins loaded', plugins.map(p => p.name));
+    }
     return plugins;
   }
   _maskUrl(url) {
@@ -4225,7 +4282,7 @@ class LazyLoadedSessionRecording {
           rrwebMethod: queuedRRWebEvent.rrwebMethod
         });
       } else {
-        logger.warn('could not emit queued rrweb event.', e, queuedRRWebEvent);
+        logger$1.warn('could not emit queued rrweb event.', e, queuedRRWebEvent);
       }
       return false;
     }
@@ -4337,7 +4394,7 @@ class LazyLoadedSessionRecording {
     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');
+    logger$1.info('recording paused due to URL blocker');
     this._tryAddCustomEvent('recording paused', {
       reason: 'url blocker'
     });
@@ -4356,7 +4413,7 @@ class LazyLoadedSessionRecording {
     this._tryAddCustomEvent('recording resumed', {
       reason: 'left blocked url'
     });
-    logger.info('recording resumed');
+    logger$1.info('recording resumed');
   }
   _activateTrigger(triggerType) {
     if (!this.isStarted || !this._recording || !this._isFullyReady) {
@@ -4389,7 +4446,7 @@ class LazyLoadedSessionRecording {
     this._isFullyReady = false;
     const config = this._remoteConfig;
     if (!config) {
-      logger.info('remote config must be stored in persistence before recording can start');
+      logger$1.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
@@ -4472,7 +4529,7 @@ class LazyLoadedSessionRecording {
             });
           }
         } catch (e) {
-          logger.error('Could not add $pageview to rrweb session', e);
+          logger$1.error('Could not add $pageview to rrweb session', e);
         }
       });
     }
@@ -4517,17 +4574,30 @@ class LazyLoadedSessionRecording {
     this._stopRrweb = undefined;
     this._isFullyReady = false;
     this._hasReportedRecordingInitialized = false;
-    logger.info('stopped');
+    logger$1.info('stopped');
   }
   _snapshotIngestionUrl() {
     const endpointFor = this._instance?.requestRouter?.endpointFor;
-    if (typeof endpointFor !== 'function') {
+    // Prefer requestRouter (parity with Browser SDK)
+    if (typeof endpointFor === 'function') {
+      try {
+        return endpointFor('api', this._endpoint);
+      } catch {
+        return null;
+      }
+    }
+    // Fallback: construct from host/api_host if requestRouter is unavailable (older IIFE builds)
+    const host = (this._instance.config.api_host || this._instance.config.host || '').trim();
+    if (!host) {
       return null;
     }
     try {
-      return endpointFor('api', this._endpoint);
+      // eslint-disable-next-line compat/compat
+      return new URL(this._endpoint, host).href;
     } catch {
-      return null;
+      const normalizedHost = host.endsWith('/') ? host.slice(0, -1) : host;
+      const normalizedEndpoint = this._endpoint.startsWith('/') ? this._endpoint : `/${this._endpoint}`;
+      return `${normalizedHost}${normalizedEndpoint}`;
     }
   }
   _canCaptureSnapshots() {
@@ -4612,7 +4682,7 @@ class LazyLoadedSessionRecording {
       }
       this._captureSnapshotBuffered(properties);
     } catch (e) {
-      logger.error('error processing rrweb event', e);
+      logger$1.error('error processing rrweb event', e);
     }
   }
   get status() {
@@ -4703,7 +4773,7 @@ class LazyLoadedSessionRecording {
     if (!this._canCaptureSnapshots()) {
       if (!this._loggedMissingEndpointFor) {
         this._loggedMissingEndpointFor = true;
-        logger.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
+        logger$1.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
       }
       this._flushBufferTimer = setTimeout(() => {
         this._flushBuffer();
@@ -4746,7 +4816,7 @@ class LazyLoadedSessionRecording {
     if (!url) {
       if (!this._loggedMissingEndpointFor) {
         this._loggedMissingEndpointFor = true;
-        logger.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
+        logger$1.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
       }
       return;
     }
@@ -4759,7 +4829,7 @@ class LazyLoadedSessionRecording {
         skip_client_rate_limiting: true
       });
     } catch (e) {
-      logger.error('failed to capture snapshot', e);
+      logger$1.error('failed to capture snapshot', e);
     }
   }
   _snapshotUrl() {
@@ -4818,9 +4888,9 @@ class LazyLoadedSessionRecording {
     });
     const message = startReason.replace('_', ' ');
     if (typeof tagPayload === 'undefined') {
-      logger.info(message);
+      logger$1.info(message);
     } else {
-      logger.info(message, tagPayload);
+      logger$1.info(message, tagPayload);
     }
     if (!core.includes(['recording_initialized', 'session_id_changed'], startReason)) {
       this._tryAddCustomEvent(startReason, tagPayload);
@@ -4921,7 +4991,7 @@ class LazyLoadedSessionRecording {
       if (shouldSample) {
         this._reportStarted(SAMPLED);
       } else {
-        logger.warn(`Sample rate (${currentSampleRate}) has determined that this sessionId (${sessionId}) will not be sent to the server.`);
+        logger$1.warn(`Sample rate (${currentSampleRate}) has determined that this sessionId (${sessionId}) will not be sent to the server.`);
       }
       this._tryAddCustomEvent('samplingDecisionMade', {
         sampleRate: currentSampleRate,
@@ -4944,7 +5014,7 @@ class LazyLoadedSessionRecording {
           this._activateTrigger('event');
         }
       } catch (e) {
-        logger.error('Could not activate event trigger', e);
+        logger$1.error('Could not activate event trigger', e);
       }
     });
   }
@@ -5026,7 +5096,7 @@ class LazyLoadedSessionRecording {
       this._disablePermanently('rrweb record function unavailable');
       return;
     }
-    const activePlugins = this._gatherRRWebPlugins();
+    const activePlugins = await this._gatherRRWebPlugins();
     let stopHandler;
     try {
       stopHandler = rrwebRecord({
@@ -5035,7 +5105,7 @@ class LazyLoadedSessionRecording {
             this.onRRwebEmit(event);
           } catch (e) {
             // never throw from rrweb emit handler
-            logger.error('error in rrweb emit handler', e);
+            logger$1.error('error in rrweb emit handler', e);
           }
         },
         plugins: activePlugins,
@@ -5060,7 +5130,7 @@ class LazyLoadedSessionRecording {
       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, {
+        logger$1.info(message, {
           node: node
         });
         this.log(LOGGER_PREFIX$1 + ' ' + message, 'warn');
@@ -5087,11 +5157,16 @@ class LazyLoadedSessionRecording {
 /* eslint-disable posthog-js/no-direct-function-check */
 const LOGGER_PREFIX = '[SessionRecording]';
 const log = {
-  info: (...args) => logger$2.info(LOGGER_PREFIX, ...args),
-  warn: (...args) => logger$2.warn(LOGGER_PREFIX, ...args),
-  error: (...args) => logger$2.error(LOGGER_PREFIX, ...args)
+  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 {
+  _debug(...args) {
+    if (this._instance?.config?.debug) {
+      log.info(...args);
+    }
+  }
   get started() {
     return !!this._lazyLoadedSessionRecording?.isStarted;
   }
@@ -5129,8 +5204,10 @@ class SessionRecording {
     }
     const canRunReplay = !core.isUndefined(Object.assign) && !core.isUndefined(Array.from);
     if (this._isRecordingEnabled && canRunReplay) {
+      this._debug('Session replay enabled; starting recorder');
       this._lazyLoadAndStart(startReason);
     } else {
+      this._debug('Session replay disabled; stopping recorder');
       this.stopRecording();
     }
   }
@@ -5202,18 +5279,15 @@ class SessionRecording {
       log.info('skipping remote config with no sessionRecording', response);
       return;
     }
-    this._receivedFlags = true;
-    if (response.sessionRecording === false) {
-      return;
-    }
     this._persistRemoteConfig(response);
+    this._receivedFlags = true;
     this.startIfEnabledOrStop();
   }
   log(message, level = 'log') {
     if (this._lazyLoadedSessionRecording?.log) {
       this._lazyLoadedSessionRecording.log(message, level);
     } else {
-      logger$2.warn('log called before recorder was ready');
+      logger$3.warn('log called before recorder was ready');
     }
   }
   get _scriptName() {
@@ -5236,10 +5310,10 @@ class SessionRecording {
         try {
           const maybePromise = this._lazyLoadedSessionRecording.start(startReason);
           if (maybePromise && typeof maybePromise.catch === 'function') {
-            maybePromise.catch(e => logger$2.error('error starting session recording', e));
+            maybePromise.catch(e => logger$3.error('error starting session recording', e));
           }
         } catch (e) {
-          logger$2.error('error starting session recording', e);
+          logger$3.error('error starting session recording', e);
         }
         return;
       }
@@ -5252,10 +5326,10 @@ class SessionRecording {
     try {
       const maybePromise = this._lazyLoadedSessionRecording.start(startReason);
       if (maybePromise && typeof maybePromise.catch === 'function') {
-        maybePromise.catch(e => logger$2.error('error starting session recording', e));
+        maybePromise.catch(e => logger$3.error('error starting session recording', e));
       }
     } catch (e) {
-      logger$2.error('error starting session recording', e);
+      logger$3.error('error starting session recording', e);
     }
   }
   /**
@@ -5412,12 +5486,12 @@ class Leanbase extends core.PostHogCore {
       }, 1);
     }
     const triggerRemoteConfigLoad = reason => {
-      logger$2.info(`remote config load triggered via ${reason}`);
+      logger$3.info(`remote config load triggered via ${reason}`);
       void this.loadRemoteConfig();
     };
     if (document) {
       if (document.readyState === 'loading') {
-        logger$2.info('remote config load deferred until DOMContentLoaded');
+        logger$3.info('remote config load deferred until DOMContentLoaded');
         const onDomReady = () => {
           document?.removeEventListener('DOMContentLoaded', onDomReady);
           triggerRemoteConfigLoad('dom');
@@ -5510,7 +5584,7 @@ class Leanbase extends core.PostHogCore {
     try {
       this.sessionRecording.startIfEnabledOrStop();
     } catch (e) {
-      logger$2.error('Failed to start session recording', e);
+      logger$3.error('Failed to start session recording', e);
     }
   }
   fetch(url, options) {
@@ -5576,7 +5650,7 @@ class Leanbase extends core.PostHogCore {
       };
       properties['distinct_id'] = persistenceProps.distinct_id;
       if (!(core.isString(properties['distinct_id']) || core.isNumber(properties['distinct_id'])) || core.isEmptyString(properties['distinct_id'])) {
-        logger$2.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;
     }
@@ -5651,11 +5725,11 @@ class Leanbase extends core.PostHogCore {
       return;
     }
     if (core.isUndefined(event) || !core.isString(event)) {
-      logger$2.error('No event name provided to posthog.capture');
+      logger$3.error('No event name provided to posthog.capture');
       return;
     }
     if (properties?.$current_url && !core.isString(properties?.$current_url)) {
-      logger$2.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();
@@ -5707,5 +5781,634 @@ class Leanbase extends core.PostHogCore {
   }
 }
 
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {
+        //
+      };
+    }
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (core.isFunction(wrapped)) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      wrapped.prototype = wrapped.prototype || {};
+      Object.defineProperties(wrapped, {
+        __posthog_wrapped__: {
+          enumerable: false,
+          value: true
+        }
+      });
+    }
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch {
+    return () => {
+      //
+    };
+  }
+}
+
+function hostnameFromURL(url) {
+  try {
+    if (typeof url === 'string') {
+      return new URL(url).hostname;
+    }
+    if ('url' in url) {
+      return new URL(url.url).hostname;
+    }
+    return url.hostname;
+  } catch {
+    return null;
+  }
+}
+function isHostOnDenyList(url, options) {
+  const hostname = hostnameFromURL(url);
+  const defaultNotDenied = {
+    hostname,
+    isHostDenied: false
+  };
+  if (!options.payloadHostDenyList?.length || !hostname?.trim().length) {
+    return defaultNotDenied;
+  }
+  for (const deny of options.payloadHostDenyList) {
+    if (hostname.endsWith(deny)) {
+      return {
+        hostname,
+        isHostDenied: true
+      };
+    }
+  }
+  return defaultNotDenied;
+}
+
+/// <reference lib="dom" />
+const logger = 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
+    });
+  }
+  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 && (core.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));
+  }
+  /**
+   * 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;
+    }
+  }
+  if (!recordBody) return false;
+  if (isBlobURL(url)) return false;
+  if (core.isBoolean(recordBody)) return true;
+  if (core.isArray(recordBody)) return matchesContentType(recordBody);
+  const recordBodyType = recordBody[type];
+  if (core.isBoolean(recordBodyType)) return recordBodyType;
+  return matchesContentType(recordBodyType);
+}
+async function getRequestPerformanceEntry(win, initiatorType, url, start, end, attempt = 0) {
+  if (attempt > 10) {
+    logger.warn('Failed to get performance entry for request', {
+      url,
+      initiatorType
+    });
+    return null;
+  }
+  const urlPerformanceEntries = win.performance.getEntriesByName(url);
+  const performanceEntry = findLast(urlPerformanceEntries, entry => isResourceTiming(entry) && entry.initiatorType === initiatorType && (core.isUndefined(start) || entry.startTime >= start) && (core.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 (core.isNullish(body)) {
+    return null;
+  }
+  const {
+    hostname,
+    isHostDenied
+  } = isHostOnDenyList(url, options);
+  if (isHostDenied) {
+    return hostname + ' is in deny list';
+  }
+  if (core.isString(body)) {
+    return body;
+  }
+  if (isDocument(body)) {
+    return body.textContent;
+  }
+  if (core.isFormData(body)) {
+    return formDataToQuery(body);
+  }
+  if (core.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 => !core.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: core.isUndefined(start) ? undefined : Math.round(start),
+    endTime: core.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 (!core.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.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
+
+var networkPlugin = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    NETWORK_PLUGIN_NAME: NETWORK_PLUGIN_NAME,
+    findLast: findLast,
+    getRecordNetworkPlugin: getRecordNetworkPlugin,
+    shouldRecordBody: shouldRecordBody
+});
+
 exports.Leanbase = Leanbase;
 //# sourceMappingURL=index.cjs.map