mixpanel-browser 2.74.0 → 2.75.0

package/dist/mixpanel-with-recorder.js

@@ -26,6 +26,16 @@
         win = window;
     }
 
+    /**
+     * Shared global window property names used across modules
+     */
+
+    // Targeting library global (used by flags and targeting modules)
+    var TARGETING_GLOBAL_NAME = '__mp_targeting';
+
+    // Recorder library global (used by recorder and mixpanel-core)
+    var RECORDER_GLOBAL_NAME = '__mp_recorder';
+
     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];
@@ -640,14 +650,16 @@
             return this.nodeMetaMap.get(n2) || null;
         };
         // removes the node from idNodeMap
-        // doesn't remove the node from nodeMetaMap
-        _proto.removeNodeFromMap = function removeNodeFromMap(n2) {
+        // if permanent is true, also removes from nodeMetaMap
+        _proto.removeNodeFromMap = function removeNodeFromMap(n2, permanent) {
             var _this = this;
+            if (permanent === void 0) permanent = false;
             var id = this.getId(n2);
             this.idNodeMap.delete(id);
+            if (permanent) this.nodeMetaMap.delete(n2);
             if (n2.childNodes) {
                 n2.childNodes.forEach(function(childNode) {
-                    return _this.removeNodeFromMap(childNode);
+                    return _this.removeNodeFromMap(childNode, permanent);
                 });
             }
         };
@@ -10389,6 +10401,15 @@
         _proto.generateId = function generateId() {
             return this.id++;
         };
+        _proto.remove = function remove(stylesheet) {
+            var id = this.styleIDMap.get(stylesheet);
+            if (id !== void 0) {
+                this.styleIDMap.delete(stylesheet);
+                this.idStyleMap.delete(id);
+                return true;
+            }
+            return false;
+        };
         return StyleSheetMirror;
     }();
     function getShadowHost(n2) {
@@ -10711,7 +10732,15 @@
                     }
                 };
                 while(_this.mapRemoves.length){
-                    _this.mirror.removeNodeFromMap(_this.mapRemoves.shift());
+                    var removedNode = _this.mapRemoves.shift();
+                    if (removedNode.nodeName === "IFRAME") {
+                        try {
+                            _this.iframeManager.removeIframe(removedNode);
+                        } catch (e2) {}
+                    } else {
+                        _this.stylesheetManager.cleanupStylesheetsForRemovedNode(removedNode);
+                    }
+                    _this.mirror.removeNodeFromMap(removedNode);
                 }
                 for(var _iterator = _create_for_of_iterator_helper_loose(_this.movedSet), _step; !(_step = _iterator()).done;){
                     var n2 = _step.value;
@@ -11085,6 +11114,9 @@
             this.shadowDomManager.reset();
             this.canvasManager.reset();
         };
+        _proto.getDoc = function getDoc() {
+            return this.doc;
+        };
         return MutationBuffer;
     }();
     function deepDelete(addsSet, n2) {
@@ -11185,6 +11217,14 @@
         });
         return observer;
     }
+    function removeMutationBufferForDoc(doc) {
+        for(var i2 = mutationBuffers.length - 1; i2 >= 0; i2--){
+            var buffer = mutationBuffers[i2];
+            if (buffer.getDoc() === doc) {
+                mutationBuffers.splice(i2, 1);
+            }
+        }
+    }
     function initMoveObserver(param) {
         var mousemoveCb = param.mousemoveCb, sampling = param.sampling, doc = param.doc, mirror2 = param.mirror;
         if (sampling.mousemove === false) {
@@ -12200,6 +12240,8 @@
             __publicField$1(this, "crossOriginIframeMirror", new CrossOriginIframeMirror(genId));
             __publicField$1(this, "crossOriginIframeStyleMirror");
             __publicField$1(this, "crossOriginIframeRootIdMap", /* @__PURE__ */ new WeakMap());
+            __publicField$1(this, "iframeContentDocumentMap", /* @__PURE__ */ new WeakMap());
+            __publicField$1(this, "iframeObserverCleanupMap", /* @__PURE__ */ new WeakMap());
             __publicField$1(this, "mirror");
             __publicField$1(this, "mutationCb");
             __publicField$1(this, "wrappedEmit");
@@ -12221,6 +12263,31 @@
             this.iframes.set(iframeEl, true);
             if (iframeEl.contentWindow) this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);
         };
