mixpanel-browser 2.77.0 → 2.79.0

package/dist/mixpanel.module.js

@@ -25,7 +25,7 @@ if (typeof(window) === 'undefined') {
 
 var Config = {
     DEBUG: false,
-    LIB_VERSION: '2.77.0'
+    LIB_VERSION: '2.79.0'
 };
 
 // Window global names for async modules
@@ -19123,6 +19123,7 @@ var log_func_with_prefix = function(func, prefix) {
 var console_with_prefix = function(prefix) {
     return {
         log: log_func_with_prefix(console$1.log, prefix),
+        warn: log_func_with_prefix(console$1.warn, prefix),
         error: log_func_with_prefix(console$1.error, prefix),
         critical: log_func_with_prefix(console$1.critical, prefix)
     };
@@ -20069,7 +20070,8 @@ var localStorageSupported = function(storage, forceCheck) {
     if (_localStorageSupported !== null && !forceCheck) {
         return _localStorageSupported;
     }
-    return _localStorageSupported = _testStorageSupported(storage || win.localStorage);
+
+    return _localStorageSupported = _testStorageSupported(storage);
 };
 
 var _sessionStorageSupported = null;
@@ -20077,7 +20079,8 @@ var sessionStorageSupported = function(storage, forceCheck) {
     if (_sessionStorageSupported !== null && !forceCheck) {
         return _sessionStorageSupported;
     }
-    return _sessionStorageSupported = _testStorageSupported(storage || win.sessionStorage);
+
+    return _sessionStorageSupported = _testStorageSupported(storage);
 };
 
 function _storageWrapper(storage, name, is_supported_fn) {
@@ -20127,17 +20130,26 @@ function _storageWrapper(storage, name, is_supported_fn) {
     };
 }
 
-// Safari errors out accessing localStorage/sessionStorage when cookies are disabled,
-// so create dummy storage wrappers that silently fail as a fallback.
-var windowLocalStorage = null, windowSessionStorage = null;
-try {
-    windowLocalStorage = win.localStorage;
-    windowSessionStorage = win.sessionStorage;
-    // eslint-disable-next-line no-empty
-} catch (_err) {}
+// Safari and other browsers may error out accessing localStorage/sessionStorage
+// when cookies are disabled, so wrap access in a try-catch.
+var getLocalStorage = function() {
+    try {
+        return win.localStorage; // eslint-disable-line no-restricted-properties
+    } catch (_err) {
+        return null;
+    }
+};
 
-_.localStorage = _storageWrapper(windowLocalStorage, 'localStorage', localStorageSupported);
-_.sessionStorage = _storageWrapper(windowSessionStorage, 'sessionStorage', sessionStorageSupported);
+var getSessionStorage = function() {
+    try {
+        return win.sessionStorage; // eslint-disable-line no-restricted-properties
+    } catch (_err) {
+        return null;
+    }
+};
+
+_.localStorage = _storageWrapper(getLocalStorage(), 'localStorage', localStorageSupported);
+_.sessionStorage = _storageWrapper(getSessionStorage(), 'sessionStorage', sessionStorageSupported);
 
 _.register_event = (function() {
     // written by Dean Edwards, 2005
@@ -20806,29 +20818,26 @@ _['JSONEncode']             = _.JSONEncode;
 _['toArray']                = _.toArray;
 _['NPO']                    = NpoPromise;
 
-var MIXPANEL_DB_NAME = 'mixpanelBrowserDb';
-
-var RECORDING_EVENTS_STORE_NAME = 'mixpanelRecordingEvents';
-var RECORDING_REGISTRY_STORE_NAME = 'mixpanelRecordingRegistry';
-
-// note: increment the version number when adding new object stores
-var DB_VERSION = 1;
-var OBJECT_STORES = [RECORDING_EVENTS_STORE_NAME, RECORDING_REGISTRY_STORE_NAME];
-
 /**
  * @type {import('./wrapper').StorageWrapper}
  */
-var IDBStorageWrapper = function (storeName) {
+var IDBStorageWrapper = function (dbName, storeName, versionData) {
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.version = versionData.version;
+    this.storeNamesInDb = versionData.storeNames;
     /**
      * @type {Promise<IDBDatabase>|null}
      */
     this.dbPromise = null;
-    this.storeName = storeName;
 };
 
 IDBStorageWrapper.prototype._openDb = function () {
+    var dbName = this.dbName;
+    var version = this.version;
+    var storeNamesInDb = this.storeNamesInDb;
     return new PromisePolyfill(function (resolve, reject) {
-        var openRequest = win.indexedDB.open(MIXPANEL_DB_NAME, DB_VERSION);
+        var openRequest = win.indexedDB.open(dbName, version);
         openRequest['onerror'] = function () {
             reject(openRequest.error);
         };
@@ -20840,8 +20849,10 @@ IDBStorageWrapper.prototype._openDb = function () {
         openRequest['onupgradeneeded'] = function (ev) {
             var db = ev.target.result;
 
-            OBJECT_STORES.forEach(function (storeName) {
-                db.createObjectStore(storeName);
+            storeNamesInDb.forEach(function (storeName) {
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName);
+                }
             });
         };
     });
@@ -20933,6 +20944,16 @@ IDBStorageWrapper.prototype.getAll = function () {
     });
 };
 
+var MIXPANEL_BROWSER_DB_NAME = 'mixpanelBrowserDb';
+var RECORDING_EVENTS_STORE_NAME = 'mixpanelRecordingEvents';
+var RECORDING_REGISTRY_STORE_NAME = 'mixpanelRecordingRegistry';
+
+// Keeping these two properties closeby, as adding additional stores to a DB in IndexedDB requires a version increment
+var RECORDER_VERSION_DATA = {
+    version: 1,
+    storeNames: [RECORDING_EVENTS_STORE_NAME, RECORDING_REGISTRY_STORE_NAME]
+};
+
 /**
  * GDPR utils
  *
@@ -21233,7 +21254,7 @@ function _addOptOutCheck(method, getConfigValue) {
     };
 }
 
-var logger$8 = console_with_prefix('lock');
+var logger$9 = console_with_prefix('lock');
 
 /**
  * SharedLock: a mutex built on HTML5 localStorage, to ensure that only one browser
@@ -21259,7 +21280,7 @@ var SharedLock = function(key, options) {
     options = options || {};
 
     this.storageKey = key;
-    this.storage = options.storage || win.localStorage;
+    this.storage = options.storage || getLocalStorage();
     this.pollIntervalMS = options.pollIntervalMS || 100;
     this.timeoutMS = options.timeoutMS || 2000;
 
@@ -21285,7 +21306,7 @@ SharedLock.prototype.withLock = function(lockedCB, pid) {
 
         var delay = function(cb) {
             if (new Date().getTime() - startTime > timeoutMS) {
-                logger$8.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                logger$9.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
                 storage.removeItem(keyZ);
                 storage.removeItem(keyY);
                 loop();
@@ -21387,10 +21408,13 @@ SharedLock.prototype.withLock = function(lockedCB, pid) {
  * @type {import('./wrapper').StorageWrapper}
  */
 var LocalStorageWrapper = function (storageOverride) {
-    this.storage = storageOverride || win.localStorage;
+    this.storage = storageOverride || getLocalStorage();
 };
 
 LocalStorageWrapper.prototype.init = function () {
+    if (!this.storage) {
+        return PromisePolyfill.reject(new Error('localStorage is not available'));
+    }
     return PromisePolyfill.resolve();
 };
 
@@ -21432,7 +21456,7 @@ LocalStorageWrapper.prototype.removeItem = function (key) {
     }, this));
 };
 
-var logger$7 = console_with_prefix('batch');
+var logger$8 = console_with_prefix('batch');
 
 /**
  * RequestQueue: queue for batching API requests with localStorage backup for retries.
@@ -21457,11 +21481,11 @@ var RequestQueue = function (storageKey, options) {
     if (this.usePersistence) {
         this.queueStorage = options.queueStorage || new LocalStorageWrapper();
         this.lock = new SharedLock(storageKey, {
-            storage: options.sharedLockStorage || win.localStorage,
+            storage: options.sharedLockStorage,
             timeoutMS: options.sharedLockTimeoutMS,
         });
     }
-    this.reportError = options.errorReporter || _.bind(logger$7.error, logger$7);
+    this.reportError = options.errorReporter || _.bind(logger$8.error, logger$8);
 
     this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
@@ -21794,7 +21818,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$6 = console_with_prefix('batch');
+var logger$7 = console_with_prefix('batch');
 
 /**
  * RequestBatcher: manages the queueing, flushing, retry etc of requests of one
@@ -21922,7 +21946,7 @@ RequestBatcher.prototype.sendRequestPromise = function(data, options) {
  */
 RequestBatcher.prototype.flush = function(options) {
     if (this.requestInProgress) {
-        logger$6.log('Flush: Request already in progress');
+        logger$7.log('Flush: Request already in progress');
         return PromisePolyfill.resolve();
     }
 
@@ -22099,7 +22123,7 @@ RequestBatcher.prototype.flush = function(options) {
             if (options.unloading) {
                 requestOptions.transport = 'sendBeacon';
             }
-            logger$6.log('MIXPANEL REQUEST:', dataForRequest);
+            logger$7.log('MIXPANEL REQUEST:', dataForRequest);
             return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
         }, this))
         .catch(_.bind(function(err) {
@@ -22112,7 +22136,7 @@ RequestBatcher.prototype.flush = function(options) {
  * Log error to global logger and optional user-defined logger.
  */
 RequestBatcher.prototype.reportError = function(msg, err) {
-    logger$6.error.apply(logger$6.error, arguments);
+    logger$7.error.apply(logger$7.error, arguments);
     if (this.errorReporter) {
         try {
             if (!(err instanceof Error)) {
@@ -22120,7 +22144,7 @@ RequestBatcher.prototype.reportError = function(msg, err) {
             }
             this.errorReporter(msg, err);
         } catch(err) {
-            logger$6.error(err);
+            logger$7.error(err);
         }
     }
 };
@@ -22265,7 +22289,7 @@ var EVENT_HANDLER_ATTRIBUTES = [
 
 var MAX_DEPTH = 5;
 
-var logger$5 = console_with_prefix('autocapture');
+var logger$6 = console_with_prefix('autocapture');
 
 
 function getClasses(el) {
@@ -22529,7 +22553,7 @@ function isElementAllowed(el, ev, allowElementCallback, allowSelectors) {
                 return false;
             }
         } catch (err) {
-            logger$5.critical('Error while checking element in allowElementCallback', err);
+            logger$6.critical('Error while checking element in allowElementCallback', err);
             return false;
         }
     }
@@ -22546,7 +22570,7 @@ function isElementAllowed(el, ev, allowElementCallback, allowSelectors) {
                 return true;
             }
         } catch (err) {
-            logger$5.critical('Error while checking selector: ' + sel, err);
+            logger$6.critical('Error while checking selector: ' + sel, err);
         }
     }
     return false;
@@ -22561,7 +22585,7 @@ function isElementBlocked(el, ev, blockElementCallback, blockSelectors) {
                 return true;
             }
         } catch (err) {
-            logger$5.critical('Error while checking element in blockElementCallback', err);
+            logger$6.critical('Error while checking element in blockElementCallback', err);
             return true;
         }
     }
@@ -22575,7 +22599,7 @@ function isElementBlocked(el, ev, blockElementCallback, blockSelectors) {
                     return true;
                 }
             } catch (err) {
-                logger$5.critical('Error while checking selector: ' + sel, err);
+                logger$6.critical('Error while checking selector: ' + sel, err);
             }
         }
     }
