mixpanel-browser 2.75.0 → 2.77.0

package/dist/mixpanel.module.js

@@ -23,16 +23,19 @@ if (typeof(window) === 'undefined') {
     win = window;
 }
 
-/**
- * Shared global window property names used across modules
- */
+var Config = {
+    DEBUG: false,
+    LIB_VERSION: '2.77.0'
+};
 
-// Targeting library global (used by flags and targeting modules)
+// Window global names for async modules
 var TARGETING_GLOBAL_NAME = '__mp_targeting';
-
-// Recorder library global (used by recorder and mixpanel-core)
 var RECORDER_GLOBAL_NAME = '__mp_recorder';
 
+// Constants that are injected at build-time for the names of async modules.
+var RECORDER_FILENAME = '__MP_RECORDER_FILENAME__';
+var TARGETING_FILENAME = '__MP_TARGETING_FILENAME__';
+
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -10730,13 +10733,7 @@ var MutationBuffer = /*#__PURE__*/ function() {
             };
             while(_this.mapRemoves.length){
                 var removedNode = _this.mapRemoves.shift();
-                if (removedNode.nodeName === "IFRAME") {
-                    try {
-                        _this.iframeManager.removeIframe(removedNode);
-                    } catch (e2) {}
-                } else {
-                    _this.stylesheetManager.cleanupStylesheetsForRemovedNode(removedNode);
-                }
+                _this.cleanupRemovedNode(removedNode);
                 _this.mirror.removeNodeFromMap(removedNode);
             }
             for(var _iterator = _create_for_of_iterator_helper_loose(_this.movedSet), _step; !(_step = _iterator()).done;){
@@ -11056,6 +11053,20 @@ var MutationBuffer = /*#__PURE__*/ function() {
                 }
             }
         });