+        _proto.getIframeContentDocument = function getIframeContentDocument(iframeEl) {
+            return this.iframeContentDocumentMap.get(iframeEl);
+        };
+        _proto.setObserverCleanup = function setObserverCleanup(iframeEl, cleanup) {
+            this.iframeObserverCleanupMap.set(iframeEl, cleanup);
+        };
+        _proto.getObserverCleanup = function getObserverCleanup(iframeEl) {
+            return this.iframeObserverCleanupMap.get(iframeEl);
+        };
+        _proto.removeIframe = function removeIframe(iframeEl) {
+            var storedDoc = this.iframeContentDocumentMap.get(iframeEl);
+            if (storedDoc) {
+                this.stylesheetManager.cleanupStylesheetsForRemovedNode(storedDoc);
+                this.mirror.removeNodeFromMap(storedDoc, true);
+            }
+            this.iframes.delete(iframeEl);
+            this.iframeContentDocumentMap.delete(iframeEl);
+            var observerCleanup = this.iframeObserverCleanupMap.get(iframeEl);
+            if (observerCleanup) {
+                try {
+                    observerCleanup();
+                } catch (e2) {}
+                this.iframeObserverCleanupMap.delete(iframeEl);
+            }
+        };
         _proto.addLoadListener = function addLoadListener(cb) {
             this.loadListener = cb;
         };
@@ -12239,6 +12306,9 @@
                 attributes: [],
                 isAttachIframe: true
             });
+            if (iframeEl.contentDocument) {
+                this.iframeContentDocumentMap.set(iframeEl, iframeEl.contentDocument);
+            }
             if (this.recordCrossOriginIframes) (_a2 = iframeEl.contentWindow) == null ? void 0 : _a2.addEventListener("message", this.handleMessage.bind(this));
             (_b = this.loadListener) == null ? void 0 : _b.call(this, iframeEl);
             if (iframeEl.contentDocument && iframeEl.contentDocument.adoptedStyleSheets && iframeEl.contentDocument.adoptedStyleSheets.length > 0) this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));
@@ -13151,6 +13221,41 @@
             this.styleMirror.reset();
             this.trackedLinkElements = /* @__PURE__ */ new WeakSet();
         };
+        /**
+       * Cleans up stylesheets associated with a removed node.
+       *
+       * @param removedNode - The node that was removed from the DOM.
+       */ _proto.cleanupStylesheetsForRemovedNode = function cleanupStylesheetsForRemovedNode(removedNode) {
+            var _this = this;
+            try {
+                if (removedNode.nodeType === Node.DOCUMENT_NODE) {
+                    var doc = removedNode;
+                    if (doc.adoptedStyleSheets) {
+                        for(var _iterator = _create_for_of_iterator_helper_loose(doc.adoptedStyleSheets), _step; !(_step = _iterator()).done;){
+                            var sheet = _step.value;
+                            this.styleMirror.remove(sheet);
+                        }
+                    }
+                }
+                if (removedNode.nodeName === "STYLE") {
+                    var styleEl = removedNode;
+                    if (styleEl.sheet) {
+                        this.styleMirror.remove(styleEl.sheet);
+                    }
+                }
+                if (removedNode.nodeName === "LINK" && removedNode.rel === "stylesheet") {
+                    var linkEl = removedNode;
+                    if (linkEl.sheet) {
+                        this.styleMirror.remove(linkEl.sheet);
+                    }
+                }
+                if (removedNode.childNodes) {
+                    removedNode.childNodes.forEach(function(child) {
+                        _this.cleanupStylesheetsForRemovedNode(child);
+                    });
+                }
+            } catch (e2) {}
+        };
         // TODO: take snapshot on stylesheet reload by applying event listener
         _proto.trackStylesheetInLinkElement = function trackStylesheetInLinkElement(_linkEl) {};
         return StylesheetManager;
@@ -13605,7 +13710,23 @@
             };
             iframeManager.addLoadListener(function(iframeEl) {
                 try {
-                    handlers.push(observe(iframeEl.contentDocument));
+                    var iframeDoc = iframeEl.contentDocument;
+                    var iframeHandler = observe(iframeDoc);
+                    handlers.push(iframeHandler);
+                    var existingCleanup = iframeManager.getObserverCleanup(iframeEl);
+                    iframeManager.setObserverCleanup(iframeEl, function() {
+                        if (existingCleanup) {
+                            try {
+                                existingCleanup();
+                            } catch (e2) {}
+                        }
+                        try {
+                            iframeHandler();
+                            var idx = handlers.indexOf(iframeHandler);
+                            if (idx !== -1) handlers.splice(idx, 1);
+                            removeMutationBufferForDoc(iframeDoc);
+                        } catch (e2) {}
+                    });
                 } catch (error) {
                     console.warn(error);
                 }
@@ -18854,7 +18975,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.74.0'
+        LIB_VERSION: '2.75.0'
     };
 
     /* eslint camelcase: "off", eqeqeq: "off" */
@@ -19060,15 +19181,8 @@
         return toString.call(obj) === '[object Array]';
     };
 