@@ -23131,7 +23155,7 @@ function shouldMaskText(element, privacyConfig) {
  *
  */
 
-var logger$4 = console_with_prefix('network-plugin');
+var logger$5 = console_with_prefix('network-plugin');
 
 /**
  * Get the time origin for converting performance timestamps to absolute timestamps.
@@ -23283,7 +23307,7 @@ function truncateBody(str) {
         return str;
     }
     if (str.length > MAX_BODY_SIZE) {
-        logger$4.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
+        logger$5.error('Body truncated from ' + str.length + ' to ' + MAX_BODY_SIZE + ' characters');
         return str.substring(0, MAX_BODY_SIZE) + '... [truncated]';
     }
     return str;
@@ -23297,7 +23321,7 @@ function truncateBody(str) {
  */
 function initPerformanceObserver(cb, win, options) {
     if (!win.PerformanceObserver) {
-        logger$4.error('PerformanceObserver not supported');
+        logger$5.error('PerformanceObserver not supported');
         return function() {
             //
         };
@@ -23450,7 +23474,7 @@ function getRequestPerformanceEntry(win, initiatorType, url, after, before, atte
         attempt = 0;
     }
     if (attempt > 10) {
-        logger$4.error('Cannot find performance entry');
+        logger$5.error('Cannot find performance entry');
         return Promise.resolve(null);
     }
     var urlPerformanceEntries = /** @type {PerformanceResourceTiming[]} */ (
@@ -23571,7 +23595,7 @@ function initXhrObserver(cb, win, options) {
                     )
                         .then(function(entry) {
                             if (!entry) {
-                                logger$4.error('Failed to get performance entry for XHR request to ' + req.url);
+                                logger$5.error('Failed to get performance entry for XHR request to ' + req.url);
                                 return;
                             }
                             /** @type {NetworkRequest} */
@@ -23591,7 +23615,7 @@ function initXhrObserver(cb, win, options) {
                             cb({ requests: [request] });
                         })
                         .catch(function(e) {
-                            logger$4.error('Error recording XHR request to ' + req.url + ': ' + String(e));
+                            logger$5.error('Error recording XHR request to ' + req.url + ': ' + String(e));
                         });
                 });
 
@@ -23683,7 +23707,7 @@ function initFetchObserver(cb, win, options) {
                 })
                 .then(function(entry) {
                     if (!entry) {
-                        logger$4.error('Failed to get performance entry for fetch request to ' + req.url);
+                        logger$5.error('Failed to get performance entry for fetch request to ' + req.url);
                         return;
                     }
                     /** @type {NetworkRequest} */
@@ -23703,7 +23727,7 @@ function initFetchObserver(cb, win, options) {
                     cb({ requests: [request] });
                 })
                 .catch(function (e) {
-                    logger$4.error('Error recording fetch request to ' + req.url + ': ' + String(e));
+                    logger$5.error('Error recording fetch request to ' + req.url + ': ' + String(e));
                 });
 
             return originalFetchPromise;
@@ -23776,7 +23800,7 @@ var getRecordNetworkPlugin = function(options) {
  */
 
 
-var logger$3 = console_with_prefix('recorder');
+var logger$4 = console_with_prefix('recorder');
 var CompressionStream = win['CompressionStream'];
 
 var RECORDER_BATCHER_LIB_CONFIG = {
@@ -23873,11 +23897,11 @@ var SessionRecording = function(options) {
 
     // 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');
+    var usePersistence = localStorageSupported(options.sharedLockStorage || getLocalStorage(), 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.queueStorage = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_EVENTS_STORE_NAME, RECORDER_VERSION_DATA);
     this.batcher = new RequestBatcher(this.batcherKey, {
         errorReporter: this.reportError.bind(this),
         flushOnlyOnInterval: true,
@@ -23956,14 +23980,14 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
     }
 
     if (this._stopRecording !== null) {
-        logger$3.log('Recording already in progress, skipping startRecording.');
+        logger$4.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$3.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
+        logger$4.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
     }
 
     if (!this.maxExpires) {
@@ -24027,7 +24051,7 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
         );
     }
 
-    var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$3);
+    var validatedOrigins = validateAllowedOrigins(this.getConfig('record_allowed_iframe_origins'), logger$4);
 
     try {
         this._stopRecording = this._rrwebRecord({
@@ -24289,14 +24313,14 @@ SessionRecording.prototype._flushEvents = addOptOutCheckMixpanelLib(function (da
 
 
 SessionRecording.prototype.reportError = function(msg, err) {
-    logger$3.error.apply(logger$3.error, arguments);
+    logger$4.error.apply(logger$4.error, arguments);
     try {
         if (!err && !(msg instanceof Error)) {
             msg = new Error(msg);
         }
         this.getConfig('error_reporter')(msg, err);
     } catch(err) {
-        logger$3.error(err);
+        logger$4.error(err);
     }
 };
 
@@ -24325,7 +24349,7 @@ SessionRecording.prototype._getRecordMinMs = function() {
     var configValue = this.getConfig('record_min_ms');
 
     if (configValue > MAX_VALUE_FOR_MIN_RECORDING_MS) {
-        logger$3.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
+        logger$4.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
         return MAX_VALUE_FOR_MIN_RECORDING_MS;
     }
 
@@ -24367,7 +24391,7 @@ SessionRecording.prototype._getMaskFn = function(shouldMaskFn, privacyConfig) {
  */
 var RecordingRegistry = function (options) {
     /** @type {IDBStorageWrapper} */
-    this.idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+    this.idb = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_REGISTRY_STORE_NAME, RECORDER_VERSION_DATA);
     this.errorReporter = options.errorReporter;
     this.mixpanelInstance = options.mixpanelInstance;
     this.sharedLockStorage = options.sharedLockStorage;
@@ -24488,7 +24512,7 @@ RecordingRegistry.prototype.flushInactiveRecordings = function () {
         .catch(this.handleError.bind(this));
 };
 
-var logger$2 = console_with_prefix('recorder');
+var logger$3 = console_with_prefix('recorder');
 
 /**
  * Recorder API: bundles rrweb and and exposes methods to start and stop recordings.
@@ -24504,7 +24528,7 @@ var MixpanelRecorder = function(mixpanelInstance, rrwebRecord, sharedLockStorage
      */
     this.recordingRegistry = new RecordingRegistry({
         mixpanelInstance: this.mixpanelInstance,
-        errorReporter: logger$2.error,
+        errorReporter: logger$3.error,
         sharedLockStorage: sharedLockStorage
     });
     this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
@@ -24516,17 +24540,17 @@ var MixpanelRecorder = function(mixpanelInstance, rrwebRecord, sharedLockStorage
 MixpanelRecorder.prototype.startRecording = function(options) {
     options = options || {};
     if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-        logger$2.log('Recording already in progress, skipping startRecording.');
+        logger$3.log('Recording already in progress, skipping startRecording.');
         return;
     }
 
     var onIdleTimeout = function () {
-        logger$2.log('Idle timeout reached, restarting recording.');
+        logger$3.log('Idle timeout reached, restarting recording.');
         this.resetRecording();
     }.bind(this);
 
     var onMaxLengthReached = function () {
-        logger$2.log('Max recording length reached, stopping recording.');
+        logger$3.log('Max recording length reached, stopping recording.');
         this.resetRecording();
     }.bind(this);
 
@@ -24596,7 +24620,7 @@ MixpanelRecorder.prototype.resumeRecording = function (startNewIfInactive) {
             } else if (startNewIfInactive) {
                 return this.startRecording({shouldStopBatcher: false});
             } else {
-                logger$2.log('No resumable recording found.');
+                logger$3.log('No resumable recording found.');
                 return null;
             }
         }.bind(this));
@@ -25261,7 +25285,7 @@ ShadowDOMObserver.prototype.observeShadowRoot = function(shadowRoot) {
         observer.observe(shadowRoot, this.observerConfig);
         this.shadowObservers.push(observer);
     } catch (e) {
-        logger$5.critical('Error while observing shadow root', e);
+        logger$6.critical('Error while observing shadow root', e);
     }
 };
 
@@ -25272,7 +25296,7 @@ ShadowDOMObserver.prototype.start = function() {
     }
 
     if (!weakSetSupported()) {
-        logger$5.critical('Shadow DOM observation unavailable: WeakSet not supported');
+        logger$6.critical('Shadow DOM observation unavailable: WeakSet not supported');
         return;
     }
 
@@ -25288,7 +25312,7 @@ ShadowDOMObserver.prototype.stop = function() {
         try {
             this.shadowObservers[i].disconnect();
         } catch (e) {
-            logger$5.critical('Error while disconnecting shadow DOM observer', e);
+            logger$6.critical('Error while disconnecting shadow DOM observer', e);
         }
     }
     this.shadowObservers = [];
@@ -25476,7 +25500,7 @@ DeadClickTracker.prototype.startTracking = function() {
 
             this.mutationObserver.observe(document.body || document.documentElement, MUTATION_OBSERVER_CONFIG);
         } catch (e) {
-            logger$5.critical('Error while setting up mutation observer', e);
+            logger$6.critical('Error while setting up mutation observer', e);
         }
     }
 
@@ -25491,7 +25515,7 @@ DeadClickTracker.prototype.startTracking = function() {
             );
             this.shadowDOMObserver.start();
         } catch (e) {
-            logger$5.critical('Error while setting up shadow DOM observer', e);
+            logger$6.critical('Error while setting up shadow DOM observer', e);
             this.shadowDOMObserver = null;
         }
     }
@@ -25518,7 +25542,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             listener.target.removeEventListener(listener.event, listener.handler, listener.options);
         } catch (e) {
-            logger$5.critical('Error while removing event listener', e);
+            logger$6.critical('Error while removing event listener', e);
         }
     }
     this.eventListeners = [];
@@ -25527,7 +25551,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             this.mutationObserver.disconnect();
         } catch (e) {
-            logger$5.critical('Error while disconnecting mutation observer', e);
+            logger$6.critical('Error while disconnecting mutation observer', e);
         }
         this.mutationObserver = null;
     }
@@ -25536,7 +25560,7 @@ DeadClickTracker.prototype.stopTracking = function() {
         try {
             this.shadowDOMObserver.stop();
         } catch (e) {
-            logger$5.critical('Error while stopping shadow DOM observer', e);
+            logger$6.critical('Error while stopping shadow DOM observer', e);
         }
         this.shadowDOMObserver = null;
     }
@@ -25614,7 +25638,7 @@ var Autocapture = function(mp) {
 
 Autocapture.prototype.init = function() {
     if (!minDOMApisSupported()) {
-        logger$5.critical('Autocapture unavailable: missing required DOM APIs');
+        logger$6.critical('Autocapture unavailable: missing required DOM APIs');
         return;
     }
     this.initPageListeners();
@@ -25654,7 +25678,7 @@ Autocapture.prototype.currentUrlBlocked = function() {
         try {
             return !urlMatchesRegexList(currentUrl, allowUrlRegexes);
         } catch (err) {
-            logger$5.critical('Error while checking block URL regexes: ', err);
+            logger$6.critical('Error while checking block URL regexes: ', err);
             return true;
         }
     }
@@ -25667,7 +25691,7 @@ Autocapture.prototype.currentUrlBlocked = function() {
     try {
         return urlMatchesRegexList(currentUrl, blockUrlRegexes);
     } catch (err) {
-        logger$5.critical('Error while checking block URL regexes: ', err);
+        logger$6.critical('Error while checking block URL regexes: ', err);
         return true;
     }
 };
@@ -25805,7 +25829,7 @@ Autocapture.prototype._initScrollDepthTracking = function() {
         return;
     }
 
-    logger$5.log('Initializing scroll depth tracking');
+    logger$6.log('Initializing scroll depth tracking');
 
     this.maxScrollViewDepth = Math.max(document$1.documentElement.clientHeight, win.innerHeight || 0);
 
@@ -25831,7 +25855,7 @@ Autocapture.prototype.initClickTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.get_config('record_heatmap_data')) {
         return;
     }
-    logger$5.log('Initializing click tracking');
+    logger$6.log('Initializing click tracking');
 
     this.listenerClick = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_CLICK) && !this.mp.is_recording_heatmap_data()) {
@@ -25850,7 +25874,7 @@ Autocapture.prototype.initDeadClickTracking = function() {
         return;
     }
 
-    logger$5.log('Initializing dead click tracking');
+    logger$6.log('Initializing dead click tracking');
     if (!this._deadClickTracker) {
         this._deadClickTracker = new DeadClickTracker(function(deadClickEvent) {
             this.trackDomEvent(deadClickEvent, MP_EV_DEAD_CLICK);
@@ -25884,7 +25908,7 @@ Autocapture.prototype.initInputTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_INPUT)) {
         return;
     }
-    logger$5.log('Initializing input tracking');
+    logger$6.log('Initializing input tracking');
 
     this.listenerChange = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_INPUT)) {
@@ -25898,14 +25922,15 @@ Autocapture.prototype.initInputTracking = function() {
 Autocapture.prototype.initPageviewTracking = function() {
     win.removeEventListener(EV_MP_LOCATION_CHANGE, this.listenerLocationchange);
 
-    if (!this.pageviewTrackingConfig()) {
+    if (!this.pageviewTrackingConfig() && !this.mp.get_config('record_heatmap_data')) {
         return;
     }
-    logger$5.log('Initializing pageview tracking');
+    logger$6.log('Initializing pageview tracking');
 
     var previousTrackedUrl = '';
     var tracked = false;
-    if (!this.currentUrlBlocked()) {
+    // Track initial pageview if pageview tracking enabled OR heatmap recording is active
+    if ((this.pageviewTrackingConfig() || this.mp.is_recording_heatmap_data()) && !this.currentUrlBlocked()) {
         tracked = this.mp.track_pageview(DEFAULT_PROPS);
     }
     if (tracked) {
@@ -25921,6 +25946,10 @@ Autocapture.prototype.initPageviewTracking = function() {
         var shouldTrack = false;
         var didPathChange = currentUrl.split('#')[0].split('?')[0] !== previousTrackedUrl.split('#')[0].split('?')[0];
         var trackPageviewOption = this.pageviewTrackingConfig();
+        if (!trackPageviewOption && this.mp.is_recording_heatmap_data()) {
+            trackPageviewOption = PAGEVIEW_OPTION_FULL_URL;
+        }
+
         if (trackPageviewOption === PAGEVIEW_OPTION_FULL_URL) {
             shouldTrack = currentUrl !== previousTrackedUrl;
         } else if (trackPageviewOption === PAGEVIEW_OPTION_URL_WITH_PATH_AND_QUERY_STRING) {
@@ -25936,7 +25965,7 @@ Autocapture.prototype.initPageviewTracking = function() {
             }
             if (didPathChange) {
                 this.lastScrollCheckpoint = 0;
-                logger$5.log('Path change: re-initializing scroll depth checkpoints');
+                logger$6.log('Path change: re-initializing scroll depth checkpoints');
             }
         }
     }.bind(this));
@@ -25951,7 +25980,7 @@ Autocapture.prototype.initRageClickTracking = function() {
         return;
     }
 
-    logger$5.log('Initializing rage click tracking');
+    logger$6.log('Initializing rage click tracking');
     if (!this._rageClickTracker) {
         this._rageClickTracker = new RageClickTracker();
     }
@@ -25981,7 +26010,7 @@ Autocapture.prototype.initScrollTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_SCROLL)) {
         return;
     }
-    logger$5.log('Initializing scroll tracking');
+    logger$6.log('Initializing scroll tracking');
     this.lastScrollCheckpoint = 0;
 
     var scrollTrackFunction = function() {
@@ -26018,7 +26047,7 @@ Autocapture.prototype.initScrollTracking = function() {
                 }
             }
         } catch (err) {
-            logger$5.critical('Error while calculating scroll percentage', err);
+            logger$6.critical('Error while calculating scroll percentage', err);
         }
         if (shouldTrack) {
             this.mp.track(MP_EV_SCROLL, props);
@@ -26036,7 +26065,7 @@ Autocapture.prototype.initSubmitTracking = function() {
     if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
         return;
     }
-    logger$5.log('Initializing submit tracking');
+    logger$6.log('Initializing submit tracking');
 
     this.listenerSubmit = function(ev) {
         if (!this.getConfig(CONFIG_TRACK_SUBMIT)) {
@@ -26058,7 +26087,7 @@ Autocapture.prototype.initPageLeaveTracking = function() {
         return;
     }
 
-    logger$5.log('Initializing page visibility tracking.');
+    logger$6.log('Initializing page visibility tracking.');
     this._initScrollDepthTracking();
     var previousTrackedUrl = _.info.currentUrl();
 
@@ -26143,10 +26172,183 @@ var getTargetingPromise = function(loadExtraBundle, targetingSrc) {
     return win[TARGETING_GLOBAL_NAME];
 };
 
+var logger$2 = console_with_prefix('flags');
+
+var MIXPANEL_FLAGS_DB_NAME = 'mixpanelFlagsDb';
+var FLAGS_STORE_NAME = 'mixpanelFlags';
+
+// Keeping these two properties closeby, as adding additional stores to a DB in IndexedDB requires a version increment
+var FLAGS_VERSION_DATA = { version: 1, storeNames: [FLAGS_STORE_NAME] };
+
+var PERSISTED_VARIANTS_KEY_PREFIX = 'persisted_variants_for_';
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+
+var VariantLookupPolicy = Object.freeze({
+    NETWORK_ONLY: 'networkOnly',
+    NETWORK_FIRST: 'networkFirst',
+    PERSISTENCE_UNTIL_NETWORK_SUCCESS: 'persistenceUntilNetworkSuccess'
+});
+
+var VALID_POLICIES = [
+    VariantLookupPolicy.NETWORK_ONLY,
+    VariantLookupPolicy.NETWORK_FIRST,
+    VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS
+];
+
+/**
+ * Module for handling the storage and retrieval of persisted feature flag variants.
+ */
+var FeatureFlagPersistence = function(persistenceConfig, token, isGloballyDisabled) {
+    this.idb = new IDBStorageWrapper(MIXPANEL_FLAGS_DB_NAME, FLAGS_STORE_NAME, FLAGS_VERSION_DATA);
+    this.persistenceConfig = persistenceConfig;
+    this.persistedVariantsKey = PERSISTED_VARIANTS_KEY_PREFIX + token;
+    this.isGloballyDisabled = isGloballyDisabled || function() { return false; };
+};
+
+FeatureFlagPersistence.prototype.getPolicy = function() {
+    if (this.isGloballyDisabled() || !this._isConfigValid()) {
+        return VariantLookupPolicy.NETWORK_ONLY;
+    }
+    return this.persistenceConfig['variantLookupPolicy'];
+};
+
+FeatureFlagPersistence.prototype.getTtlMs = function() {
+    if (!this._isConfigValid()) {
+        return DEFAULT_TTL_MS;
+    }
+    var configuredTtl = this.persistenceConfig['persistenceTtlMs'];
+    return (configuredTtl === undefined || configuredTtl === null) ? DEFAULT_TTL_MS : configuredTtl;
+};
+
+FeatureFlagPersistence.prototype._isConfigValid = function() {
+    var config = this.persistenceConfig;
+    if (!config) {
+        return false;
+    }
+
+    if (VALID_POLICIES.indexOf(config['variantLookupPolicy']) === -1) {
+        logger$2.error('Invalid variantLookupPolicy:', config['variantLookupPolicy']);
+        return false;
+    }
+
+    if (config['persistenceTtlMs'] !== undefined &&
+        config['persistenceTtlMs'] !== null &&
+        config['persistenceTtlMs'] <= 0) {
+        logger$2.error('If provided, persistenceTtlMs must be a positive number. Provided value:', config['persistenceTtlMs']);
+        return false;
+    }
+
+    return true;
+};
+
+FeatureFlagPersistence.prototype.loadFlagsFromStorage = function(context) {
+    var clearAndReturnNull = _.bind(function() {
+        return this.clear().then(function() { return null; }).catch(function() { return null; });
+    }, this);
+
+    if (this.getPolicy() === VariantLookupPolicy.NETWORK_ONLY) {
+        return clearAndReturnNull();
+    }
+
+    var ttlMs = this.getTtlMs();
+
+    return this.idb.init().then(_.bind(function() {
+        return this.idb.getItem(this.persistedVariantsKey);
+    }, this)).then(_.bind(function(data) {
+        if (!data) {
+            logger$2.log('No persisted variants found in IndexedDB');
+            return null;
+        }
+
+        if (ttlMs && Date.now() - data['persistedAt'] >= ttlMs) {
+            logger$2.log('Persisted variants are expiring');
+            return null;
+        }
+
+        if (!context || data['distinctId'] !== context['distinct_id']) {
+            logger$2.log('Persisted variants found, but for a different distinct_id so clearing.');
+            return clearAndReturnNull();
+        }
+
+        var persistedFlags = new Map();
+        _.each(data['flagVariants'], function(variantData, key) {
+            persistedFlags.set(key, {
+                'key': variantData['variant_key'],
+                'value': variantData['variant_value'],
+                'experiment_id': variantData['experiment_id'],
+                'is_experiment_active': variantData['is_experiment_active'],
+                'is_qa_tester': variantData['is_qa_tester'],
+                'variant_source': 'persistence',
+                'persisted_at_in_ms': data['persistedAt'],
+                'ttl_in_ms': ttlMs
+            });
+        });
+
+        logger$2.log('Loaded', persistedFlags.size, 'variants from IndexedDB for distinct_id', data['distinctId']);
+
+        return {
+            flags: persistedFlags,
+            pendingFirstTimeEvents: data['pendingFirstTimeEvents'] || {},
+            persistedAtMs: data['persistedAt'],
+            ttlMs: ttlMs
+        };
+    }, this)).catch(_.bind(function(error) {
+        logger$2.error('Failed to load persisted variants from IndexedDB, so clearing', error);
+        return clearAndReturnNull();
+    }, this));
+};
+
+FeatureFlagPersistence.prototype.save = function(context, flagsMap, pendingFirstTimeEvents) {
+    if (this.getPolicy() === VariantLookupPolicy.NETWORK_ONLY) {
+        return Promise.resolve();
+    }
+
+    var flagVariants = {};
+    flagsMap.forEach(function(variant, key) {
+        flagVariants[key] = {
+            'variant_key': variant['key'],
+            'variant_value': variant['value'],
+            'experiment_id': variant['experiment_id'],
+            'is_experiment_active': variant['is_experiment_active'],
+            'is_qa_tester': variant['is_qa_tester']
+        };
+    });
+
+    var data = {
+        'persistedAt': Date.now(),
+        'distinctId': context && context['distinct_id'],
+        'context': context,
+        'flagVariants': flagVariants,
+        'pendingFirstTimeEvents': pendingFirstTimeEvents || {}
+    };
+
+    return this.idb.init().then(_.bind(function() {
+        return this.idb.setItem(this.persistedVariantsKey, data);
+    }, this)).then(function() {
+        logger$2.log('Saved', flagsMap.size, 'variants to IndexedDB for distinct_id', data['distinctId']);
+    }).catch(function(error) {
+        logger$2.error('Failed to persist variants to IndexedDB:', error);
+    });
+};
+
+FeatureFlagPersistence.prototype.clear = function() {
+    if (this.isGloballyDisabled()) {
+        return Promise.resolve();
+    }
+    return this.idb.init().then(_.bind(function() {
+        return this.idb.removeItem(this.persistedVariantsKey);
+    }, this)).then(function() {
+        logger$2.log('Cleared persisted variants from IndexedDB');
+    }).catch(function(error) {
+        logger$2.error('Failed to clear persisted variants from IndexedDB:', error);
+    });
+};
+
 var logger$1 = console_with_prefix('flags');
 var FLAGS_CONFIG_KEY = 'flags';
 
 var CONFIG_CONTEXT = 'context';
+var CONFIG_PERSISTENCE = 'persistence';
 var CONFIG_DEFAULTS = {};
 CONFIG_DEFAULTS[CONFIG_CONTEXT] = {};
 
@@ -26169,6 +26371,13 @@ var getFlagKeyFromPendingEventKey = function(eventKey) {
     return eventKey.split(':')[0];
 };
 
+var withFallbackSource = function(fallback) {
+    if (_.isObject(fallback)) {
+        return _.extend({}, fallback, {'variant_source': 'fallback'});
+    }
+    return {'value': fallback, 'variant_source': 'fallback'};
+};
+
 /**
  * FeatureFlagManager: support for Mixpanel's feature flagging product
  * @constructor
@@ -26191,11 +26400,63 @@ FeatureFlagManager.prototype.init = function() {
     }
 
     this.flags = null;
-    this.fetchFlags();
-
     this.trackedFeatures = new Set();
     this.pendingFirstTimeEvents = {};
     this.activatedFirstTimeEvents = {};
+    this._loadedPersistedAtMs = null;
+    this._loadedTtlMs = null;
+
+    this.persistence = new FeatureFlagPersistence(
+        this.getConfig(CONFIG_PERSISTENCE),
+        this.getMpConfig('token'),
+        _.bind(function() { return this.getMpConfig('disable_persistence'); }, this)
+    );
+
+    this.persistenceLoadedPromise = this.persistence.loadFlagsFromStorage(this._buildContext())
+        .then(_.bind(function(loaded) {
+            if (loaded) {
+                this.flags = loaded.flags;
+                this.pendingFirstTimeEvents = loaded.pendingFirstTimeEvents;
+                this._loadedPersistedAtMs = loaded.persistedAtMs;
+                this._loadedTtlMs = loaded.ttlMs;
+            }
+        }, this));
+
+    return this.persistenceLoadedPromise
+        .then(_.bind(function() {
+            return this.fetchFlags();
+        }, this))
+        .catch(function() {
+            logger$1.error('Error initializing feature flags');
+        });
+};
+
+FeatureFlagManager.prototype._buildContext = function() {
+    return _.extend(
+        {'distinct_id': this.getMpProperty('distinct_id'), 'device_id': this.getMpProperty('$device_id')},
+        this.getConfig(CONFIG_CONTEXT)
+    );
+};
+
+FeatureFlagManager.prototype.reset = function() {
+    if (!this.persistence) {
+        return Promise.resolve();
+    }
+
+    this.flags = null;
+    this.pendingFirstTimeEvents = {};
+    this.activatedFirstTimeEvents = {};
+    this.trackedFeatures = new Set();
+    this.fetchPromise = null;
+    this._fetchInProgressStartTime = null;
+    this._loadedPersistedAtMs = null;
+    this._loadedTtlMs = null;
+
+    return this.persistence.clear().then(_.bind(function() {
+        return this.fetchFlags();
+    }, this)).catch(function() {
+        logger$1.error('Error during flags reset');
+    });
 };
 
 FeatureFlagManager.prototype.getFullConfig = function() {
@@ -26232,8 +26493,12 @@ FeatureFlagManager.prototype.updateContext = function(newContext, options) {
     var oldContext = (options && options['replace']) ? {} : this.getConfig(CONFIG_CONTEXT);
     ffConfig[CONFIG_CONTEXT] = _.extend({}, oldContext, newContext);
 
-    this.setMpConfig(FLAGS_CONFIG_KEY, ffConfig);
-    return this.fetchFlags();
+    var configUpdate = {};
+    configUpdate[FLAGS_CONFIG_KEY] = ffConfig;
+    this.setMpConfig(configUpdate);
+    return this.fetchFlags().catch(function() {
+        logger$1.error('Error fetching flags during updateContext');
+    });
 };
 
 FeatureFlagManager.prototype.areFlagsReady = function() {
@@ -26248,12 +26513,11 @@ FeatureFlagManager.prototype.fetchFlags = function() {
         return Promise.resolve();
     }
 
-    var distinctId = this.getMpProperty('distinct_id');
-    var deviceId = this.getMpProperty('$device_id');
+    var context = this._buildContext();
+    var distinctId = context['distinct_id'];
     var traceparent = generateTraceparent();
     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();
     searchParams.set('context', JSON.stringify(context));
     searchParams.set('token', this.getMpConfig('token'));
@@ -26270,96 +26534,116 @@ FeatureFlagManager.prototype.fetchFlags = function() {
         }
     }).then(function(response) {
         this.markFetchComplete();
-        return response.json().then(function(responseBody) {
-            var responseFlags = responseBody['flags'];
-            if (!responseFlags) {
-                throw new Error('No flags in API response');
-            }
-            var flags = new Map();
-            var pendingFirstTimeEvents = {};
-
-            // Process flags from response
-            _.each(responseFlags, function(data, key) {
-                // Check if this flag has any activated first-time events this session
-                var hasActivatedEvent = false;
-                var prefix = key + ':';
-                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                    if (eventKey.startsWith(prefix)) {
-                        hasActivatedEvent = true;
-                    }
-                });
+        return response.json();
+    }.bind(this)).then(function(responseBody) {
+        var responseFlags = responseBody['flags'];
+        if (!responseFlags) {
+            throw new Error('No flags in API response');
+        }
+        var flags = new Map();
+        var pendingFirstTimeEvents = {};
+
+        // Process flags from response
+        _.each(responseFlags, function(data, key) {
+            // Check if this flag has any activated first-time events this session
+            var hasActivatedEvent = false;
+            var prefix = key + ':';
+            _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                if (eventKey.startsWith(prefix)) {
+                    hasActivatedEvent = true;
+                }
+            });
 
-                if (hasActivatedEvent) {
-                    // Preserve the activated variant, don't overwrite with server's current variant
-                    var currentFlag = this.flags && this.flags.get(key);
-                    if (currentFlag) {
-                        flags.set(key, currentFlag);
-                    }
-                } else {
-                    // Use server's current variant
-                    flags.set(key, {
-                        'key': data['variant_key'],
-                        'value': data['variant_value'],
-                        'experiment_id': data['experiment_id'],
-                        'is_experiment_active': data['is_experiment_active'],
-                        'is_qa_tester': data['is_qa_tester']
-                    });
+            if (hasActivatedEvent) {
+                // Preserve the activated variant, don't overwrite with server's current variant
+                var currentFlag = this.flags && this.flags.get(key);
+                if (currentFlag) {
+                    flags.set(key, currentFlag);
                 }
-            }, this);
+            } else {
+                // Use server's current variant
+                flags.set(key, {
+                    'key': data['variant_key'],
+                    'value': data['variant_value'],
+                    'experiment_id': data['experiment_id'],
+                    'is_experiment_active': data['is_experiment_active'],
+                    'is_qa_tester': data['is_qa_tester'],
+                    'variant_source': 'network'
+                });
+            }
+        }, this);
 
-            // Process top-level pending_first_time_events array
-            var topLevelDefinitions = responseBody['pending_first_time_events'];
-            if (topLevelDefinitions && topLevelDefinitions.length > 0) {
-                _.each(topLevelDefinitions, function(def) {
-                    var flagKey = def['flag_key'];
-                    var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
+        // Process top-level pending_first_time_events array
+        var topLevelDefinitions = responseBody['pending_first_time_events'];
+        if (topLevelDefinitions && topLevelDefinitions.length > 0) {
+            _.each(topLevelDefinitions, function(def) {
+                var flagKey = def['flag_key'];
+                var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
 
-                    // Skip if this specific event has already been activated this session
-                    if (this.activatedFirstTimeEvents[eventKey]) {
-                        return;
-                    }
+                // Skip if this specific event has already been activated this session
+                if (this.activatedFirstTimeEvents[eventKey]) {
+                    return;
+                }
 
-                    // Store pending event definition using composite key
-                    pendingFirstTimeEvents[eventKey] = {
-                        'flag_key': flagKey,
-                        'flag_id': def['flag_id'],
-                        'project_id': def['project_id'],
-                        'first_time_event_hash': def['first_time_event_hash'],
-                        'event_name': def['event_name'],
-                        'property_filters': def['property_filters'],
-                        'pending_variant': def['pending_variant']
-                    };
-                }, this);
-            }
+                // Store pending event definition using composite key
+                pendingFirstTimeEvents[eventKey] = {
+                    'flag_key': flagKey,
+                    'flag_id': def['flag_id'],
+                    'project_id': def['project_id'],
+                    'first_time_event_hash': def['first_time_event_hash'],
+                    'event_name': def['event_name'],
+                    'property_filters': def['property_filters'],
+                    'pending_variant': def['pending_variant']
+                };
+            }, this);
+        }
 
-            // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
-            if (this.activatedFirstTimeEvents) {
-                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                    var flagKey = getFlagKeyFromPendingEventKey(eventKey);
-                    if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
-                        // Keep the activated flag even though it's not in the new response
-                        flags.set(flagKey, this.flags.get(flagKey));
-                    }
-                }, this);
-            }
+        // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
+        if (this.activatedFirstTimeEvents) {
+            _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                var flagKey = getFlagKeyFromPendingEventKey(eventKey);
+                if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
+                    // Keep the activated flag even though it's not in the new response
+                    flags.set(flagKey, this.flags.get(flagKey));
+                }
+            }, this);
+        }
 
-            this.flags = flags;
-            this.pendingFirstTimeEvents = pendingFirstTimeEvents;
-            this._traceparent = traceparent;
+        this.flags = flags;
+        this.trackedFeatures = new Set();
+        this.pendingFirstTimeEvents = pendingFirstTimeEvents;
+        this._loadedPersistedAtMs = null;
+        this._loadedTtlMs = null;
+        this._traceparent = traceparent;
 
-            this._loadTargetingIfNeeded();
-        }.bind(this)).catch(function(error) {
-            this.markFetchComplete();
-            logger$1.error(error);
-        }.bind(this));
+        this._loadTargetingIfNeeded();
+
+        this.persistence.save(context, this.flags, this.pendingFirstTimeEvents);
     }.bind(this)).catch(function(error) {
-        this.markFetchComplete();
+        if (this._fetchInProgressStartTime) {
+            this.markFetchComplete();
+        }
         logger$1.error(error);
+        throw error;
     }.bind(this));
 
     return this.fetchPromise;
 };
 
+FeatureFlagManager.prototype.loadFlags = function() {
+    if (!this.isSystemEnabled()) {
+        return Promise.resolve();
+    }
+    if (!this.trackedFeatures) {
+        logger$1.error('loadFlags called before init');
+        return Promise.resolve();
+    }
+    if (this._fetchInProgressStartTime) {
+        return this.fetchPromise;
+    }
+    return this.fetchFlags();
+};
+
 FeatureFlagManager.prototype.markFetchComplete = function() {
     if (!this._fetchInProgressStartTime) {
         logger$1.error('Fetch in progress started time not set, cannot mark fetch complete');
@@ -26494,6 +26778,7 @@ FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, p
         };
 
         this.flags.set(flagKey, newVariant);
+        this.trackedFeatures.delete(flagKey);
         this.activatedFirstTimeEvents[eventKey] = true;
 
         this.recordFirstTimeEvent(
@@ -26543,35 +26828,106 @@ FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId,
 };
 
 FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
-    if (!this.fetchPromise) {
+    if (!this.persistenceLoadedPromise) {
         return new Promise(function(resolve) {
             logger$1.critical('Feature Flags not initialized');
-            resolve(fallback);
+            resolve(withFallbackSource(fallback));
         });
     }
 
-    return this.fetchPromise.then(function() {
-        return this.getVariantSync(featureName, fallback);
-    }.bind(this)).catch(function(error) {
-        logger$1.error(error);
-        return fallback;
-    });
+    var policy = this.persistence.getPolicy();
+
+    return this.persistenceLoadedPromise.then(_.bind(function() {
+        // Serve from persistence until the network completes a successful fetch. If a non-expired cached value is available, return it without waiting on the in-flight fetch.
+        if (policy === VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS) {
+            if (this.areFlagsReady() && !this._loadedPersistenceIsStale()) {
+                return this.getVariantSync(featureName, fallback);
+            }
+            if (!this.fetchPromise) {
+                return withFallbackSource(fallback);
+            }
+            return this.fetchPromise.then(_.bind(function() {
+                return this.getVariantSync(featureName, fallback);
+            }, this)).catch(function(error) {
+                logger$1.error(error);
+                return withFallbackSource(fallback);
+            });
+        }
+
+        var serve = _.bind(function() { return this.getVariantSync(featureName, fallback); }, this);
+        if (!this.fetchPromise) {
+            return withFallbackSource(fallback);
+        }
+        return this.fetchPromise.then(serve).catch(serve);
+    }, this));
+};
+
+FeatureFlagManager.prototype._loadedPersistenceIsStale = function() {
+    if (!this._loadedPersistedAtMs || !this._loadedTtlMs) {
+        return false;
+    }
+    return Date.now() - this._loadedPersistedAtMs >= this._loadedTtlMs;
 };
 
 FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
+    if (this._loadedPersistenceIsStale()) {
+        logger$1.log('Loaded persisted variants are past TTL so returning fallback for "' + featureName + '"');
+        return withFallbackSource(fallback);
+    }
     if (!this.areFlagsReady()) {
         logger$1.log('Flags not loaded yet');
-        return fallback;
+        return withFallbackSource(fallback);
     }
     var feature = this.flags.get(featureName);
     if (!feature) {
         logger$1.log('No flag found: "' + featureName + '"');
-        return fallback;
+        return withFallbackSource(fallback);
     }
     this.trackFeatureCheck(featureName, feature);
     return feature;
 };
 
+FeatureFlagManager.prototype.getAllVariants = function() {
+    if (!this.persistenceLoadedPromise) {
+        logger$1.critical('Feature Flags not initialized');
+        return Promise.resolve(new Map());
+    }
+
+    var policy = this.persistence.getPolicy();
+
+    return this.persistenceLoadedPromise.then(_.bind(function() {
+        // Serve from persistence until the network completes a successful fetch. If a non-expired cached value is available, return it without waiting on the in-flight fetch.
+        if (policy === VariantLookupPolicy.PERSISTENCE_UNTIL_NETWORK_SUCCESS) {
+            if (this.areFlagsReady() && !this._loadedPersistenceIsStale()) {
+                return this.getAllVariantsSync();
+            }
+            if (!this.fetchPromise) {
+                return new Map();
+            }
+            return this.fetchPromise.then(_.bind(function() {
+                return this.getAllVariantsSync();
+            }, this)).catch(function(error) {
+                logger$1.error(error);
+                return new Map();
+            });
+        }
+
+        var serve = _.bind(this.getAllVariantsSync, this);
+        if (!this.fetchPromise) {
+            return new Map();
+        }
+        return this.fetchPromise.then(serve).catch(serve);
+    }, this));
+};
+
+FeatureFlagManager.prototype.getAllVariantsSync = function() {
+    if (this._loadedPersistenceIsStale()) {
+        logger$1.log('Loaded persisted variants are past TTL so returning empty Map');
+        return new Map();
+    }
+    return this.flags || new Map();
+};
+
 FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
     return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
         return feature['value'];
@@ -26610,6 +26966,10 @@ FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue
     return val;
 };
 
+function isPresent(v) {
+    return v !== undefined && v !== null;
+}
+
 FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature) {
     if (this.trackedFeatures.has(featureName)) {
         return;
@@ -26620,25 +26980,41 @@ FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature)
         '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 start time': isPresent(this._fetchStartTime) ? new Date(this._fetchStartTime).toISOString() : null,
+        'Variant fetch complete time': isPresent(this._fetchCompleteTime) ? new Date(this._fetchCompleteTime).toISOString() : null,
         'Variant fetch latency (ms)': this._fetchLatency,
         'Variant fetch traceparent': this._traceparent,
     };
 
-    if (feature['experiment_id'] !== 'undefined') {
+    if (isPresent(feature['experiment_id'])) {
         trackingProperties['$experiment_id'] = feature['experiment_id'];
     }
-    if (feature['is_experiment_active'] !== 'undefined') {
+    if (isPresent(feature['is_experiment_active'])) {
         trackingProperties['$is_experiment_active'] = feature['is_experiment_active'];
     }
-    if (feature['is_qa_tester'] !== 'undefined') {
+    if (isPresent(feature['is_qa_tester'])) {
         trackingProperties['$is_qa_tester'] = feature['is_qa_tester'];
     }
+    if (isPresent(feature['variant_source'])) {
+        trackingProperties['$variant_source'] = feature['variant_source'];
+    }
+    if (isPresent(feature['persisted_at_in_ms'])) {
+        trackingProperties['$persisted_at_in_ms'] = feature['persisted_at_in_ms'];
+    }
+    if (isPresent(feature['ttl_in_ms'])) {
+        trackingProperties['$ttl_in_ms'] = feature['ttl_in_ms'];
+    }
 
     this.track('$experiment_started', trackingProperties);
 };
 
+FeatureFlagManager.prototype.whenReady = function() {
+    if (this.fetchPromise) {
+        return this.fetchPromise;
+    }
+    return Promise.resolve();
+};
+
 FeatureFlagManager.prototype.minApisSupported = function() {
     return !!this.fetch &&
       typeof Promise !== 'undefined' &&
@@ -26651,11 +27027,15 @@ 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_all_variants'] = FeatureFlagManager.prototype.getAllVariants;
+FeatureFlagManager.prototype['get_all_variants_sync'] = FeatureFlagManager.prototype.getAllVariantsSync;
 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['load_flags'] = FeatureFlagManager.prototype.loadFlags;
 FeatureFlagManager.prototype['update_context'] = FeatureFlagManager.prototype.updateContext;
+FeatureFlagManager.prototype['when_ready'] = FeatureFlagManager.prototype.whenReady;
 
 // Deprecated method
 FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
@@ -26701,7 +27081,7 @@ RecorderManager.prototype.shouldLoadRecorder = function() {
         return PromisePolyfill.resolve(false);
     }
 
-    var recording_registry_idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+    var recording_registry_idb = new IDBStorageWrapper(MIXPANEL_BROWSER_DB_NAME, RECORDING_REGISTRY_STORE_NAME, RECORDER_VERSION_DATA);
     var tab_id = this.getTabId();
     return recording_registry_idb.init()
         .then(function () {
@@ -28628,6 +29008,7 @@ MixpanelLib.prototype._init = function(token, config, name) {
         'disable_all_events': false,
         'identify_called': false
     };
+    this._remote_settings_strict_disabled = false;
 
     // set up request queueing/batching
     this.request_batchers = {};
@@ -28702,9 +29083,6 @@ MixpanelLib.prototype._init = function(token, config, name) {
     this.flags.init();
     this['flags'] = this.flags;
 
-    this.autocapture = new Autocapture(this);
-    this.autocapture.init();
-
     this._init_tab_id();
 
     // Based on remote_settings_mode, fetch remote settings and then start session recording if applicable
@@ -28716,6 +29094,9 @@ MixpanelLib.prototype._init = function(token, config, name) {
     } else {
         this.__session_recording_init_promise = this._check_and_start_session_recording();
     }
+
+    this.autocapture = new Autocapture(this);
+    this.autocapture.init();
 };
 
 /**
@@ -28762,9 +29143,19 @@ MixpanelLib.prototype._check_and_start_session_recording = addOptOutCheckMixpane
     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_recording_on_event = safewrap(function(event_name, properties) {
+    // Wait for recording init to complete before evaluating event triggers.
+    // This ensures recording_event_triggers config is fully loaded when remote settings are used.
+    if (this.__session_recording_init_promise) {
+        this.__session_recording_init_promise.then(_.bind(function() {
+            // In strict mode, skip recording if remote settings failed
+            if (this._remote_settings_strict_disabled) {
+                return;
+            }
+            return this.recorderManager.startRecordingOnEvent(event_name, properties);
+        }, this));
+    }
+});
 
 MixpanelLib.prototype.start_session_recording = function () {
     return this._check_and_start_session_recording(true);
@@ -29063,6 +29454,7 @@ MixpanelLib.prototype._fetch_remote_settings = function(mode) {
     var disableRecordingIfStrict = function() {
         if (mode === 'strict') {
             self.set_config({'record_sessions_percent': 0});
+            self._remote_settings_strict_disabled = true;
         }
     };
 
@@ -29688,6 +30080,10 @@ MixpanelLib.prototype.track_pageview = addOptOutCheckMixpanelLib(function(proper
         properties
     );
 
+    if (this.is_recording_heatmap_data()) {
+        event_properties['$captured_for_heatmap'] = true;
+    }
+
     return this.track(event_name, event_properties);
 });
 
@@ -30011,7 +30407,9 @@ MixpanelLib.prototype.identify = function(
 
     // check feature flags again if distinct id has changed
     if (new_distinct_id !== previous_distinct_id) {
-        this.flags.fetchFlags();
+        this.flags.fetchFlags().catch(function() {
+            console$1.error('[flags] Error fetching flags during identify');
+        });
     }
 };
 
@@ -30029,6 +30427,7 @@ MixpanelLib.prototype.reset = function() {
         '$device_id': uuid
     }, '');
     this._check_and_start_session_recording();
+    this.flags.reset();
 };
 
 /**