+        __publicField$1(this, "cleanupRemovedNode", function(node2) {
+            if (node2.nodeName === "IFRAME") {
+                try {
+                    _this.iframeManager.removeIframe(node2);
+                } catch (e2) {}
+            } else {
+                try {
+                    _this.stylesheetManager.cleanupStylesheetsForRemovedNode(node2);
+                } catch (e2) {}
+            }
+            node2.childNodes.forEach(function(child) {
+                _this.cleanupRemovedNode(child);
+            });
+        });
     }
     var _proto = MutationBuffer.prototype;
     _proto.init = function init(options) {
@@ -13283,6 +13294,31 @@ var ProcessedNodeManager = /*#__PURE__*/ function() {
     _proto.destroy = function destroy() {};
     return ProcessedNodeManager;
 }();
+function toOrigin(url) {
+    try {
+        var origin = new URL(url).origin;
+        return origin !== "null" ? origin : null;
+    } catch (e) {
+        return null;
+    }
+}
+function buildAllowedOriginSet(origins) {
+    if (!Array.isArray(origins) || origins.length === 0) {
+        throw new Error("[rrweb] allowedIframeOrigins must be a non-empty array of origin strings.");
+    }
+    var set = /* @__PURE__ */ new Set();
+    for(var i2 = 0; i2 < origins.length; i2++){
+        var entry = origins[i2];
+        if (typeof entry !== "string") {
+            throw new Error("[rrweb] allowedIframeOrigins[" + i2 + "] must be a string, got " + (typeof entry === "undefined" ? "undefined" : _type_of(entry)) + ".");
+        }
+        var origin = toOrigin(entry);
+        if (origin) {
+            set.add(origin);
+        }
+    }
+    return Object.freeze(set);
+}
 var wrappedEmit;
 var takeFullSnapshot$1;
 var canvasManager;
@@ -13304,10 +13340,17 @@ try {
 var mirror = createMirror$2();
 function record(options) {
     if (options === void 0) options = {};
-    var emit = options.emit, checkoutEveryNms = options.checkoutEveryNms, checkoutEveryNth = options.checkoutEveryNth, _options_blockClass = options.blockClass, blockClass = _options_blockClass === void 0 ? "rr-block" : _options_blockClass, _options_blockSelector = options.blockSelector, blockSelector = _options_blockSelector === void 0 ? null : _options_blockSelector, _options_ignoreClass = options.ignoreClass, ignoreClass = _options_ignoreClass === void 0 ? "rr-ignore" : _options_ignoreClass, _options_ignoreSelector = options.ignoreSelector, ignoreSelector = _options_ignoreSelector === void 0 ? null : _options_ignoreSelector, _options_maskTextClass = options.maskTextClass, maskTextClass = _options_maskTextClass === void 0 ? "rr-mask" : _options_maskTextClass, _options_maskTextSelector = options.maskTextSelector, maskTextSelector = _options_maskTextSelector === void 0 ? null : _options_maskTextSelector, _options_inlineStylesheet = options.inlineStylesheet, inlineStylesheet = _options_inlineStylesheet === void 0 ? true : _options_inlineStylesheet, maskAllInputs = options.maskAllInputs, _maskInputOptions = options.maskInputOptions, _slimDOMOptions = options.slimDOMOptions, maskInputFn = options.maskInputFn, maskTextFn = options.maskTextFn, hooks = options.hooks, packFn = options.packFn, _options_sampling = options.sampling, sampling = _options_sampling === void 0 ? {} : _options_sampling, _options_dataURLOptions = options.dataURLOptions, dataURLOptions = _options_dataURLOptions === void 0 ? {} : _options_dataURLOptions, mousemoveWait = options.mousemoveWait, _options_recordDOM = options.recordDOM, recordDOM = _options_recordDOM === void 0 ? true : _options_recordDOM, _options_recordCanvas = options.recordCanvas, recordCanvas = _options_recordCanvas === void 0 ? false : _options_recordCanvas, _options_recordCrossOriginIframes = options.recordCrossOriginIframes, recordCrossOriginIframes = _options_recordCrossOriginIframes === void 0 ? false : _options_recordCrossOriginIframes, _options_recordAfter = options.recordAfter, recordAfter = _options_recordAfter === void 0 ? options.recordAfter === "DOMContentLoaded" ? options.recordAfter : "load" : _options_recordAfter, _options_userTriggeredOnInput = options.userTriggeredOnInput, userTriggeredOnInput = _options_userTriggeredOnInput === void 0 ? false : _options_userTriggeredOnInput, _options_collectFonts = options.collectFonts, collectFonts = _options_collectFonts === void 0 ? false : _options_collectFonts, _options_inlineImages = options.inlineImages, inlineImages = _options_inlineImages === void 0 ? false : _options_inlineImages, plugins = options.plugins, _options_keepIframeSrcFn = options.keepIframeSrcFn, keepIframeSrcFn = _options_keepIframeSrcFn === void 0 ? function() {
+    var emit = options.emit, checkoutEveryNms = options.checkoutEveryNms, checkoutEveryNth = options.checkoutEveryNth, _options_blockClass = options.blockClass, blockClass = _options_blockClass === void 0 ? "rr-block" : _options_blockClass, _options_blockSelector = options.blockSelector, blockSelector = _options_blockSelector === void 0 ? null : _options_blockSelector, _options_ignoreClass = options.ignoreClass, ignoreClass = _options_ignoreClass === void 0 ? "rr-ignore" : _options_ignoreClass, _options_ignoreSelector = options.ignoreSelector, ignoreSelector = _options_ignoreSelector === void 0 ? null : _options_ignoreSelector, _options_maskTextClass = options.maskTextClass, maskTextClass = _options_maskTextClass === void 0 ? "rr-mask" : _options_maskTextClass, _options_maskTextSelector = options.maskTextSelector, maskTextSelector = _options_maskTextSelector === void 0 ? null : _options_maskTextSelector, _options_inlineStylesheet = options.inlineStylesheet, inlineStylesheet = _options_inlineStylesheet === void 0 ? true : _options_inlineStylesheet, maskAllInputs = options.maskAllInputs, _maskInputOptions = options.maskInputOptions, _slimDOMOptions = options.slimDOMOptions, maskInputFn = options.maskInputFn, maskTextFn = options.maskTextFn, hooks = options.hooks, packFn = options.packFn, _options_sampling = options.sampling, sampling = _options_sampling === void 0 ? {} : _options_sampling, _options_dataURLOptions = options.dataURLOptions, dataURLOptions = _options_dataURLOptions === void 0 ? {} : _options_dataURLOptions, mousemoveWait = options.mousemoveWait, _options_recordDOM = options.recordDOM, recordDOM = _options_recordDOM === void 0 ? true : _options_recordDOM, _options_recordCanvas = options.recordCanvas, recordCanvas = _options_recordCanvas === void 0 ? false : _options_recordCanvas, _options_recordCrossOriginIframes = options.recordCrossOriginIframes, recordCrossOriginIframes = _options_recordCrossOriginIframes === void 0 ? false : _options_recordCrossOriginIframes, allowedIframeOrigins = options.allowedIframeOrigins, _options_recordAfter = options.recordAfter, recordAfter = _options_recordAfter === void 0 ? options.recordAfter === "DOMContentLoaded" ? options.recordAfter : "load" : _options_recordAfter, _options_userTriggeredOnInput = options.userTriggeredOnInput, userTriggeredOnInput = _options_userTriggeredOnInput === void 0 ? false : _options_userTriggeredOnInput, _options_collectFonts = options.collectFonts, collectFonts = _options_collectFonts === void 0 ? false : _options_collectFonts, _options_inlineImages = options.inlineImages, inlineImages = _options_inlineImages === void 0 ? false : _options_inlineImages, plugins = options.plugins, _options_keepIframeSrcFn = options.keepIframeSrcFn, keepIframeSrcFn = _options_keepIframeSrcFn === void 0 ? function() {
         return false;
     } : _options_keepIframeSrcFn, _options_ignoreCSSAttributes = options.ignoreCSSAttributes, ignoreCSSAttributes = _options_ignoreCSSAttributes === void 0 ? /* @__PURE__ */ new Set([]) : _options_ignoreCSSAttributes, errorHandler2 = options.errorHandler;
     registerErrorHandler(errorHandler2);
+    var validatedOrigins;
+    if (recordCrossOriginIframes && allowedIframeOrigins && allowedIframeOrigins.length > 0) {
+        validatedOrigins = buildAllowedOriginSet(allowedIframeOrigins);
+        if (validatedOrigins.size === 0) {
+            validatedOrigins = void 0;
+        }
+    }
     var inEmittingFrame = recordCrossOriginIframes ? window.parent === window : true;
     var passEmitsToParent = false;
     if (!inEmittingFrame) {
@@ -13399,7 +13442,14 @@ function record(options) {
                 origin: window.location.origin,
                 isCheckout: isCheckout
             };
-            window.parent.postMessage(message, "*");
+            if (validatedOrigins) {
+                for(var _iterator = _create_for_of_iterator_helper_loose(validatedOrigins), _step; !(_step = _iterator()).done;){
+                    var targetOrigin = _step.value;
+                    window.parent.postMessage(message, targetOrigin);
+                }
+            } else {
+                window.parent.postMessage(message, "*");
+            }
         }
         if (e2.type === EventType.FullSnapshot) {
             lastFullSnapshotEvent = e2;
@@ -18132,7 +18182,7 @@ var __defNormalProp = function(obj, key, value) {
 var __publicField = function(obj, key, value) {
     return __defNormalProp(obj, (typeof key === "undefined" ? "undefined" : _type_of(key)) !== "symbol" ? key + "" : key, value);
 };
-function patch(source, name, replacement) {
+function patch$3(source, name, replacement) {
     try {
         if (!(name in source)) {
             return function() {};
@@ -18549,7 +18599,7 @@ function initLogObserver(cb, win, options) {
         if (!_logger[level]) {
             return function() {};
         }
-        return patch(_logger, level, function(original) {
+        return patch$3(_logger, level, function(original) {
             var _this1 = _this;
             return function() {
                 for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
@@ -18970,11 +19020,6 @@ if (typeof Promise !== 'undefined' && Promise.toString().indexOf('[native code]'
     PromisePolyfill = NpoPromise;
 }
 
-var Config = {
-    DEBUG: false,
-    LIB_VERSION: '2.75.0'
-};
-
 /* eslint camelcase: "off", eqeqeq: "off" */
 
 // Maximum allowed session recording length
@@ -20706,6 +20751,17 @@ var isOnline = function() {
 
 var NOOP_FUNC = function () {};
 
+var urlMatchesRegexList = function (url, regexList) {
+    var matches = false;
+    for (var i = 0; i < regexList.length; i++) {
+        if (url.match(regexList[i])) {
+            matches = true;
+            break;
+        }
+    }
+    return matches;
+};
+
 var JSONStringify = null, JSONParse = null;
 if (typeof JSON !== 'undefined') {
     JSONStringify = JSON.stringify;
@@ -21177,7 +21233,7 @@ function _addOptOutCheck(method, getConfigValue) {
     };
 }
 
-var logger$6 = console_with_prefix('lock');
+var logger$8 = console_with_prefix('lock');
 
 /**
  * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
@@ -21229,7 +21285,7 @@ SharedLock.prototype.withLock = function(lockedCB, pid) {
 
         var delay = function(cb) {
             if (new Date().getTime() - startTime > timeoutMS) {
-                logger$6.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                logger$8.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
                 storage.removeItem(keyZ);
                 storage.removeItem(keyY);
                 loop();
@@ -21376,7 +21432,7 @@ LocalStorageWrapper.prototype.removeItem = function (key) {
     }, this));
 };
 
-var logger$5 = console_with_prefix('batch');
+var logger$7 = console_with_prefix('batch');
 
 /**
  * RequestQueue: queue for batching API requests with localStorage backup for retries.
@@ -21405,7 +21461,7 @@ var RequestQueue = function (storageKey, options) {
             timeoutMS: options.sharedLockTimeoutMS,
         });
     }
-    this.reportError = options.errorReporter || _.bind(logger$5.error, logger$5);
+    this.reportError = options.errorReporter || _.bind(logger$7.error, logger$7);
 
     this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
@@ -21738,7 +21794,7 @@ RequestQueue.prototype.clear = function () {
 // maximum interval between request retries after exponential backoff
 var MAX_RETRY_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
 
-var logger$4 = console_with_prefix('batch');
+var logger$6 = console_with_prefix('batch');
 
 /**
  * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
@@ -21866,7 +21922,7 @@ RequestBatcher.prototype.sendRequestPromise = function(data, options) {
  */
 RequestBatcher.prototype.flush = function(options) {
     if (this.requestInProgress) {
-        logger$4.log('Flush: Request already in progress');
+        logger$6.log('Flush: Request already in progress');
         return PromisePolyfill.resolve();
     }
 
@@ -22043,7 +22099,7 @@ RequestBatcher.prototype.flush = function(options) {
             if (options.unloading) {
                 requestOptions.transport = 'sendBeacon';
             }
-            logger$4.log('MIXPANEL REQUEST:', dataForRequest);
+            logger$6.log('MIXPANEL REQUEST:', dataForRequest);
             return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
         }, this))
         .catch(_.bind(function(err) {
@@ -22056,7 +22112,7 @@ RequestBatcher.prototype.flush = function(options) {
  * Log error to global logger and optional user-defined logger.
  */
 RequestBatcher.prototype.reportError = function(msg, err) {
-    logger$4.error.apply(logger$4.error, arguments);
+    logger$6.error.apply(logger$6.error, arguments);
     if (this.errorReporter) {
         try {
             if (!(err instanceof Error)) {
@@ -22064,7 +22120,7 @@ RequestBatcher.prototype.reportError = function(msg, err) {
             }
             this.errorReporter(msg, err);
         } catch(err) {
-            logger$4.error(err);
+            logger$6.error(err);
         }
     }
 };
@@ -22081,6 +22137,29 @@ var isRecordingExpired = function(serializedRecording) {
 
 var RECORD_ENQUEUE_THROTTLE_MS = 250;
 
+var validateAllowedOrigins = function(origins, logger) {
+    if (!_.isArray(origins)) {
+        if (origins) {
+            logger.critical('record_allowed_iframe_origins must be an array of origin strings, cross-origin recording will be disabled.');
+        }
+        return [];
+    }
+    var valid = [];
+    for (var i = 0; i < origins.length; i++) {
+        try {
+            var origin = new URL(origins[i]).origin;
+            if (origin === 'null') {
+                logger.critical(origins[i] + ' has an opaque origin. Skipping this entry.');
+                continue;
+            }
+            valid.push(origin);
+        } catch (e) {
+            logger.critical(origins[i] + ' is not a valid origin URL. Skipping this entry.');
+        }
+    }
+    return valid;
+};
+
 // stateless utils
 // mostly from https://github.com/mixpanel/mixpanel-js/blob/989ada50f518edab47b9c4fd9535f9fbd5ec5fc0/src/autotrack-utils.js
 
@@ -22186,7 +22265,7 @@ var EVENT_HANDLER_ATTRIBUTES = [
 
 var MAX_DEPTH = 5;
 
-var logger$3 = console_with_prefix('autocapture');
+var logger$5 = console_with_prefix('autocapture');
 
 
 function getClasses(el) {
@@ -22450,7 +22529,7 @@ function isElementAllowed(el, ev, allowElementCallback, allowSelectors) {
                 return false;
             }
         } catch (err) {
-            logger$3.critical('Error while checking element in allowElementCallback', err);
+            logger$5.critical('Error while checking element in allowElementCallback', err);
             return false;
         }
     }
@@ -22467,7 +22546,7 @@ function isElementAllowed(el, ev, allowElementCallback, allowSelectors) {
                 return true;
             }
         } catch (err) {
-            logger$3.critical('Error while checking selector: ' + sel, err);
+            logger$5.critical('Error while checking selector: ' + sel, err);
         }
     }
     return false;
@@ -22482,7 +22561,7 @@ function isElementBlocked(el, ev, blockElementCallback, blockSelectors) {
                 return true;
             }
         } catch (err) {
-            logger$3.critical('Error while checking element in blockElementCallback', err);
+            logger$5.critical('Error while checking element in blockElementCallback', err);
             return true;
         }
     }
@@ -22496,7 +22575,7 @@ function isElementBlocked(el, ev, blockElementCallback, blockSelectors) {
                     return true;
                 }
             } catch (err) {
-                logger$3.critical('Error while checking selector: ' + sel, err);
+                logger$5.critical('Error while checking selector: ' + sel, err);
             }
         }
     }
@@ -23044,177 +23123,826 @@ function shouldMaskText(element, privacyConfig) {
 }
 
 /**
- * @typedef {import('../index').RecordPrivacyConfig} RecordPrivacyConfig
+ * This is a port of the open rrweb network plugin in this PR https://github.com/rrweb-io/rrweb/pull/1105
+ * the hope is that eventually this can be replaced with the official plugin once it's published (and we sync the mixpanel rrweb fork)
+ *
+ * This plugin incorporates some important fixes for fetch/XHR body recording that are not yet in the main rrweb repo, as well as makes
+ * header and body recording more restrictive by requiring an allowlist instead of content type / blocklist.
+ *
  */
 
+var logger$4 = console_with_prefix('network-plugin');
 
-var logger$2 = console_with_prefix('recorder');
-var CompressionStream = win['CompressionStream'];
-
-var RECORDER_BATCHER_LIB_CONFIG = {
-    'batch_size': 1000,
-    'batch_flush_interval_ms': 10 * 1000,
-    'batch_request_timeout_ms': 90 * 1000,
-    'batch_autostart': true
-};
+/**
+ * Get the time origin for converting performance timestamps to absolute timestamps.
+ * Uses Date.now() - performance.now() instead of performance.timeOrigin because
+ * browsers can report timeOrigin values that are skewed from actual time, and some
+ * browsers (notably older Safari versions) don't implement timeOrigin at all.
+ * See: https://github.com/getsentry/sentry-javascript/blob/e856e40b6e71a73252e788cd42b5260f81c9c88e/packages/utils/src/time.ts#L49-L70
+ * @param {Window} win
+ * @returns {number}
+ */
+function getTimeOrigin(win) {
+    return Math.round(Date.now() - win.performance.now());
+}
 
-var ACTIVE_SOURCES = new Set([
-    IncrementalSource.MouseMove,
-    IncrementalSource.MouseInteraction,
-    IncrementalSource.Scroll,
-    IncrementalSource.ViewportResize,
-    IncrementalSource.Input,
-    IncrementalSource.TouchMove,
-    IncrementalSource.MediaInteraction,
-    IncrementalSource.Drag,
-    IncrementalSource.Selection,
-]);
+/**
+ * @typedef {import('../index.d.ts').InitiatorType} InitiatorType
+ * @typedef {import('../index.d.ts').NetworkRequest} NetworkRequest
+ * @typedef {import('../index.d.ts').NetworkRecordOptions} NetworkRecordOptions
+ * @typedef {import('../index.d.ts').NetworkData} NetworkData
+ */
 
-function isUserEvent(ev) {
-    return ev.type === EventType.IncrementalSnapshot && ACTIVE_SOURCES.has(ev.data.source);
-}
+/**
+ * @typedef {Record<string, string>} Headers
+ */
 
 /**
- * @typedef {Object} SerializedRecording
- * @property {number} idleExpires
- * @property {number} maxExpires
- * @property {number} replayStartTime
- * @property {number} lastEventTimestamp
- * @property {number} seqNo
- * @property {string} batchStartUrl
- * @property {string} replayId
- * @property {string} tabId
- * @property {string} replayStartUrl
+ * @typedef {string | Document | Blob | ArrayBufferView | ArrayBuffer | FormData | URLSearchParams | ReadableStream<Uint8Array> | null} Body
  */
 
 /**
- * @typedef {Object} SessionRecordingOptions
- * @property {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
- * @property {String} [options.replayId] - unique uuid for a single replay
- * @property {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
- * @property {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
- * @property {import('./rrweb-entrypoint').record} [options.rrwebRecord] - rrweb's `record` function
- * @property {Function} [options.onBatchSent] - callback when a batch of events is sent to the server
- * @property {Storage} [options.sharedLockStorage] - optional storage for shared lock, used for test dependency injection
- * optional properties for deserialization:
- * @property {number} idleExpires
- * @property {number} maxExpires
- * @property {number} replayStartTime
- * @property {number} lastEventTimestamp - the unix timestamp of the last recorded event from rrweb
- * @property {number} seqNo
- * @property {string} batchStartUrl
- * @property {string} replayStartUrl
+ * @callback networkCallback
+ * @param {NetworkData} data
+ * @returns {void}
  */
 
 /**
- * @typedef {Object} UserIdInfo
- * @property {string} distinct_id
- * @property {string} user_id
- * @property {string} device_id
+ * @callback listenerHandler
+ * @returns {void}
  */
 
+/**
+ * @typedef {(PerformanceNavigationTiming | PerformanceResourceTiming) & { responseStatus?: number }} ObservedPerformanceEntry
+ */
 
 /**
- * This class encapsulates a single session recording and its lifecycle.
- * @param {SessionRecordingOptions} options
+ * @typedef {Object} RecordPlugin
+ * @property {string} name
+ * @property {(callback: networkCallback, win: Window, options: NetworkRecordOptions) => listenerHandler} observer
+ * @property {NetworkRecordOptions} [options]
  */
-var SessionRecording = function(options) {
-    this._mixpanel = options.mixpanelInstance;
-    this._onIdleTimeout = options.onIdleTimeout || NOOP_FUNC;
-    this._onMaxLengthReached = options.onMaxLengthReached || NOOP_FUNC;
-    this._onBatchSent = options.onBatchSent || NOOP_FUNC;
-    this._rrwebRecord = options.rrwebRecord || null;
 
-    // internal rrweb stopRecording function
-    this._stopRecording = null;
-    this.replayId = options.replayId;
+/** @type {Required<NetworkRecordOptions>} */
+var defaultNetworkOptions = {
+    initiatorTypes: [
+        'audio',
+        'beacon',
+        'body',
+        'css',
+        'early-hint',
+        'embed',
+        'fetch',
+        'frame',
+        'iframe',
+        'icon',
+        'image',
+        'img',
+        'input',
+        'link',
+        'navigation',
+        'object',
+        'ping',
+        'script',
+        'track',
+        'video',
+        'xmlhttprequest',
+    ],
+    ignoreRequestFn: function() { return false; },
+    recordHeaders: {
+        request: [],
+        response: [],
+    },
+    recordBodyUrls: {
+        request: [],
+        response: [],
+    },
+    recordInitialRequests: false,
+};
 
-    this.batchStartUrl = options.batchStartUrl || null;
-    this.replayStartUrl = options.replayStartUrl || null;
-    this.idleExpires = options.idleExpires || null;
-    this.maxExpires = options.maxExpires || null;
-    this.replayStartTime = options.replayStartTime || null;
-    this.lastEventTimestamp = options.lastEventTimestamp || null;
-    this.seqNo = options.seqNo || 0;
+/**
+ * @param {PerformanceEntry} entry
+ * @returns {entry is PerformanceNavigationTiming}
+ */
+function isNavigationTiming(entry) {
+    return entry.entryType === 'navigation';
+}
 
-    this.idleTimeoutId = null;
-    this.maxTimeoutId = null;
+/**
+ * @param {PerformanceEntry} entry
+ * @returns {entry is PerformanceResourceTiming}
+ */
+function isResourceTiming (entry) {
+    return entry.entryType === 'resource';
+}
 
-    this.recordMaxMs = MAX_RECORDING_MS;
-    this.recordMinMs = 0;
+function findLast(array, predicate) {
+    var length = array.length;
+    for (var i = length - 1; i >= 0; i -= 1) {
+        if (predicate(array[i])) {
+            return array[i];
+        }
+    }
+}
 
-    // disable persistence if localStorage is not supported
-    // request-queue will automatically disable persistence if indexedDB fails to initialize
-    var usePersistence = localStorageSupported(options.sharedLockStorage, true) && !this.getConfig('disable_persistence');
+/**
+ * Monkey-patches a method on an object with a wrapped version, returning a function that restores the original.
+ * Adapted from Sentry's `fill` utility:
+ * https://github.com/getsentry/sentry-javascript/blob/de5c5cbe177b4334386e747857225eec36a91ea1/packages/core/src/utils/object.ts#L67-L95
+ *
+ * @param {object} source - The object containing the method to patch
+ * @param {string} name - The method name to patch
+ * @param {function} replacementFactory - A function that receives the original method and returns the replacement
+ * @returns {function} A function that restores the original method
+ */
+function patch(source, name, replacementFactory) {
+    if (!(name in source) || typeof source[name] !== 'function') {
+        return function() {};
+    }
+    var original = source[name];
+    var wrapped = replacementFactory(original);
+    source[name] = wrapped;
+    return function() {
+        source[name] = original;
+    };
+}
 
-    // each replay has its own batcher key to avoid conflicts between rrweb events of different recordings
-    this.batcherKey = '__mprec_' + this.getConfig('name') + '_' + this.getConfig('token') + '_' + this.replayId;
-    this.queueStorage = new IDBStorageWrapper(RECORDING_EVENTS_STORE_NAME);
-    this.batcher = new RequestBatcher(this.batcherKey, {
-        errorReporter: this.reportError.bind(this),
-        flushOnlyOnInterval: true,
-        libConfig: RECORDER_BATCHER_LIB_CONFIG,
-        sendRequestFunc: this.flushEventsWithOptOut.bind(this),
-        queueStorage: this.queueStorage,
-        sharedLockStorage: options.sharedLockStorage,
-        usePersistence: usePersistence,
-        stopAllBatchingFunc: this.stopRecording.bind(this),
 
-        // increased throttle and shared lock timeout because recording events are very high frequency.
-        // this will minimize the amount of lock contention between enqueued events.
-        // for session recordings there is a lock for each tab anyway, so there's no risk of deadlock between tabs.
-        enqueueThrottleMs: RECORD_ENQUEUE_THROTTLE_MS,
-        sharedLockTimeoutMS: 10 * 1000,
-    });
-};
+/**
+ * Maximum body size to record (1MB)
+ */
+var MAX_BODY_SIZE = 1024 * 1024;
 
 /**
- * @returns {UserIdInfo}
+ * Truncate string if it exceeds max size
+ * @param {string} str
+ * @returns {string}
  */
-SessionRecording.prototype.getUserIdInfo = function () {
-    if (this.finalFlushUserIdInfo) {
-        return this.finalFlushUserIdInfo;
+function truncateBody(str) {
+    if (!str || typeof str !== 'string') {
+        return str;
+    }
+    if (str.length > MAX_BODY_SIZE) {
+        logger$4.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
+        return str.substring(0, MAX_BODY_SIZE) + '... [truncated]';
     }
+    return str;
+}
 
-    var userIdInfo = {
-        'distinct_id': String(this._mixpanel.get_distinct_id()),
+/**
+ * @param {networkCallback} cb
+ * @param {Window} win
+ * @param {Required<NetworkRecordOptions>} options
+ * @returns {listenerHandler}
+ */
+function initPerformanceObserver(cb, win, options) {
+    if (!win.PerformanceObserver) {
+        logger$4.error('PerformanceObserver not supported');
+        return function() {
+            //
+        };
+    }
+    if (options.recordInitialRequests) {
+        var initialPerformanceEntries = win.performance
+            .getEntries()
+            .filter(function(entry) {
+                return isNavigationTiming(entry) ||
+          (isResourceTiming(entry) &&
+            options.initiatorTypes.includes(entry.initiatorType));
+            });
+        cb({
+            requests: initialPerformanceEntries.map(function(entry) {
+                return {
+                    url: entry.name,
+                    initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                    status: 'responseStatus' in entry ? entry.responseStatus : undefined,
+                    startTime: Math.round(entry.startTime),
+                    endTime: Math.round(entry.responseEnd),
+                    timeOrigin: getTimeOrigin(win),
+                };
+            }),
+            isInitial: true,
+        });
+    }
+    var observer = new win.PerformanceObserver(function(entries) {
+        var performanceEntries = entries
+            .getEntries()
+            .filter(function(entry) {
+                return isResourceTiming(entry) &&
+                    options.initiatorTypes.includes(entry.initiatorType) &&
+                    entry.initiatorType !== 'xmlhttprequest' &&
+                    entry.initiatorType !== 'fetch';
+            });
+        cb({
+            requests: performanceEntries.map(function(entry) {
+                return {
+                    url: entry.name,
+                    initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                    status: 'responseStatus' in entry ? entry.responseStatus : undefined,
+                    startTime: Math.round(entry.startTime),
+                    endTime: Math.round(entry.responseEnd),
+                    timeOrigin: getTimeOrigin(win),
+                };
+            }),
+        });
+    });
+    observer.observe({ entryTypes: ['navigation', 'resource'] });
+    return function() {
+        observer.disconnect();
     };
+}
 
-    // send ID management props if they exist
-    var deviceId = this._mixpanel.get_property('$device_id');
-    if (deviceId) {
-        userIdInfo['$device_id'] = deviceId;
-    }
-    var userId = this._mixpanel.get_property('$user_id');
-    if (userId) {
-        userIdInfo['$user_id'] = userId;
+/**
+ * Variation of the original rrweb function that requires an allowlist for headers instead of supporting boolean options
+ * @param {'request' | 'response'} type
+ * @param {NetworkRecordOptions['recordHeaders']} recordHeaders
+ * @param {string} headerName
+ * @returns {boolean}
+ */
+function shouldRecordHeader(type, recordHeaders, headerName) {
+    if (!recordHeaders[type] || recordHeaders[type].length === 0) {
+        return false;
     }
-    return userIdInfo;
-};
 
-SessionRecording.prototype.unloadPersistedData = function () {
-    this.batcher.stop();
+    return recordHeaders[type].includes(headerName.toLowerCase());
+}
 
-    return this.queueStorage.init().catch(function () {
-        this.reportError('Error initializing IndexedDB storage for unloading persisted data.');
-    }.bind(this)).then(function () {
-        // if the recording is too short, just delete any stored events without flushing
-        if (this.getDurationMs() < this._getRecordMinMs()) {
-            return this.queueStorage.removeItem(this.batcherKey);
-        }
+/**
+ * Variation of the original rrweb function that requires an allowlist for URLs instead of supporting boolean options or by content type
+ * @param {'request' | 'response'} type
+ * @param {NetworkRecordOptions['recordBodyUrls']} recordBodyUrls
+ * @param {string} url
+ * @returns {boolean}
+ */
+function shouldRecordBody(type, recordBodyUrls, url) {
+    if (!recordBodyUrls[type] || recordBodyUrls[type].length === 0) {
+        return false;
+    }
 
-        return this.batcher.flush()
-            .then(function () {
-                return this.queueStorage.removeItem(this.batcherKey);
-            }.bind(this));
-    }.bind(this));
-};
+    return urlMatchesRegexList(url, recordBodyUrls[type]);
+}
 
-SessionRecording.prototype.getConfig = function(configVar) {
-    return this._mixpanel.get_config(configVar);
-};
+function tryReadXHRBody(body) {
+    if (body === null || body === undefined) {
+        return null;
+    }
 
-// Alias for getConfig, used by the common addOptOutCheckMixpanelLib function which
+    var result;
+    if (typeof body === 'string') {
+        result = body;
+    } else if (body instanceof Document) {
+        result = body.textContent;
+    } else if (body instanceof FormData) {
+        result = _.HTTPBuildQuery(body);
+    } else if (_.isObject(body)) {
+        try {
+            result = JSON.stringify(body);
+        } catch (e) {
+            return 'Failed to stringify response object';
+        }
+    } else {
+        return 'Cannot read body of type ' + typeof body;
+    }
+
+    return truncateBody(result);
+}
+
+/**
+ * @param {Request | Response} r
+ * @returns {Promise<string>}
+ */
+function tryReadFetchBody(r) {
+    return new Promise(function(resolve) {
+        var timeout = setTimeout(function() {
+            resolve('Timeout while trying to read body');
+        }, 500);
+        try {
+            r.clone()
+                .text()
+                .then(
+                    function(txt) {
+                        clearTimeout(timeout);
+                        resolve(truncateBody(txt));
+                    },
+                    function(reason) {
+                        clearTimeout(timeout);
+                        resolve('Failed to read body: ' + String(reason));
+                    }
+                );
+        } catch (e) {
+            clearTimeout(timeout);
+            resolve('Failed to read body: ' + String(e));
+        }
+    });
+}
+
+/**
+ * @param {Window} win
+ * @param {string} initiatorType
+ * @param {string} url
+ * @param {number} [after]
+ * @param {number} [before]
+ * @param {number} [attempt]
+ * @returns {Promise<PerformanceResourceTiming>}
+ */
+function getRequestPerformanceEntry(win, initiatorType, url, after, before, attempt) {
+    if (attempt === undefined) {
+        attempt = 0;
+    }
+    if (attempt > 10) {
+        logger$4.error('Cannot find performance entry');
+        return Promise.resolve(null);
+    }
+    var urlPerformanceEntries = /** @type {PerformanceResourceTiming[]} */ (
+        win.performance.getEntriesByName(url)
+    );
+    var performanceEntry = findLast(
+        urlPerformanceEntries,
+        function(entry) {
+            return isResourceTiming(entry) &&
+        entry.initiatorType === initiatorType &&
+        (!after || entry.startTime >= after) &&
+        (!before || entry.startTime <= before);
+        }
+    );
+    if (!performanceEntry) {
+        return new Promise(function(resolve) {
+            setTimeout(resolve, 50 * attempt);
+        }).then(function() {
+            return getRequestPerformanceEntry(
+                win,
+                initiatorType,
+                url,
+                after,
+                before,
+                attempt + 1
+            );
+        });
+    }
+    return Promise.resolve(performanceEntry);
+}
+
+/**
+ * @param {networkCallback} cb
+ * @param {Window} win
+ * @param {Required<NetworkRecordOptions>} options
+ * @returns {listenerHandler}
+ */
+function initXhrObserver(cb, win, options) {
+    if (!options.initiatorTypes.includes('xmlhttprequest')) {
+        return function() {
+            //
+        };
+    }
+    var restorePatch = patch(
+        win.XMLHttpRequest.prototype,
+        'open',
+        function(/** @type {typeof XMLHttpRequest.prototype.open} */ originalOpen) {
+            return function(
+                /** @type {string} */ method,
+                /** @type {string | URL} */ url,
+                /** @type {boolean} */ async,
+                username, password
+            ) {
+                if (async === undefined) {
+                    async = true;
+                }
+                var xhr = /** @type {XMLHttpRequest} */ (this);
+                var req = new Request(url, { method: method });
+                /** @type {Partial<NetworkRequest>} */
+                var networkRequest = {};
+                /** @type {number | undefined} */
+                var after;
+                /** @type {number | undefined} */
+                var before;
+
+                /** @type {Headers} */
+                var requestHeaders = {};
+                var originalSetRequestHeader = xhr.setRequestHeader.bind(xhr);
+                xhr.setRequestHeader = function(/** @type {string} */ header, /** @type {string} */ value) {
+                    if (shouldRecordHeader('request', options.recordHeaders, header)) {
+                        requestHeaders[header] = value;
+                    }
+                    return originalSetRequestHeader(header, value);
+                };
+                networkRequest.requestHeaders = requestHeaders;
+
+                var originalSend = xhr.send.bind(xhr);
+                xhr.send = function(/** @type {Body} */ body) {
+                    if (shouldRecordBody('request', options.recordBodyUrls, req.url)) {
+                        networkRequest.requestBody = tryReadXHRBody(body);
+                    }
+                    after = win.performance.now();
+                    return originalSend(body);
+                };
+                xhr.addEventListener('readystatechange', function() {
+                    if (xhr.readyState !== xhr.DONE) {
+                        return;
+                    }
+                    before = win.performance.now();
+                    /** @type {Headers} */
+                    var responseHeaders = {};
+                    var rawHeaders = xhr.getAllResponseHeaders();
+                    if (rawHeaders) {
+                        var headers = rawHeaders.trim().split(/[\r\n]+/);
+                        headers.forEach(function(line) {
+                            if (!line) return;
+                            var colonIndex = line.indexOf(': ');
+                            if (colonIndex === -1) return;
+                            var header = line.substring(0, colonIndex);
+                            var value = line.substring(colonIndex + 2);
+                            if (header && shouldRecordHeader('response', options.recordHeaders, header)) {
+                                responseHeaders[header] = value;
+                            }
+                        });
+                    }
+                    networkRequest.responseHeaders = responseHeaders;
+                    if (
+                        shouldRecordBody('response', options.recordBodyUrls, req.url)
+                    ) {
+                        networkRequest.responseBody = tryReadXHRBody(xhr.response);
+                    }
+                    getRequestPerformanceEntry(
+                        win,
+                        'xmlhttprequest',
+                        req.url,
+                        after,
+                        before
+                    )
+                        .then(function(entry) {
+                            if (!entry) {
+                                logger$4.error('Failed to get performance entry for XHR request to ' + req.url);
+                                return;
+                            }
+                            /** @type {NetworkRequest} */
+                            var request = {
+                                url: entry.name,
+                                method: req.method,
+                                initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                                status: xhr.status,
+                                startTime: Math.round(entry.startTime),
+                                endTime: Math.round(entry.responseEnd),
+                                timeOrigin: getTimeOrigin(win),
+                                requestHeaders: networkRequest.requestHeaders,
+                                requestBody: networkRequest.requestBody,
+                                responseHeaders: networkRequest.responseHeaders,
+                                responseBody: networkRequest.responseBody,
+                            };
+                            cb({ requests: [request] });
+                        })
+                        .catch(function(e) {
+                            logger$4.error('Error recording XHR request to ' + req.url + ': ' + String(e));
+                        });
+                });
+
+                originalOpen.call(xhr, method, url, async, username, password);
+            };
+        }
+    );
+    return function() {
+        restorePatch();
+    };
+}
+
+/**
+ * @param {networkCallback} cb
+ * @param {Window} win
+ * @param {Required<NetworkRecordOptions>} options
+ * @returns {listenerHandler}
+ */
+function initFetchObserver(cb, win, options) {
+    if (!options.initiatorTypes.includes('fetch')) {
+        return function() {
+            //
+        };
+    }
+
+    var restorePatch = patch(win, 'fetch', function(/** @type {typeof fetch} */ originalFetch) {
+        return function() {
+            var req = new Request(arguments[0], arguments[1]);
+            /** @type {Response | undefined} */
+            var res;
+            /** @type {Partial<NetworkRequest>} */
+            var networkRequest = {};
+            /** @type {number | undefined} */
+            var after;
+            /** @type {number | undefined} */
+            var before;
+
+            var originalFetchPromise;
+            var requestBodyPromise = Promise.resolve(undefined);
+            var responseBodyPromise = Promise.resolve(undefined);
+            try {
+                /** @type {Headers} */
+                var requestHeaders = {};
+                req.headers.forEach(function(value, header) {
+                    if (shouldRecordHeader('request', options.recordHeaders, header)) {
+                        requestHeaders[header] = value;
+                    }
+                });
+                networkRequest.requestHeaders = requestHeaders;
+
+                if (shouldRecordBody('request', options.recordBodyUrls, req.url)) {
+                    requestBodyPromise = tryReadFetchBody(req)
+                        .then(function(body) {
+                            networkRequest.requestBody = body;
+                        });
+                }
+
+                after = win.performance.now();
+                originalFetchPromise = originalFetch.apply(win, arguments).then(function(response) {
+                    res = response;
+                    before = win.performance.now();
+
+                    /** @type {Headers} */
+                    var responseHeaders = {};
+                    res.headers.forEach(function(value, header) {
+                        if (shouldRecordHeader('response', options.recordHeaders, header)) {
+                            responseHeaders[header] = value;
+                        }
+                    });
+                    networkRequest.responseHeaders = responseHeaders;
+
+                    if (shouldRecordBody('response', options.recordBodyUrls, req.url)) {
+                        responseBodyPromise = tryReadFetchBody(res)
+                            .then(function(body) {
+                                networkRequest.responseBody = body;
+                            });
+                    }
+
+                    return res;
+                });
+            } catch (e) {
+                originalFetchPromise = Promise.reject(e);
+            }
+
+            // await concurrently so we don't delay the fetch response
+            Promise.all([requestBodyPromise, responseBodyPromise, originalFetchPromise])
+                .then(function () {
+                    return getRequestPerformanceEntry(win, 'fetch', req.url, after, before);
+                })
+                .then(function(entry) {
+                    if (!entry) {
+                        logger$4.error('Failed to get performance entry for fetch request to ' + req.url);
+                        return;
+                    }
+                    /** @type {NetworkRequest} */
+                    var request = {
+                        url: entry.name,
+                        method: req.method,
+                        initiatorType: /** @type {InitiatorType} */ (entry.initiatorType),
+                        status: res ? res.status : undefined,
+                        startTime: Math.round(entry.startTime),
+                        endTime: Math.round(entry.responseEnd),
+                        timeOrigin: getTimeOrigin(win),
+                        requestHeaders: networkRequest.requestHeaders,
+                        requestBody: networkRequest.requestBody,
+                        responseHeaders: networkRequest.responseHeaders,
+                        responseBody: networkRequest.responseBody,
+                    };
+                    cb({ requests: [request] });
+                })
+                .catch(function (e) {
+                    logger$4.error('Error recording fetch request to ' + req.url + ': ' + String(e));
+                });
+
+            return originalFetchPromise;
+        };
+    });
+    return function() {
+        restorePatch();
+    };
+}
+
+/**
+ * @param {networkCallback} callback
+ * @param {Window} win
+ * @param {NetworkRecordOptions} options
+ * @returns {listenerHandler}
+ */
+function initNetworkObserver(callback, win, options) {
+    if (!('performance' in win)) {
+        return function() {
+            //
+        };
+    }
+
+    var recordHeaders = Object.assign({}, defaultNetworkOptions.recordHeaders, options.recordHeaders || {});
+    var recordBodyUrls = Object.assign({}, defaultNetworkOptions.recordBodyUrls, options.recordBodyUrls || {});
+    options = Object.assign({}, options, {
+        recordHeaders: recordHeaders,
+        recordBodyUrls: recordBodyUrls,
+    });
+    var networkOptions = /** @type {Required<NetworkRecordOptions>} */ Object.assign({}, defaultNetworkOptions, options);
+
+    /** @type {networkCallback} */
+    var cb = function(data) {
+        var requests = data.requests.filter(function(request) {
+            var shouldIgnoreUrl = urlMatchesRegexList(request.url, networkOptions.ignoreRequestUrls || []);
+            return !shouldIgnoreUrl && !networkOptions.ignoreRequestFn(request);
+        });
+        if (requests.length > 0 || data.isInitial) {
+            callback(Object.assign({}, data, { requests: requests }));
+        }
+    };
+    var performanceObserver = initPerformanceObserver(cb, win, networkOptions);
+    var xhrObserver = initXhrObserver(cb, win, networkOptions);
+    var fetchObserver = initFetchObserver(cb, win, networkOptions);
+    return function() {
+        performanceObserver();
+        xhrObserver();
+        fetchObserver();
+    };
+}
+
+// arbitrary .mp suffix in case rrweb does publish this plugin later and we use it but need to handle
+// a changed format in the mixpanel product.
+var NETWORK_PLUGIN_NAME = 'rrweb/network@1.mp';
+
+/**
+ * @param {NetworkRecordOptions} [options]
+ * @returns {RecordPlugin}
+ */
+var getRecordNetworkPlugin = function(options) {
+    return {
+        name: NETWORK_PLUGIN_NAME,
+        observer: initNetworkObserver,
+        options: options,
+    };
+};
+
+/**
+ * @typedef {import('../index').RecordPrivacyConfig} RecordPrivacyConfig
+ */
+
+
+var logger$3 = console_with_prefix('recorder');
+var CompressionStream = win['CompressionStream'];
+
+var RECORDER_BATCHER_LIB_CONFIG = {
+    'batch_size': 1000,
+    'batch_flush_interval_ms': 10 * 1000,
+    'batch_request_timeout_ms': 90 * 1000,
+    'batch_autostart': true
+};
+
+var ACTIVE_SOURCES = new Set([
+    IncrementalSource.MouseMove,
+    IncrementalSource.MouseInteraction,
+    IncrementalSource.Scroll,
+    IncrementalSource.ViewportResize,
+    IncrementalSource.Input,
+    IncrementalSource.TouchMove,
+    IncrementalSource.MediaInteraction,
+    IncrementalSource.Drag,
+    IncrementalSource.Selection,
+]);
+
+function isUserEvent(ev) {
+    return ev.type === EventType.IncrementalSnapshot && ACTIVE_SOURCES.has(ev.data.source);
+}
+
+/**
+ * @typedef {Object} SerializedRecording
+ * @property {number} idleExpires
+ * @property {number} maxExpires
+ * @property {number} replayStartTime
+ * @property {number} lastEventTimestamp
+ * @property {number} seqNo
+ * @property {string} batchStartUrl
+ * @property {string} replayId
+ * @property {string} tabId
+ * @property {string} replayStartUrl
+ */
+
+/**
+ * @typedef {Object} SessionRecordingOptions
+ * @property {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
+ * @property {String} [options.replayId] - unique uuid for a single replay
+ * @property {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
+ * @property {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
+ * @property {import('./rrweb-entrypoint').record} [options.rrwebRecord] - rrweb's `record` function
+ * @property {Function} [options.onBatchSent] - callback when a batch of events is sent to the server
+ * @property {Storage} [options.sharedLockStorage] - optional storage for shared lock, used for test dependency injection
+ * optional properties for deserialization:
+ * @property {number} idleExpires
+ * @property {number} maxExpires
+ * @property {number} replayStartTime
+ * @property {number} lastEventTimestamp - the unix timestamp of the last recorded event from rrweb
+ * @property {number} seqNo
+ * @property {string} batchStartUrl
+ * @property {string} replayStartUrl
+ */
+
+/**
+ * @typedef {Object} UserIdInfo
+ * @property {string} distinct_id
+ * @property {string} user_id
+ * @property {string} device_id
+ */
+
+
+/**
+ * This class encapsulates a single session recording and its lifecycle.
+ * @param {SessionRecordingOptions} options
+ */
+var SessionRecording = function(options) {
+    this._mixpanel = options.mixpanelInstance;
+    this._onIdleTimeout = options.onIdleTimeout || NOOP_FUNC;
+    this._onMaxLengthReached = options.onMaxLengthReached || NOOP_FUNC;
+    this._onBatchSent = options.onBatchSent || NOOP_FUNC;
+    this._rrwebRecord = options.rrwebRecord || null;
+
+    // internal rrweb stopRecording function
+    this._stopRecording = null;
+    this.replayId = options.replayId;
+
+    this.batchStartUrl = options.batchStartUrl || null;
+    this.replayStartUrl = options.replayStartUrl || null;
+    this.idleExpires = options.idleExpires || null;
+    this.maxExpires = options.maxExpires || null;
+    this.replayStartTime = options.replayStartTime || null;
+    this.lastEventTimestamp = options.lastEventTimestamp || null;
+    this.seqNo = options.seqNo || 0;
+
+    this.idleTimeoutId = null;
+    this.maxTimeoutId = null;
+
+    this.recordMaxMs = MAX_RECORDING_MS;
+    this.recordMinMs = 0;
+
+    // disable persistence if localStorage is not supported
+    // request-queue will automatically disable persistence if indexedDB fails to initialize
+    var usePersistence = localStorageSupported(options.sharedLockStorage, true) && !this.getConfig('disable_persistence');
+
+    // each replay has its own batcher key to avoid conflicts between rrweb events of different recordings
+    this.batcherKey = '__mprec_' + this.getConfig('name') + '_' + this.getConfig('token') + '_' + this.replayId;
+    this.queueStorage = new IDBStorageWrapper(RECORDING_EVENTS_STORE_NAME);
+    this.batcher = new RequestBatcher(this.batcherKey, {
+        errorReporter: this.reportError.bind(this),
+        flushOnlyOnInterval: true,
+        libConfig: RECORDER_BATCHER_LIB_CONFIG,
+        sendRequestFunc: this.flushEventsWithOptOut.bind(this),
+        queueStorage: this.queueStorage,
+        sharedLockStorage: options.sharedLockStorage,
+        usePersistence: usePersistence,
+        stopAllBatchingFunc: this.stopRecording.bind(this),
+
+        // increased throttle and shared lock timeout because recording events are very high frequency.
+        // this will minimize the amount of lock contention between enqueued events.
+        // for session recordings there is a lock for each tab anyway, so there's no risk of deadlock between tabs.
+        enqueueThrottleMs: RECORD_ENQUEUE_THROTTLE_MS,
+        sharedLockTimeoutMS: 10 * 1000,
+    });
+};
+
+/**
+ * @returns {UserIdInfo}
+ */
+SessionRecording.prototype.getUserIdInfo = function () {
+    if (this.finalFlushUserIdInfo) {
+        return this.finalFlushUserIdInfo;
+    }
+
+    var userIdInfo = {
+        'distinct_id': String(this._mixpanel.get_distinct_id()),
+    };
+
+    // send ID management props if they exist
+    var deviceId = this._mixpanel.get_property('$device_id');
+    if (deviceId) {
+        userIdInfo['$device_id'] = deviceId;
+    }
+    var userId = this._mixpanel.get_property('$user_id');
+    if (userId) {
+        userIdInfo['$user_id'] = userId;
+    }
+    return userIdInfo;
+};
+
+SessionRecording.prototype.unloadPersistedData = function () {
+    this.batcher.stop();
+
+    return this.queueStorage.init().catch(function () {
+        this.reportError('Error initializing IndexedDB storage for unloading persisted data.');
+    }.bind(this)).then(function () {
+        // if the recording is too short, just delete any stored events without flushing
+        if (this.getDurationMs() < this._getRecordMinMs()) {
+            return this.queueStorage.removeItem(this.batcherKey);
+        }
+
+        return this.batcher.flush()
+            .then(function () {
+                return this.queueStorage.removeItem(this.batcherKey);
+            }.bind(this));
+    }.bind(this));
+};
+
+SessionRecording.prototype.getConfig = function(configVar) {
+    return this._mixpanel.get_config(configVar);
+};
+
+// Alias for getConfig, used by the common addOptOutCheckMixpanelLib function which
 // reaches into this class instance and expects the snake case version of the function.
 // eslint-disable-next-line camelcase
 SessionRecording.prototype.get_config = function(configVar) {
@@ -23228,14 +23956,14 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
     }
 
     if (this._stopRecording !== null) {
-        logger$2.log('Recording already in progress, skipping startRecording.');
+        logger$3.log('Recording already in progress, skipping startRecording.');
         return;
     }
 
     this.recordMaxMs = this.getConfig('record_max_ms');
     if (this.recordMaxMs > MAX_RECORDING_MS) {
         this.recordMaxMs = MAX_RECORDING_MS;
-        logger$2.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
+        logger$3.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
     }
 
     if (!this.maxExpires) {
@@ -23276,6 +24004,31 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
 
     var privacyConfig = getPrivacyConfig(this._mixpanel);
 
+    var plugins = [];
+    if (this.getConfig('record_network')) {
+        var options = this.getConfig('record_network_options') || {};
+        // don't track requests to Mixpanel /record API
+        var ignoreRequestUrls = (options.ignoreRequestUrls || []).slice();
+        ignoreRequestUrls.push(this._getApiRoute());
+        options.ignoreRequestUrls = ignoreRequestUrls;
+
+        plugins.push(getRecordNetworkPlugin(options));
+    }
+
+    if (this.getConfig('record_console')) {
+        plugins.push(
+            getRecordConsolePlugin({
+                stringifyOptions: {
+                    stringLengthLimit: 1000,
+                    numOfKeysLimit: 50,
+                    depthOfLimit: 2
+                }
+            })
+        );
+    }
+
+    var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$3);
+
     try {
         this._stopRecording = this._rrwebRecord({
             'emit': function (ev) {
@@ -23310,19 +24063,13 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
             'maskTextSelector': '*',
             'maskInputFn': this._getMaskFn(shouldMaskInput, privacyConfig),
             'maskTextFn': this._getMaskFn(shouldMaskText, privacyConfig),
+            'recordCrossOriginIframes': validatedOrigins.length > 0,
+            'allowedIframeOrigins': validatedOrigins,
             'recordCanvas': this.getConfig('record_canvas'),
             'sampling': {
                 'canvas': 15
             },
-            'plugins': this.getConfig('record_console') ? [
-                getRecordConsolePlugin({
-                    stringifyOptions: {
-                        stringLengthLimit: 1000,
-                        numOfKeysLimit: 50,
-                        depthOfLimit: 2
-                    }
-                })
-            ] : []
+            'plugins': plugins,
         });
     } catch (err) {
         this.reportError('Unexpected error when starting rrweb recording.', err);
@@ -23437,6 +24184,10 @@ SessionRecording.deserialize = function (serializedRecording, options) {
     return recording;
 };
 
+SessionRecording.prototype._getApiRoute = function () {
+    return this.getConfig('api_routes')['record'];
+};
+
 SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, reqBody, callback) {
     var onSuccess = function (response, responseBody) {
         // Update batch specific props only if the request was successful to guarantee ordering.
@@ -23456,7 +24207,7 @@ SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, r
         });
     }.bind(this);
     var apiHost = (this._mixpanel.get_api_host && this._mixpanel.get_api_host('record')) || this.getConfig('api_host');
-    win['fetch'](apiHost + '/' + this.getConfig('api_routes')['record'] + '?' + new URLSearchParams(reqParams), {
+    win['fetch'](apiHost + '/' + this._getApiRoute() + '?' + new URLSearchParams(reqParams), {
         'method': 'POST',
         'headers': {
             'Authorization': 'Basic ' + btoa(this.getConfig('token') + ':'),
@@ -23538,14 +24289,14 @@ SessionRecording.prototype._flushEvents = addOptOutCheckMixpanelLib(function (da
 
 
 SessionRecording.prototype.reportError = function(msg, err) {
-    logger$2.error.apply(logger$2.error, arguments);
+    logger$3.error.apply(logger$3.error, arguments);
     try {
         if (!err && !(msg instanceof Error)) {
             msg = new Error(msg);
         }
         this.getConfig('error_reporter')(msg, err);
     } catch(err) {
-        logger$2.error(err);
+        logger$3.error(err);
     }
 };
 
@@ -23574,7 +24325,7 @@ SessionRecording.prototype._getRecordMinMs = function() {
     var configValue = this.getConfig('record_min_ms');
 
     if (configValue > MAX_VALUE_FOR_MIN_RECORDING_MS) {
-        logger$2.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
+        logger$3.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
         return MAX_VALUE_FOR_MIN_RECORDING_MS;
     }
 
@@ -23737,7 +24488,7 @@ RecordingRegistry.prototype.flushInactiveRecordings = function () {
         .catch(this.handleError.bind(this));
 };
 
-var logger$1 = console_with_prefix('recorder');
+var logger$2 = console_with_prefix('recorder');
 
 /**
  * Recorder API: bundles rrweb and and exposes methods to start and stop recordings.
@@ -23753,7 +24504,7 @@ var MixpanelRecorder = function(mixpanelInstance, rrwebRecord, sharedLockStorage
      */
     this.recordingRegistry = new RecordingRegistry({
         mixpanelInstance: this.mixpanelInstance,
-        errorReporter: logger$1.error,
+        errorReporter: logger$2.error,
         sharedLockStorage: sharedLockStorage
     });
     this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
@@ -23765,17 +24516,17 @@ var MixpanelRecorder = function(mixpanelInstance, rrwebRecord, sharedLockStorage
 MixpanelRecorder.prototype.startRecording = function(options) {
     options = options || {};
     if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-        logger$1.log('Recording already in progress, skipping startRecording.');
+        logger$2.log('Recording already in progress, skipping startRecording.');
         return;
     }
 
     var onIdleTimeout = function () {
-        logger$1.log('Idle timeout reached, restarting recording.');
+        logger$2.log('Idle timeout reached, restarting recording.');
         this.resetRecording();
     }.bind(this);
 
     var onMaxLengthReached = function () {
-        logger$1.log('Max recording length reached, stopping recording.');
+        logger$2.log('Max recording length reached, stopping recording.');
         this.resetRecording();
     }.bind(this);
 
@@ -23845,7 +24596,7 @@ MixpanelRecorder.prototype.resumeRecording = function (startNewIfInactive) {
             } else if (startNewIfInactive) {
                 return this.startRecording({shouldStopBatcher: false});
             } else {
-                logger$1.log('No resumable recording found.');
+                logger$2.log('No resumable recording found.');
                 return null;
             }
         }.bind(this));
@@ -23857,8 +24608,12 @@ MixpanelRecorder.prototype.resetRecording = function () {
     this.startRecording({shouldStopBatcher: true});
 };
 
+MixpanelRecorder.prototype.isRecording = function () {
+    return this.activeRecording && !this.activeRecording.isRrwebStopped();
+};
+
 MixpanelRecorder.prototype.getActiveReplayId = function () {
-    if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
+    if (this.isRecording()) {
         return this.activeRecording.replayId;
     } else {
         return null;
@@ -24362,53 +25117,6 @@ function requireLogic () {
 var logicExports = requireLogic();
 var jsonLogic = /*@__PURE__*/getDefaultExportFromCjs(logicExports);
 
-/**
- * Shared helper to recursively lowercase strings in nested structures
- * @param {*} obj - Value to process
- * @param {boolean} lowercaseKeys - Whether to lowercase object keys
- * @returns {*} Processed value with lowercased strings
- */
-var lowercaseJson = function(obj, lowercaseKeys) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    } else if (typeof obj === 'string') {
-        return obj.toLowerCase();
-    } else if (Array.isArray(obj)) {
-        return obj.map(function(item) {
-            return lowercaseJson(item, lowercaseKeys);
-        });
-    } else if (obj === Object(obj)) {
-        var result = {};
-        for (var key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                var newKey = lowercaseKeys && typeof key === 'string' ? key.toLowerCase() : key;
-                result[newKey] = lowercaseJson(obj[key], lowercaseKeys);
-            }
-        }
-        return result;
-    } else {
-        return obj;
-    }
-};
-
-/**
- * Lowercase all string keys and values in a nested structure
- * @param {*} val - Value to process
- * @returns {*} Processed value with lowercased strings
- */
-var lowercaseKeysAndValues = function(val) {
-    return lowercaseJson(val, true);
-};
-
-/**
- * Lowercase only leaf node string values in a nested structure (keys unchanged)
- * @param {*} val - Value to process
- * @returns {*} Processed value with lowercased leaf strings
- */
-var lowercaseOnlyLeafNodes = function(val) {
-    return lowercaseJson(val, false);
-};
-
 /**
  * Check if an event matches the given criteria
  * @param {string} eventName - The name of the event being checked
@@ -24432,13 +25140,8 @@ var eventMatchesCriteria = function(eventName, properties, criteria) {
 
     if (propertyFilters && !_.isEmptyObject(propertyFilters)) {
         try {
-            // Lowercase all keys and values in event properties for case-insensitive matching
-            var lowercasedProperties = lowercaseKeysAndValues(properties || {});
-
-            // Lowercase only leaf nodes in JsonLogic filters (keep operators intact)
-            var lowercasedFilters = lowercaseOnlyLeafNodes(propertyFilters);
-
-            filtersMatch = jsonLogic.apply(lowercasedFilters, lowercasedProperties);
+            // Use properties as-is for case-sensitive matching
+            filtersMatch = jsonLogic.apply(propertyFilters, properties || {});
         } catch (error) {
             return {
                 matches: false,
@@ -24558,7 +25261,7 @@ ShadowDOMObserver.prototype.observeShadowRoot = function(shadowRoot) {
         observer.observe(shadowRoot, this.observerConfig);
         this.shadowObservers.push(observer);
     } catch (e) {
-        logger$3.critical('Error while observing shadow root', e);
+        logger$5.critical('Error while observing shadow root', e);
     }
 };
 
@@ -24569,7 +25272,7 @@ ShadowDOMObserver.prototype.start = function() {
     }
 
     if (!weakSetSupported()) {
-        logger$3.critical('Shadow DOM observation unavailable: WeakSet not supported');
+        logger$5.critical('Shadow DOM observation unavailable: WeakSet not supported');
         return;
     }
 
@@ -24585,7 +25288,7 @@ ShadowDOMObserver.prototype.stop = function() {
         try {
             this.shadowObservers[i].disconnect();
         } catch (e) {
-            logger$3.critical('Error while disconnecting shadow DOM observer', e);
+            logger$5.critical('Error while disconnecting shadow DOM observer', e);
         }
     }
     this.shadowObservers = [];
@@ -24773,7 +25476,7 @@ DeadClickTracker.prototype.startTracking = function() {
 
             this.mutationObserver.observe(document.body || document.documentElement, MUTATION_OBSERVER_CONFIG);
         } catch (e) {
-            logger$3.critical('Error while setting up mutation observer', e);
+            logger$5.critical('Error while setting up mutation observer', e);
         }
     }
 
@@ -24788,7 +25491,7 @@ DeadClickTracker.prototype.startTracking = function() {
             );
             this.shadowDOMObserver.start();
         } catch (e) {
-            logger$3.critical('Error while setting up shadow DOM observer', e);
+            logger$5.critical('Error while setting up shadow DOM observer', e);
             this.shadowDOMObserver = null;
         }
     }
@@ -24815,7 +25518,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             listener.target.removeEventListener(listener.event, listener.handler, listener.options);
         } catch (e) {
-            logger$3.critical('Error while removing event listener', e);
+            logger$5.critical('Error while removing event listener', e);
         }
     }
     this.eventListeners = [];
@@ -24824,7 +25527,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             this.mutationObserver.disconnect();
         } catch (e) {
-            logger$3.critical('Error while disconnecting mutation observer', e);
+            logger$5.critical('Error while disconnecting mutation observer', e);
         }
         this.mutationObserver = null;
     }
@@ -24833,7 +25536,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             this.shadowDOMObserver.stop();
         } catch (e) {
-            logger$3.critical('Error while stopping shadow DOM observer', e);
+            logger$5.critical('Error while stopping shadow DOM observer', e);
         }
         this.shadowDOMObserver = null;
     }
@@ -24911,7 +25614,7 @@ var Autocapture = function(mp) {
 
 Autocapture.prototype.init = function() {
     if (!minDOMApisSupported()) {
-        logger$3.critical('Autocapture unavailable: missing required DOM APIs');
+        logger$5.critical('Autocapture unavailable: missing required DOM APIs');
         return;
     }
     this.initPageListeners();
@@ -24943,27 +25646,15 @@ Autocapture.prototype.getConfig = function(key) {
 };
 
 Autocapture.prototype.currentUrlBlocked = function() {
-    var i;
     var currentUrl = _.info.currentUrl();
 
     var allowUrlRegexes = this.getConfig(CONFIG_ALLOW_URL_REGEXES) || [];
     if (allowUrlRegexes.length) {
         // we're using an allowlist, only track if current URL matches
-        var allowed = false;
-        for (i = 0; i < allowUrlRegexes.length; i++) {
-            var allowRegex = allowUrlRegexes[i];
-            try {
-                if (currentUrl.match(allowRegex)) {
-                    allowed = true;
-                    break;
-                }
-            } catch (err) {
-                logger$3.critical('Error while checking block URL regex: ' + allowRegex, err);
-                return true;
-            }
-        }
-        if (!allowed) {
-            // wasn't allowed by any regex
+        try {
+            return !urlMatchesRegexList(currentUrl, allowUrlRegexes);
+        } catch (err) {
+            logger$5.critical('Error while checking block URL regexes: ', err);
             return true;
         }
     }
@@ -24973,17 +25664,12 @@ Autocapture.prototype.currentUrlBlocked = function() {
         return false;
     }
 
-    for (i = 0; i < blockUrlRegexes.length; i++) {
-        try {
-            if (currentUrl.match(blockUrlRegexes[i])) {
-                return true;
-            }
-        } catch (err) {
-            logger$3.critical('Error while checking block URL regex: ' + blockUrlRegexes[i], err);
-            return true;
-        }
+    try {
+        return urlMatchesRegexList(currentUrl, blockUrlRegexes);
+    } catch (err) {
+        logger$5.critical('Error while checking block URL regexes: ', err);
+        return true;
     }
-    return false;
 };
 
 Autocapture.prototype.pageviewTrackingConfig = function() {
@@ -25119,7 +25805,7 @@ Autocapture.prototype._initScrollDepthTracking = function() {
         return;
     }
 
-    logger$3.log('Initializing scroll depth tracking');
+    logger$5.log('Initializing scroll depth tracking');
 
     this.maxScrollViewDepth = Math.max(document$1.documentElement.clientHeight, win.innerHeight || 0);
 
@@ -25145,7 +25831,7 @@ Autocapture.prototype.initClickTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.get_config('record_heatmap_data')) {
         return;
     }
-    logger$3.log('Initializing click tracking');
+    logger$5.log('Initializing click tracking');
 
     this.listenerClick = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.is_recording_heatmap_data()) {
@@ -25164,7 +25850,7 @@ Autocapture.prototype.initDeadClickTracking = function() {
         return;
     }
 
-    logger$3.log('Initializing dead click tracking');
+    logger$5.log('Initializing dead click tracking');
     if (!this._deadClickTracker) {
         this._deadClickTracker = new DeadClickTracker(function(deadClickEvent) {
             this.trackDomEvent(deadClickEvent, MP_EV_DEAD_CLICK);
@@ -25198,7 +25884,7 @@ Autocapture.prototype.initInputTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_INPUT)) {
         return;
     }
-    logger$3.log('Initializing input tracking');
+    logger$5.log('Initializing input tracking');
 
     this.listenerChange = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_INPUT)) {
@@ -25215,7 +25901,7 @@ Autocapture.prototype.initPageviewTracking = function() {
     if (!this.pageviewTrackingConfig()) {
         return;
     }
-    logger$3.log('Initializing pageview tracking');
+    logger$5.log('Initializing pageview tracking');
 
     var previousTrackedUrl = '';
     var tracked = false;
@@ -25250,7 +25936,7 @@ Autocapture.prototype.initPageviewTracking = function() {
             }
             if (didPathChange) {
                 this.lastScrollCheckpoint = 0;
-                logger$3.log('Path change: re-initializing scroll depth checkpoints');
+                logger$5.log('Path change: re-initializing scroll depth checkpoints');
             }
         }
     }.bind(this));
@@ -25265,7 +25951,7 @@ Autocapture.prototype.initRageClickTracking = function() {
         return;
     }
 
-    logger$3.log('Initializing rage click tracking');
+    logger$5.log('Initializing rage click tracking');
     if (!this._rageClickTracker) {
         this._rageClickTracker = new RageClickTracker();
     }
@@ -25295,7 +25981,7 @@ Autocapture.prototype.initScrollTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_SCROLL)) {
         return;
     }
-    logger$3.log('Initializing scroll tracking');
+    logger$5.log('Initializing scroll tracking');
     this.lastScrollCheckpoint = 0;
 
     var scrollTrackFunction = function() {
@@ -25332,7 +26018,7 @@ Autocapture.prototype.initScrollTracking = function() {
                 }
             }
         } catch (err) {
-            logger$3.critical('Error while calculating scroll percentage', err);
+            logger$5.critical('Error while calculating scroll percentage', err);
         }
         if (shouldTrack) {
             this.mp.track(MP_EV_SCROLL, props);
@@ -25350,7 +26036,7 @@ Autocapture.prototype.initSubmitTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
         return;
     }
-    logger$3.log('Initializing submit tracking');
+    logger$5.log('Initializing submit tracking');
 
     this.listenerSubmit = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
@@ -25372,7 +26058,7 @@ Autocapture.prototype.initPageLeaveTracking = function() {
         return;
     }
 
-    logger$3.log('Initializing page visibility tracking.');
+    logger$5.log('Initializing page visibility tracking.');
     this._initScrollDepthTracking();
     var previousTrackedUrl = _.info.currentUrl();
 
@@ -25457,7 +26143,7 @@ var getTargetingPromise = function(loadExtraBundle, targetingSrc) {
     return win[TARGETING_GLOBAL_NAME];
 };
 
-var logger = console_with_prefix('flags');
+var logger$1 = console_with_prefix('flags');
 var FLAGS_CONFIG_KEY = 'flags';
 
 var CONFIG_CONTEXT = 'context';
@@ -25500,7 +26186,7 @@ var FeatureFlagManager = function(initOptions) {
 
 FeatureFlagManager.prototype.init = function() {
     if (!this.minApisSupported()) {
-        logger.critical('Feature Flags unavailable: missing minimum required APIs');
+        logger$1.critical('Feature Flags unavailable: missing minimum required APIs');
         return;
     }
 
@@ -25535,7 +26221,7 @@ FeatureFlagManager.prototype.isSystemEnabled = function() {
 
 FeatureFlagManager.prototype.updateContext = function(newContext, options) {
     if (!this.isSystemEnabled()) {
-        logger.critical('Feature Flags not enabled, cannot update context');
+        logger$1.critical('Feature Flags not enabled, cannot update context');
         return Promise.resolve();
     }
 
@@ -25552,7 +26238,7 @@ FeatureFlagManager.prototype.updateContext = function(newContext, options) {
 
 FeatureFlagManager.prototype.areFlagsReady = function() {
     if (!this.isSystemEnabled()) {
-        logger.error('Feature Flags not enabled');
+        logger$1.error('Feature Flags not enabled');
     }
     return !!this.flags;
 };
@@ -25565,7 +26251,7 @@ FeatureFlagManager.prototype.fetchFlags = function() {
     var distinctId = this.getMpProperty('distinct_id');
     var deviceId = this.getMpProperty('$device_id');
     var traceparent = generateTraceparent();
-    logger.log('Fetching flags for distinct ID: ' + distinctId);
+    logger$1.log('Fetching flags for distinct ID: ' + distinctId);
 
     var context = _.extend({'distinct_id': distinctId, 'device_id': deviceId}, this.getConfig(CONFIG_CONTEXT));
     var searchParams = new URLSearchParams();
@@ -25664,11 +26350,11 @@ FeatureFlagManager.prototype.fetchFlags = function() {
             this._loadTargetingIfNeeded();
         }.bind(this)).catch(function(error) {
             this.markFetchComplete();
-            logger.error(error);
+            logger$1.error(error);
         }.bind(this));
     }.bind(this)).catch(function(error) {
         this.markFetchComplete();
-        logger.error(error);
+        logger$1.error(error);
     }.bind(this));
 
     return this.fetchPromise;
@@ -25676,7 +26362,7 @@ FeatureFlagManager.prototype.fetchFlags = function() {
 
 FeatureFlagManager.prototype.markFetchComplete = function() {
     if (!this._fetchInProgressStartTime) {
-        logger.error('Fetch in progress started time not set, cannot mark fetch complete');
+        logger$1.error('Fetch in progress started time not set, cannot mark fetch complete');
         return;
     }
     this._fetchStartTime = this._fetchInProgressStartTime;
@@ -25698,7 +26384,7 @@ FeatureFlagManager.prototype._loadTargetingIfNeeded = function() {
 
     if (hasPropertyFilters) {
         this.getTargeting().then(function() {
-            logger.log('targeting loaded for property filter evaluation');
+            logger$1.log('targeting loaded for property filter evaluation');
         });
     }
 };
@@ -25713,7 +26399,7 @@ FeatureFlagManager.prototype.getTargeting = function() {
         this.loadExtraBundle.bind(this),
         this.targetingSrc
     ).catch(function(error) {
-        logger.error('Failed to load targeting: ' + error);
+        logger$1.error('Failed to load targeting: ' + error);
     }.bind(this));
 };
 
@@ -25767,7 +26453,7 @@ FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, p
 
         // If no targeting library and event has property filters, skip it
         if (!targeting && pendingEvent['property_filters'] && !_.isEmptyObject(pendingEvent['property_filters'])) {
-            logger.warn('Skipping event check for "' + flagKey + '" - property filters require targeting library');
+            logger$1.warn('Skipping event check for "' + flagKey + '" - property filters require targeting library');
             return;
         }
 
@@ -25790,7 +26476,7 @@ FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, p
         }
 
         if (matchResult.error) {
-            logger.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
+            logger$1.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
             return;
         }
 
@@ -25798,7 +26484,7 @@ FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, p
             return;
         }
 
-        logger.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
+        logger$1.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
 
         var newVariant = {
             'key': pendingEvent['pending_variant']['variant_key'],
@@ -25839,7 +26525,7 @@ FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId,
         'first_time_event_hash': firstTimeEventHash
     };
 
-    logger.log('Recording first-time event for flag: ' + flagId);
+    logger$1.log('Recording first-time event for flag: ' + flagId);
 
     // Fire-and-forget POST request
     this.fetch.call(win, url, {
@@ -25852,130 +26538,446 @@ FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId,
         'body': JSON.stringify(payload)
     }).catch(function(error) {
         // Silent failure - cohort sync will catch up
-        logger.error('Failed to record first-time event for flag ' + flagId + ': ' + error);
+        logger$1.error('Failed to record first-time event for flag ' + flagId + ': ' + error);
+    });
+};
+
+FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
+    if (!this.fetchPromise) {
+        return new Promise(function(resolve) {
+            logger$1.critical('Feature Flags not initialized');
+            resolve(fallback);
+        });
+    }
+
+    return this.fetchPromise.then(function() {
+        return this.getVariantSync(featureName, fallback);
+    }.bind(this)).catch(function(error) {
+        logger$1.error(error);
+        return fallback;
+    });
+};
+
+FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
+    if (!this.areFlagsReady()) {
+        logger$1.log('Flags not loaded yet');
+        return fallback;
+    }
+    var feature = this.flags.get(featureName);
+    if (!feature) {
+        logger$1.log('No flag found: "' + featureName + '"');
+        return fallback;
+    }
+    this.trackFeatureCheck(featureName, feature);
+    return feature;
+};
+
+FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
+    return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
+        return feature['value'];
+    }).catch(function(error) {
+        logger$1.error(error);
+        return fallbackValue;
+    });
+};
+
+// TODO remove deprecated method
+FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
+    logger$1.critical('mixpanel.flags.get_feature_data() is deprecated and will be removed in a future release. Use mixpanel.flags.get_variant_value() instead.');
+    return this.getVariantValue(featureName, fallbackValue);
+};
+
+FeatureFlagManager.prototype.getVariantValueSync = function(featureName, fallbackValue) {
+    return this.getVariantSync(featureName, {'value': fallbackValue})['value'];
+};
+
+FeatureFlagManager.prototype.isEnabled = function(featureName, fallbackValue) {
+    return this.getVariantValue(featureName).then(function() {
+        return this.isEnabledSync(featureName, fallbackValue);
+    }.bind(this)).catch(function(error) {
+        logger$1.error(error);
+        return fallbackValue;
     });
 };
 
-FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
-    if (!this.fetchPromise) {
-        return new Promise(function(resolve) {
-            logger.critical('Feature Flags not initialized');
-            resolve(fallback);
-        });
+FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue) {
+    fallbackValue = fallbackValue || false;
+    var val = this.getVariantValueSync(featureName, fallbackValue);
+    if (val !== true && val !== false) {
+        logger$1.error('Feature flag "' + featureName + '" value: ' + val + ' is not a boolean; returning fallback value: ' + fallbackValue);
+        val = fallbackValue;
+    }
+    return val;
+};
+
+FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
+    if (this.trackedFeatures.has(featureName)) {
+        return;
+    }
+    this.trackedFeatures.add(featureName);
+
+    var trackingProperties = {
+        'Experiment name': featureName,
+        'Variant name': feature['key'],
+        '$experiment_type': 'feature_flag',
+        'Variant fetch start time': new Date(this._fetchStartTime).toISOString(),
+        'Variant fetch complete time': new Date(this._fetchCompleteTime).toISOString(),
+        'Variant fetch latency (ms)': this._fetchLatency,
+        'Variant fetch traceparent': this._traceparent,
+    };
+
+    if (feature['experiment_id'] !== 'undefined') {
+        trackingProperties['$experiment_id'] = feature['experiment_id'];
+    }
+    if (feature['is_experiment_active'] !== 'undefined') {
+        trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
+    }
+    if (feature['is_qa_tester'] !== 'undefined') {
+        trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
+    }
+
+    this.track('$experiment_started', trackingProperties);
+};
+
+FeatureFlagManager.prototype.minApisSupported = function() {
+    return !!this.fetch &&
+      typeof Promise !== 'undefined' &&
+      typeof Map !== 'undefined' &&
+      typeof Set !== 'undefined';
+};
+
+safewrapClass(FeatureFlagManager);
+
+FeatureFlagManager.prototype['are_flags_ready'] = FeatureFlagManager.prototype.areFlagsReady;
+FeatureFlagManager.prototype['get_variant'] = FeatureFlagManager.prototype.getVariant;
+FeatureFlagManager.prototype['get_variant_sync'] = FeatureFlagManager.prototype.getVariantSync;
+FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype.getVariantValue;
+FeatureFlagManager.prototype['get_variant_value_sync'] = FeatureFlagManager.prototype.getVariantValueSync;
+FeatureFlagManager.prototype['is_enabled'] = FeatureFlagManager.prototype.isEnabled;
+FeatureFlagManager.prototype['is_enabled_sync'] = FeatureFlagManager.prototype.isEnabledSync;
+FeatureFlagManager.prototype['update_context'] = FeatureFlagManager.prototype.updateContext;
+
+// Deprecated method
+FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
+
+// Exports intended only for testing
+FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+
+/* eslint camelcase: "off" */
+
+
+var logger = console_with_prefix('recorder');
+
+var IFRAME_HANDSHAKE_REQUEST  = 'mp_iframe_handshake_request';
+var IFRAME_HANDSHAKE_RESPONSE = 'mp_iframe_handshake_response';
+
+
+/**
+ * RecorderManager: manages session recording initialization, lifecycle and state
+ * @constructor
+ */
+var RecorderManager = function(initOptions) {
+    // TODO - Passing in mixpanel instance as it is still needed for recorder creation
+    // but ideally we should be able to remove this dependency.
+    this.mixpanelInstance = initOptions.mixpanelInstance;
+
+    this.getMpConfig = initOptions.getConfigFunc;
+    this.getTabId = initOptions.getTabIdFunc;
+    this.reportError = initOptions.reportErrorFunc;
+    this.getDistinctId = initOptions.getDistinctIdFunc;
+    this.loadExtraBundle = initOptions.loadExtraBundle;
+    this.recorderSrc = initOptions.recorderSrc;
+    this.targetingSrc = initOptions.targetingSrc;
+    this.libBasePath = initOptions.libBasePath;
+
+    this._recorder = null;
+    this._parentReplayId = null;
+    this._parentFrameRetryInterval = null;
+};
+
+RecorderManager.prototype.shouldLoadRecorder = function() {
+    if (this.getMpConfig('disable_persistence')) {
+        console$1.log('Load recorder check skipped due to disable_persistence config');
+        return PromisePolyfill.resolve(false);
+    }
+
+    var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+    var tab_id = this.getTabId();
+    return recording_registry_idb.init()
+        .then(function () {
+            return recording_registry_idb.getAll();
+        })
+        .then(function (recordings) {
+            for (var i = 0; i < recordings.length; i++) {
+                // if there are expired recordings in the registry, we should load the recorder to flush them
+                // if there's a recording for this tab id, we should load the recorder to continue the recording
+                if (isRecordingExpired(recordings[i]) || recordings[i]['tabId'] === tab_id) {
+                    return true;
+                }
+            }
+            return false;
+        })
+        .catch(_.bind(function (err) {
+            this.reportError('Error checking recording registry', err);
+            return false;
+        }, this));
+};
+
+RecorderManager.prototype.checkAndStartSessionRecording = function(force_start, rate) {
+    if (!win['MutationObserver']) {
+        console$1.critical('Browser does not support MutationObserver; skipping session recording');
+        return PromisePolyfill.resolve();
+    }
+
+    var loadRecorder = _.bind(function(startNewIfInactive) {
+        return new PromisePolyfill(_.bind(function(resolve) {
+            var handleLoadedRecorder = safewrap(_.bind(function() {
+                this._recorder = this._recorder || new win[RECORDER_GLOBAL_NAME](this.mixpanelInstance);
+                this._recorder['resumeRecording'](startNewIfInactive);
+                resolve();
+            }, this));
+
+            if (_.isUndefined(win[RECORDER_GLOBAL_NAME])) {
+                var recorderSrc = this.recorderSrc || (this.libBasePath + RECORDER_FILENAME);
+                this.loadExtraBundle(recorderSrc, handleLoadedRecorder);
+            } else {
+                handleLoadedRecorder();
+            }
+        }, this));
+    }, this);
+
+    // Cross-origin iframe handling
+    var allowedOrigins = validateAllowedOrigins(this.getMpConfig('record_allowed_iframe_origins'), logger);
+    var isCrossOriginRecordingEnabled = allowedOrigins.length > 0;
+
+    if (isCrossOriginRecordingEnabled) {
+        // listen for handshake requests from their own child iframes (including nested)
+        this._setupParentFrameListener(allowedOrigins);
+
+        if (win.parent !== win) {
+            // also wait for parent's replay ID
+            this._setupChildFrameListener(allowedOrigins, loadRecorder);
+            this._sendParentFrameRequestWithRetry(allowedOrigins);
+            return PromisePolyfill.resolve();
+        }
+    }
+
+    /**
+     * If the user is sampled or start_session_recording is called, we always load the recorder since it's guaranteed a recording should start.
+     * Otherwise, if the recording registry has any records then it's likely there's a recording in progress or orphaned data that needs to be flushed.
+     */
+    var effective_rate = _.isUndefined(rate) ? this.getMpConfig('record_sessions_percent') : rate;
+    var is_sampled = effective_rate > 0 && Math.random() * 100 <= effective_rate;
+    if (force_start || is_sampled) {
+        return loadRecorder(true);
+    } else {
+        return this.shouldLoadRecorder()
+            .then(_.bind(function (shouldLoad) {
+                if (shouldLoad) {
+                    return loadRecorder(false);
+                }
+                return PromisePolyfill.resolve();
+            }, this));
+    }
+};
+
+RecorderManager.prototype.isRecording = function() {
+    // Safety check: ensure isRecording method exists (older CDN builds may not have it)
+    if (!this._recorder || !_.isFunction(this._recorder['isRecording'])) {
+        return false;
+    }
+    try {
+        return this._recorder['isRecording']();
+    } catch (e) {
+        this.reportError('Error checking if recording is active', e);
+        return false;
     }
+};
 
-    return this.fetchPromise.then(function() {
-        return this.getVariantSync(featureName, fallback);
-    }.bind(this)).catch(function(error) {
-        logger.error(error);
-        return fallback;
-    });
+RecorderManager.prototype.startRecordingOnEvent = function(event_name, properties) {
+    var isRecording = this.isRecording();
+    var recordingTriggerEvents = this.getMpConfig('recording_event_triggers');
+
+    if (!isRecording && recordingTriggerEvents) {
+        var trigger = recordingTriggerEvents[event_name];
+        if (trigger && typeof trigger['percentage'] === 'number') {
+            var newRate = trigger['percentage'];
+            var propertyFilters = trigger['property_filters'];
+            if (propertyFilters && !_.isEmptyObject(propertyFilters)) {
+                var targetingSrc = this.targetingSrc || (this.libBasePath + TARGETING_FILENAME);
+                getTargetingPromise(this.loadExtraBundle, targetingSrc)
+                    .then(function(targeting) {
+                        try {
+                            var result = targeting['eventMatchesCriteria'](
+                                event_name,
+                                properties,
+                                {
+                                    'event_name': event_name,
+                                    'property_filters': propertyFilters
+                                }
+                            );
+                            if (result['matches']) {
+                                this.checkAndStartSessionRecording(false, newRate);
+                            }
+                        } catch (err) {
+                            console$1.critical('Could not parse recording event trigger properties logic:', err);
+                        }
+                    }.bind(this)).catch(function(err) {
+                        console$1.critical('Failed to load targeting library:', err);
+                    });
+            } else {
+                this.checkAndStartSessionRecording(false, newRate);
+            }
+        }
+    }
 };
 
-FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
-    if (!this.areFlagsReady()) {
-        logger.log('Flags not loaded yet');
-        return fallback;
+RecorderManager.prototype.stopSessionRecording = function() {
+    if (this._recorder) {
+        return this._recorder['stopRecording']();
     }
-    var feature = this.flags.get(featureName);
-    if (!feature) {
-        logger.log('No flag found: "' + featureName + '"');
-        return fallback;
+    return PromisePolyfill.resolve();
+};
+
+RecorderManager.prototype.pauseSessionRecording = function() {
+    if (this._recorder) {
+        return this._recorder['pauseRecording']();
     }
-    this.trackFeatureCheck(featureName, feature);
-    return feature;
+    return PromisePolyfill.resolve();
 };
 
-FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
-    return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
-        return feature['value'];
-    }).catch(function(error) {
-        logger.error(error);
-        return fallbackValue;
-    });
+RecorderManager.prototype.resumeSessionRecording = function() {
+    if (this._recorder) {
+        return this._recorder['resumeRecording']();
+    }
+    return PromisePolyfill.resolve();
 };
 
-// TODO remove deprecated method
-FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
-    logger.critical('mixpanel.flags.get_feature_data() is deprecated and will be removed in a future release. Use mixpanel.flags.get_variant_value() instead.');
-    return this.getVariantValue(featureName, fallbackValue);
+RecorderManager.prototype.isRecordingHeatmapData = function() {
+    return this.getSessionReplayId() && this.getMpConfig('record_heatmap_data');
 };
 
-FeatureFlagManager.prototype.getVariantValueSync = function(featureName, fallbackValue) {
-    return this.getVariantSync(featureName, {'value': fallbackValue})['value'];
+RecorderManager.prototype.getSessionRecordingProperties = function() {
+    var props = {};
+    var replay_id = this.getSessionReplayId();
+    if (replay_id) {
+        props['$mp_replay_id'] = replay_id;
+    }
+    return props;
 };
 
-FeatureFlagManager.prototype.isEnabled = function(featureName, fallbackValue) {
-    return this.getVariantValue(featureName).then(function() {
-        return this.isEnabledSync(featureName, fallbackValue);
-    }.bind(this)).catch(function(error) {
-        logger.error(error);
-        return fallbackValue;
-    });
+RecorderManager.prototype.getSessionReplayUrl = function() {
+    var replay_url = null;
+    var replay_id = this.getSessionReplayId();
+    if (replay_id) {
+        var query_params = _.HTTPBuildQuery({
+            'replay_id': replay_id,
+            'distinct_id': this.getDistinctId(),
+            'token': this.getMpConfig('token')
+        });
+        replay_url = 'https://mixpanel.com/projects/replay-redirect?' + query_params;
+    }
+    return replay_url;
 };
 
-FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue) {
-    fallbackValue = fallbackValue || false;
-    var val = this.getVariantValueSync(featureName, fallbackValue);
-    if (val !== true && val !== false) {
-        logger.error('Feature flag "' + featureName + '" value: ' + val + ' is not a boolean; returning fallback value: ' + fallbackValue);
-        val = fallbackValue;
+RecorderManager.prototype.getSessionReplayId = function() {
+    // Child iframe uses parent's replay ID
+    if (this._parentReplayId) {
+        return this._parentReplayId;
     }
-    return val;
+    var replay_id = null;
+    if (this._recorder) {
+        replay_id = this._recorder['replayId'];
+    }
+    return replay_id || null;
 };
 
-FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
-    if (this.trackedFeatures.has(featureName)) {
+// "private" public method to reach into the recorder in test cases
+RecorderManager.prototype.getRecorder = function() {
+    return this._recorder;
+};
+
+RecorderManager.prototype._setupChildFrameListener = function(allowedOrigins, loadRecorder) {
+    if (this._childFrameMessageHandler) {
         return;
     }
-    this.trackedFeatures.add(featureName);
-
-    var trackingProperties = {
-        'Experiment name': featureName,
-        'Variant name': feature['key'],
-        '$experiment_type': 'feature_flag',
-        'Variant fetch start time': new Date(this._fetchStartTime).toISOString(),
-        'Variant fetch complete time': new Date(this._fetchCompleteTime).toISOString(),
-        'Variant fetch latency (ms)': this._fetchLatency,
-        'Variant fetch traceparent': this._traceparent,
+    var self = this;
+    this._childFrameMessageHandler = function(event) {
+        if (allowedOrigins.indexOf(event.origin) === -1) return;
+        var data = event.data;
+        if (data && data['type'] === IFRAME_HANDSHAKE_RESPONSE && data['token'] === self.getMpConfig('token') && data['replayId']) {
+            self._parentReplayId = data['replayId'];
+            if (data['distinctId']) {
+                self.mixpanelInstance['identify'](data['distinctId']);
+            }
+            self._parentFrameRetryActive = false;
+            win.removeEventListener('message', self._childFrameMessageHandler);
+            self._childFrameMessageHandler = null;
+            loadRecorder(true);
+        }
     };
+    win.addEventListener('message', this._childFrameMessageHandler);
+};
 
-    if (feature['experiment_id'] !== 'undefined') {
-        trackingProperties['$experiment_id'] = feature['experiment_id'];
-    }
-    if (feature['is_experiment_active'] !== 'undefined') {
-        trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
-    }
-    if (feature['is_qa_tester'] !== 'undefined') {
-        trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
+RecorderManager.prototype._sendParentFrameRequest = function(allowedOrigins) {
+    var message = {};
+    message['type'] = IFRAME_HANDSHAKE_REQUEST;
+    message['token'] = this.getMpConfig('token');
+    for (var i = 0; i < allowedOrigins.length; i++) {
+        try {
+            win.parent.postMessage(message, allowedOrigins[i]);
+        } catch (e) {
+            // origin mismatch - ignore
+        }
     }
-
-    this.track('$experiment_started', trackingProperties);
 };
 
-FeatureFlagManager.prototype.minApisSupported = function() {
-    return !!this.fetch &&
-      typeof Promise !== 'undefined' &&
-      typeof Map !== 'undefined' &&
-      typeof Set !== 'undefined';
-};
+RecorderManager.prototype._sendParentFrameRequestWithRetry = function(allowedOrigins) {
+    var self = this;
+    var maxRetries = 10;
+    var retryCount = 0;
+    var delay = 50;
+    this._parentFrameRetryActive = true;
 
-safewrapClass(FeatureFlagManager);
+    this._sendParentFrameRequest(allowedOrigins);
 
-FeatureFlagManager.prototype['are_flags_ready'] = FeatureFlagManager.prototype.areFlagsReady;
-FeatureFlagManager.prototype['get_variant'] = FeatureFlagManager.prototype.getVariant;
-FeatureFlagManager.prototype['get_variant_sync'] = FeatureFlagManager.prototype.getVariantSync;
-FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype.getVariantValue;
-FeatureFlagManager.prototype['get_variant_value_sync'] = FeatureFlagManager.prototype.getVariantValueSync;
-FeatureFlagManager.prototype['is_enabled'] = FeatureFlagManager.prototype.isEnabled;
-FeatureFlagManager.prototype['is_enabled_sync'] = FeatureFlagManager.prototype.isEnabledSync;
-FeatureFlagManager.prototype['update_context'] = FeatureFlagManager.prototype.updateContext;
+    function scheduleRetry() {
+        setTimeout(function() {
+            if (!self._parentFrameRetryActive || self._parentReplayId || ++retryCount >= maxRetries) {
+                return;
+            }
+            self._sendParentFrameRequest(allowedOrigins);
+            delay *= 2;
+            scheduleRetry();
+        }, delay);
+    }
+    scheduleRetry();
+};
 
-// Deprecated method
-FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
+RecorderManager.prototype._setupParentFrameListener = function(allowedOrigins) {
+    if (this._parentFrameMessageHandler) {
+        return;
+    }
+    var self = this;
+    this._parentFrameMessageHandler = function(event) {
+        if (allowedOrigins.indexOf(event.origin) === -1) return;
+        var data = event.data;
+        if (data && data['type'] === IFRAME_HANDSHAKE_REQUEST && data['token'] === self.getMpConfig('token')) {
+            var replayId = self.getSessionReplayId();
+            if (replayId) {
+                var response = {};
+                response['type'] = IFRAME_HANDSHAKE_RESPONSE;
+                response['token'] = self.getMpConfig('token');
+                response['replayId'] = replayId;
+                response['distinctId'] = self.getDistinctId();
+                event.source.postMessage(response, event.origin);
+            }
+        }
+    };
+    win.addEventListener('message', this._parentFrameMessageHandler);
+};
 
-// Exports intended only for testing
-FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+safewrapClass(RecorderManager);
 
 /* eslint camelcase: "off" */
 
@@ -27349,7 +28351,6 @@ var INIT_SNIPPET = 1;
 /** @const */ var SETTING_FALLBACK      = 'fallback';
 /** @const */ var SETTING_DISABLED      = 'disabled';
 
-
 /*
  * Dynamic... constants? Is that an oxymoron?
  */
@@ -27434,19 +28435,24 @@ var DEFAULT_CONFIG = {
     'batch_request_timeout_ms':          90000,
     'batch_autostart':                   true,
     'hooks':                             {},
+    'record_allowed_iframe_origins':     [],
     'record_block_class':                new RegExp('^(mp-block|fs-exclude|amp-block|rr-block|ph-no-capture)$'),
     'record_block_selector':             'img, video, audio',
     'record_canvas':                     false,
     'record_collect_fonts':              false,
     'record_console':                    true,
     'record_heatmap_data':               false,
+    'recording_event_triggers':          {},
     'record_idle_timeout_ms':            30 * 60 * 1000, // 30 minutes
     'record_mask_inputs':                true,
     'record_max_ms':                     MAX_RECORDING_MS,
     'record_min_ms':                     0,
+    'record_network':                    false,
+    'record_network_options':            {},
     'record_sessions_percent':           0,
-    'recorder_src':                      'https://cdn.mxpnl.com/libs/mixpanel-recorder.min.js',
-    'targeting_src':                     'https://cdn.mxpnl.com/libs/mixpanel-targeting.min.js',
+    'recorder_src':                      null,
+    'targeting_src':                     null,
+    'lib_base_path':                     'https://cdn.mxpnl.com/libs/',
     'remote_settings_mode':              SETTING_DISABLED // 'strict', 'fallback', 'disabled'
 };
 
@@ -27600,6 +28606,19 @@ MixpanelLib.prototype._init = function(token, config, name) {
         'callback_fn': ((name === PRIMARY_INSTANCE_NAME) ? name : PRIMARY_INSTANCE_NAME + '.' + name) + '._jsc'
     }));
 
+    this.recorderManager = new RecorderManager({
+        mixpanelInstance: this,
+        getConfigFunc: _.bind(this.get_config, this),
+        setConfigFunc: _.bind(this.set_config, this),
+        getTabIdFunc: _.bind(this.get_tab_id, this),
+        reportErrorFunc: _.bind(this.report_error, this),
+        getDistinctIdFunc: _.bind(this.get_distinct_id, this),
+        recorderSrc: this.get_config('recorder_src'),
+        targetingSrc: this.get_config('targeting_src'),
+        libBasePath: this.get_config('lib_base_path'),
+        loadExtraBundle: load_extra_bundle
+    });
+
     this['_jsc'] = NOOP_FUNC;
 
     this.__dom_loaded_queue = [];
@@ -27678,7 +28697,7 @@ MixpanelLib.prototype._init = function(token, config, name) {
         getPropertyFunc: _.bind(this.get_property, this),
         trackingFunc: _.bind(this.track, this),
         loadExtraBundle: load_extra_bundle,
-        targetingSrc: this.get_config('targeting_src')
+        targetingSrc: this.get_config('targeting_src') || (this.get_config('lib_base_path') + TARGETING_FILENAME)
     });
     this.flags.init();
     this['flags'] = this.flags;
@@ -27691,11 +28710,11 @@ MixpanelLib.prototype._init = function(token, config, name) {
     // Based on remote_settings_mode, fetch remote settings and then start session recording if applicable
     var mode = this.get_config('remote_settings_mode');
     if (mode === SETTING_STRICT || mode === SETTING_FALLBACK) {
-        this._fetch_remote_settings(mode).then(_.bind(function() {
-            this._check_and_start_session_recording();
+        this.__session_recording_init_promise = this._fetch_remote_settings(mode).then(_.bind(function() {
+            return this._check_and_start_session_recording();
         }, this));
     } else {
-        this._check_and_start_session_recording();
+        this.__session_recording_init_promise = this._check_and_start_session_recording();
     }
 };
 
@@ -27739,132 +28758,50 @@ MixpanelLib.prototype.get_tab_id = function () {
     return this.tab_id || null;
 };
 
-MixpanelLib.prototype._should_load_recorder = function () {
-    if (this.get_config('disable_persistence')) {
-        console$1.log('Load recorder check skipped due to disable_persistence config');
-        return Promise.resolve(false);
-    }
-
-    var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
-    var tab_id = this.get_tab_id();
-    return recording_registry_idb.init()
-        .then(function () {
-            return recording_registry_idb.getAll();
-        })
-        .then(function (recordings) {
-            for (var i = 0; i < recordings.length; i++) {
-                // if there are expired recordings in the registry, we should load the recorder to flush them
-                // if there's a recording for this tab id, we should load the recorder to continue the recording
-                if (isRecordingExpired(recordings[i]) || recordings[i]['tabId'] === tab_id) {
-                    return true;
-                }
-            }
-            return false;
-        })
-        .catch(_.bind(function (err) {
-            this.report_error('Error checking recording registry', err);
-        }, this));
-};
-
 MixpanelLib.prototype._check_and_start_session_recording = addOptOutCheckMixpanelLib(function(force_start) {
-    if (!win['MutationObserver']) {
-        console$1.critical('Browser does not support MutationObserver; skipping session recording');
-        return;
-    }
-
-    var loadRecorder = _.bind(function(startNewIfInactive) {
-        var handleLoadedRecorder = _.bind(function() {
-            this._recorder = this._recorder || new win[RECORDER_GLOBAL_NAME](this);
-            this._recorder['resumeRecording'](startNewIfInactive);
-        }, this);
-
-        if (_.isUndefined(win[RECORDER_GLOBAL_NAME])) {
-            load_extra_bundle(this.get_config('recorder_src'), handleLoadedRecorder);
-        } else {
-            handleLoadedRecorder();
-        }
-    }, this);
-
-    /**
-     * If the user is sampled or start_session_recording is called, we always load the recorder since it's guaranteed a recording should start.
-     * Otherwise, if the recording registry has any records then it's likely there's a recording in progress or orphaned data that needs to be flushed.
-     */
-    var is_sampled = this.get_config('record_sessions_percent') > 0 && Math.random() * 100 <= this.get_config('record_sessions_percent');
-    if (force_start || is_sampled) {
-        loadRecorder(true);
-    } else {
-        this._should_load_recorder()
-            .then(function (shouldLoad) {
-                if (shouldLoad) {
-                    loadRecorder(false);
-                }
-            });
-    }
+    return this.recorderManager.checkAndStartSessionRecording(force_start);
 });
 
+MixpanelLib.prototype._start_recording_on_event = function(event_name, properties) {
+    return this.recorderManager.startRecordingOnEvent(event_name, properties);
+};
+
 MixpanelLib.prototype.start_session_recording = function () {
-    this._check_and_start_session_recording(true);
+    return this._check_and_start_session_recording(true);
 };
 
 MixpanelLib.prototype.stop_session_recording = function () {
-    if (this._recorder) {
-        return this._recorder['stopRecording']();
-    }
-    return Promise.resolve();
+    return this.recorderManager.stopSessionRecording();
 };
 
 MixpanelLib.prototype.pause_session_recording = function () {
-    if (this._recorder) {
-        return this._recorder['pauseRecording']();
-    }
-    return Promise.resolve();
+    return this.recorderManager.pauseSessionRecording();
 };
 
 MixpanelLib.prototype.resume_session_recording = function () {
-    if (this._recorder) {
-        return this._recorder['resumeRecording']();
-    }
-    return Promise.resolve();
+    return this.recorderManager.resumeSessionRecording();
 };
 
 MixpanelLib.prototype.is_recording_heatmap_data = function () {
-    return this._get_session_replay_id() && this.get_config('record_heatmap_data');
+    return this.recorderManager.isRecordingHeatmapData();
 };
 
 MixpanelLib.prototype.get_session_recording_properties = function () {
-    var props = {};
-    var replay_id = this._get_session_replay_id();
-    if (replay_id) {
-        props['$mp_replay_id'] = replay_id;
-    }
-    return props;
+    return this.recorderManager.getSessionRecordingProperties();
 };
 
 MixpanelLib.prototype.get_session_replay_url = function () {
-    var replay_url = null;
-    var replay_id = this._get_session_replay_id();
-    if (replay_id) {
-        var query_params = _.HTTPBuildQuery({
-            'replay_id': replay_id,
-            'distinct_id': this.get_distinct_id(),
-            'token': this.get_config('token')
-        });
-        replay_url = 'https://mixpanel.com/projects/replay-redirect?' + query_params;
-    }
-    return replay_url;
-};
-
-MixpanelLib.prototype._get_session_replay_id = function () {
-    var replay_id = null;
-    if (this._recorder) {
-        replay_id = this._recorder['replayId'];
-    }
-    return replay_id || null;
+    return this.recorderManager.getSessionReplayUrl();
 };
 
 // "private" public method to reach into the recorder in test cases
 MixpanelLib.prototype.__get_recorder = function () {
-    return this._recorder;
+    return this.recorderManager.getRecorder();
+};
+
+// "private" public method to get session recording init promise in test cases
+MixpanelLib.prototype.__get_recording_init_promise = function () {
+    return this.__session_recording_init_promise;
 };
 
 // Private methods
@@ -28122,6 +29059,7 @@ MixpanelLib.prototype._send_request = function(url, data, options, callback) {
 };
 
 MixpanelLib.prototype._fetch_remote_settings = function(mode) {
+    var self = this;
     var disableRecordingIfStrict = function() {
         if (mode === 'strict') {
             self.set_config({'record_sessions_percent': 0});
@@ -28142,7 +29080,6 @@ MixpanelLib.prototype._fetch_remote_settings = function(mode) {
     };
     var query_string = _.HTTPBuildQuery(request_params);
     var full_url = settings_endpoint + '?' + query_string;
-    var self = this;
 
     var abortController = new AbortController();
     var timeout_id = setTimeout(function() {
@@ -28334,6 +29271,34 @@ MixpanelLib.prototype.push = function(item) {
     this._execute_array([item]);
 };
 
+/**
+ * Enables events on the Mixpanel object. If passed no arguments,
+ * this function enable tracking of all events. If passed an
+ * array of event names, those events will be enabled, but other
+ * existing disabled events will continue to be not tracked.
+ *
+ * @param {Array} [events] An array of event names to enable
+ */
+MixpanelLib.prototype.enable = function(events) {
+    var keys, new_disabled_events, i, j;
+
+    if (typeof(events) === 'undefined') {
+        this._flags.disable_all_events = false;
+    } else {
+        keys = {};
+        new_disabled_events = [];
+        for (i = 0; i < events.length; i++) {
+            keys[events[i]] = true;
+        }
+        for (j = 0; j < this.__disabled_events.length; j++) {
+            if (!keys[this.__disabled_events[j]]) {
+                new_disabled_events.push(this.__disabled_events[j]);
+            }
+        }
+        this.__disabled_events = new_disabled_events;
+    }
+};
+
 /**
  * Disable events on the Mixpanel object. If passed no arguments,
  * this function disables tracking of any event. If passed an
@@ -28507,6 +29472,8 @@ MixpanelLib.prototype.track = addOptOutCheckMixpanelLib(function(event_name, pro
         this.report_error('Invalid value for property_blacklist config: ' + property_blacklist);
     }
 
+    this._start_recording_on_event(event_name, properties);
+
     var data = {
         'event': event_name,
         'properties': properties
@@ -29715,6 +30682,7 @@ MixpanelLib.prototype.remove_hook = function(hook_name, hook_fn) {
 // MixpanelLib Exports
 MixpanelLib.prototype['init']                               = MixpanelLib.prototype.init;
 MixpanelLib.prototype['reset']                              = MixpanelLib.prototype.reset;
+MixpanelLib.prototype['enable']                             = MixpanelLib.prototype.enable;
 MixpanelLib.prototype['disable']                            = MixpanelLib.prototype.disable;
 MixpanelLib.prototype['time_event']                         = MixpanelLib.prototype.time_event;
 MixpanelLib.prototype['track']                              = MixpanelLib.prototype.track;
@@ -29758,6 +30726,7 @@ MixpanelLib.prototype['DEFAULT_API_ROUTES']                 = DEFAULT_API_ROUTES
 
 // Exports intended only for testing
 MixpanelLib.prototype['__get_recorder']                     = MixpanelLib.prototype.__get_recorder;
+MixpanelLib.prototype['__get_recording_init_promise']       = MixpanelLib.prototype.__get_recording_init_promise;
 
 // MixpanelPersistence Exports
 MixpanelPersistence.prototype['properties']            = MixpanelPersistence.prototype.properties;