-    // from a comment on http://dbj.org/dbj/?p=286
-    // fails on only one very rare and deliberate custom object:
-    // var bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
     _.isFunction = function(f) {
-        try {
-            return /^\s*\bfunction\b/.test(f);
-        } catch (x) {
-            return false;
-        }
+        return typeof f === 'function';
     };
 
     _.isArguments = function(obj) {
@@ -23762,7 +23876,7 @@
         }
     });
 
-    win['__mp_recorder'] = MixpanelRecorder;
+    win[RECORDER_GLOBAL_NAME] = MixpanelRecorder;
 
     /** @const */ var DEFAULT_RAGE_CLICK_THRESHOLD_PX = 30;
     /** @const */ var DEFAULT_RAGE_CLICK_TIMEOUT_MS = 1000;
@@ -24733,14 +24847,62 @@
     // TODO integrate error_reporter from mixpanel instance
     safewrapClass(Autocapture);
 
-    var logger = console_with_prefix('flags');
+    /**
+     * Get the promise-based targeting loader
+     * @param {Function} loadExtraBundle - Function to load external bundle (callback-based)
+     * @param {string} targetingSrc - URL to targeting bundle
+     * @returns {Promise} Promise that resolves with targeting library
+     */
+    var getTargetingPromise = function(loadExtraBundle, targetingSrc) {
+        // Return existing promise if already initialized or loading
+        if (win[TARGETING_GLOBAL_NAME] && typeof win[TARGETING_GLOBAL_NAME].then === 'function') {
+            return win[TARGETING_GLOBAL_NAME];
+        }
+
+        // Create loading promise and set it as the global immediately
+        // This makes minified build behavior consistent with dev/CJS builds
+        win[TARGETING_GLOBAL_NAME] = new Promise(function (resolve) {
+            loadExtraBundle(targetingSrc, resolve);
+        }).then(function () {
+            var p = win[TARGETING_GLOBAL_NAME];
+            if (p && typeof p.then === 'function') {
+                return p;
+            }
+            throw new Error('targeting failed to load');
+        }).catch(function (err) {
+            delete win[TARGETING_GLOBAL_NAME];
+            throw err;
+        });
+
+        return win[TARGETING_GLOBAL_NAME];
+    };
 
+    var logger = console_with_prefix('flags');
     var FLAGS_CONFIG_KEY = 'flags';
 
     var CONFIG_CONTEXT = 'context';
     var CONFIG_DEFAULTS = {};
     CONFIG_DEFAULTS[CONFIG_CONTEXT] = {};
 
+    /**
+     * Generate a unique key for a pending first-time event
+     * @param {string} flagKey - The flag key
+     * @param {string} firstTimeEventHash - The first_time_event_hash from the pending event definition
+     * @returns {string} Composite key in format "flagKey:firstTimeEventHash"
+     */
+    var getPendingEventKey = function(flagKey, firstTimeEventHash) {
+        return flagKey + ':' + firstTimeEventHash;
+    };
+
+    /**
+     * Extract the flag key from a pending event key
+     * @param {string} eventKey - The composite event key in format "flagKey:firstTimeEventHash"
+     * @returns {string} The flag key portion
+     */
+    var getFlagKeyFromPendingEventKey = function(eventKey) {
+        return eventKey.split(':')[0];
+    };
+
     /**
      * FeatureFlagManager: support for Mixpanel's feature flagging product
      * @constructor
@@ -24752,6 +24914,8 @@
         this.setMpConfig = initOptions.setConfigFunc;
         this.getMpProperty = initOptions.getPropertyFunc;
         this.track = initOptions.trackingFunc;
+        this.loadExtraBundle = initOptions.loadExtraBundle || function() {};
+        this.targetingSrc = initOptions.targetingSrc || '';
     };
 
     FeatureFlagManager.prototype.init = function() {
@@ -24764,6 +24928,8 @@
         this.fetchFlags();
 
         this.trackedFeatures = new Set();
+        this.pendingFirstTimeEvents = {};
+        this.activatedFirstTimeEvents = {};
     };
 
     FeatureFlagManager.prototype.getFullConfig = function() {
@@ -24844,17 +25010,78 @@
                     throw new Error('No flags in API response');
                 }
                 var flags = new Map();
+                var pendingFirstTimeEvents = {};
+
+                // Process flags from response
                 _.each(responseFlags, function(data, key) {
-                    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']
+                    // 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']
+                        });
+                    }
+                }, 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']);
+
+                        // 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);
+                }
+
+                // 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._loadTargetingIfNeeded();
             }.bind(this)).catch(function(error) {
                 this.markFetchComplete();
                 logger.error(error);
@@ -24878,6 +25105,177 @@
         this._fetchInProgressStartTime = null;
     };
 
+    /**
+     * Proactively load targeting bundle if any pending events have property filters
+     */
+    FeatureFlagManager.prototype._loadTargetingIfNeeded = function() {
+        var hasPropertyFilters = false;
+        _.each(this.pendingFirstTimeEvents, function(evt) {
+            if (evt['property_filters'] && !_.isEmptyObject(evt['property_filters'])) {
+                hasPropertyFilters = true;
+            }
+        });
+
+        if (hasPropertyFilters) {
+            this.getTargeting().then(function() {
+                logger.log('targeting loaded for property filter evaluation');
+            });
+        }
+    };
+
+    /**
+     * Get the targeting library (initializes if not already loaded)
+     * This method is primarily for testing - production code should rely on automatic loading
+     * @returns {Promise} Promise that resolves with targeting library
+     */
+    FeatureFlagManager.prototype.getTargeting = function() {
+        return getTargetingPromise(
+            this.loadExtraBundle.bind(this),
+            this.targetingSrc
+        ).catch(function(error) {
+            logger.error('Failed to load targeting: ' + error);
+        }.bind(this));
+    };
+
+    /**
+     * Check if a tracked event matches any pending first-time events and activate the corresponding flag variant
+     * @param {string} eventName - The name of the event being tracked
+     * @param {Object} properties - Event properties to evaluate against property filters
+     *
+     * When a match is found (event name matches and property filters pass), this method:
+     * - Switches the flag to the pending variant
+     * - Marks the event as activated for this session
+     * - Records the activation via the API (fire-and-forget)
+     */
+    FeatureFlagManager.prototype.checkFirstTimeEvents = function(eventName, properties) {
+        if (!this.pendingFirstTimeEvents || _.isEmptyObject(this.pendingFirstTimeEvents)) {
+            return;
+        }
+
+        // Check if targeting promise exists (either bundled or async loaded)
+        if (win[TARGETING_GLOBAL_NAME] && _.isFunction(win[TARGETING_GLOBAL_NAME].then)) {
+            win[TARGETING_GLOBAL_NAME].then(function(library) {
+                this._processFirstTimeEventCheck(eventName, properties, library);
+            }.bind(this)).catch(function() {
+                // If targeting failed to load, process with null
+                // Events without property filters will still match
+                this._processFirstTimeEventCheck(eventName, properties, null);
+            }.bind(this));
+        } else {
+            // No targeting available, process with null
+            // Events without property filters will still match
+            this._processFirstTimeEventCheck(eventName, properties, null);
+        }
+    };
+
+    /**
+     * Internal method to process first-time event checks with loaded targeting library
+     * @param {string} eventName - The name of the event being tracked
+     * @param {Object} properties - Event properties to evaluate against property filters
+     * @param {Object} targeting - The loaded targeting library
+     */
+    FeatureFlagManager.prototype._processFirstTimeEventCheck = function(eventName, properties, targeting) {
+        _.each(this.pendingFirstTimeEvents, function(pendingEvent, eventKey) {
+            if (this.activatedFirstTimeEvents[eventKey]) {
+                return;
+            }
+
+            var flagKey = pendingEvent['flag_key'];
+
+            // Use targeting module to check if event matches
+            var matchResult;
+
+            // 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');
+                return;
+            }
+
+            // For simple events (no property filters), just check event name
+            if (!targeting) {
+                matchResult = {
+                    matches: eventName === pendingEvent['event_name'],
+                    error: null
+                };
+            } else {
+                var criteria = {
+                    'event_name': pendingEvent['event_name'],
+                    'property_filters': pendingEvent['property_filters']
+                };
+                matchResult = targeting['eventMatchesCriteria'](
+                    eventName,
+                    properties,
+                    criteria
+                );
+            }
+
+            if (matchResult.error) {
+                logger.error('Error checking first-time event for flag "' + flagKey + '": ' + matchResult.error);
+                return;
+            }
+
+            if (!matchResult.matches) {
+                return;
+            }
+
+            logger.log('First-time event matched for flag "' + flagKey + '": ' + eventName);
+
+            var newVariant = {
+                'key': pendingEvent['pending_variant']['variant_key'],
+                'value': pendingEvent['pending_variant']['variant_value'],
+                'experiment_id': pendingEvent['pending_variant']['experiment_id'],
+                'is_experiment_active': pendingEvent['pending_variant']['is_experiment_active']
+            };
+
+            this.flags.set(flagKey, newVariant);
+            this.activatedFirstTimeEvents[eventKey] = true;
+
+            this.recordFirstTimeEvent(
+                pendingEvent['flag_id'],
+                pendingEvent['project_id'],
+                pendingEvent['first_time_event_hash']
+            );
+        }, this);
+    };
+
+    FeatureFlagManager.prototype.getFirstTimeEventApiRoute = function(flagId) {
+        // Construct URL: {api_host}/flags/{flagId}/first-time-events
+        return this.getFullApiRoute() + '/' + flagId + '/first-time-events';
+    };
+
+    FeatureFlagManager.prototype.recordFirstTimeEvent = function(flagId, projectId, firstTimeEventHash) {
+        var distinctId = this.getMpProperty('distinct_id');
+        var traceparent = generateTraceparent();
+
+        // Build URL with query string parameters
+        var searchParams = new URLSearchParams();
+        searchParams.set('mp_lib', 'web');
+        searchParams.set('$lib_version', Config.LIB_VERSION);
+        var url = this.getFirstTimeEventApiRoute(flagId) + '?' + searchParams.toString();
+
+        var payload = {
+            'distinct_id': distinctId,
+            'project_id': projectId,
+            'first_time_event_hash': firstTimeEventHash
+        };
+
+        logger.log('Recording first-time event for flag: ' + flagId);
+
+        // Fire-and-forget POST request
+        this.fetch.call(win, url, {
+            'method': 'POST',
+            'headers': {
+                'Content-Type': 'application/json',
+                'Authorization': 'Basic ' + btoa(this.getMpConfig('token') + ':'),
+                'traceparent': traceparent
+            },
+            '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);
+        });
+    };
+
     FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
         if (!this.fetchPromise) {
             return new Promise(function(resolve) {
@@ -24996,6 +25394,9 @@
     // Deprecated method
     FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
 
+    // Exports intended only for testing
+    FeatureFlagManager.prototype['getTargeting'] = FeatureFlagManager.prototype.getTargeting;
+
     /* eslint camelcase: "off" */
 
 
@@ -26465,6 +26866,7 @@
         'record_min_ms':                     0,
         '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',
         'remote_settings_mode':              SETTING_DISABLED // 'strict', 'fallback', 'disabled'
     };
 
@@ -26694,7 +27096,9 @@
             getConfigFunc: _.bind(this.get_config, this),
             setConfigFunc: _.bind(this.set_config, this),
             getPropertyFunc: _.bind(this.get_property, this),
-            trackingFunc: _.bind(this.track, this)
+            trackingFunc: _.bind(this.track, this),
+            loadExtraBundle: load_extra_bundle,
+            targetingSrc: this.get_config('targeting_src')
         });
         this.flags.init();
         this['flags'] = this.flags;
@@ -26790,11 +27194,11 @@
 
         var loadRecorder = _.bind(function(startNewIfInactive) {
             var handleLoadedRecorder = _.bind(function() {
-                this._recorder = this._recorder || new win['__mp_recorder'](this);
+                this._recorder = this._recorder || new win[RECORDER_GLOBAL_NAME](this);
                 this._recorder['resumeRecording'](startNewIfInactive);
             }, this);
 
-            if (_.isUndefined(win['__mp_recorder'])) {
+            if (_.isUndefined(win[RECORDER_GLOBAL_NAME])) {
                 load_extra_bundle(this.get_config('recorder_src'), handleLoadedRecorder);
             } else {
                 handleLoadedRecorder();
@@ -27536,6 +27940,11 @@
             send_request_options: options
         }, callback);
 
+        // Check for first-time event matches
+        if (this.flags && this.flags.checkFirstTimeEvents) {
+            this.flags.checkFirstTimeEvents(event_name, properties);
+        }
+
         return ret;
     });